@openscout/scout 0.2.68 → 0.2.69

package/dist/main.mjs

@@ -815,6 +815,17 @@ function assertValidUnblockRequestEvent(event, record) {
     throw new Error(errors.join("; "));
   }
 }
+// ../protocol/src/lifecycle.ts
+var TERMINAL_INVOCATION_STATES;
+var init_lifecycle = __esm(() => {
+  TERMINAL_INVOCATION_STATES = new Set([
+    "completed",
+    "failed",
+    "cancelled",
+    "expired"
+  ]);
+});
+
 // ../protocol/src/permission-policy.ts
 function normalizeScoutPermissionProfile(value) {
   const normalized = value?.trim().replaceAll("-", "_");
@@ -901,6 +912,9 @@ function parsePrefixedRouteTarget(prefix, rawValue) {
   if (prefix === "id" || prefix === "agent-id" || prefix === "agent_id") {
     return { kind: "agent_id", agentId: value, value: `id:${value}` };
   }
+  if (prefix === "session" || prefix === "session-id" || prefix === "session_id" || prefix === "s") {
+    return { kind: "session_id", sessionId: value, value: `session:${value}` };
+  }
   if (prefix === "channel" || prefix === "chan" || prefix === "ch") {
     return { kind: "channel", channel: value, value: `channel:${value}` };
   }
@@ -1003,15 +1017,20 @@ var init_inbox = __esm(() => {
     "deferred"
   ];
 });
+// ../protocol/src/cursor-transport.ts
+var init_cursor_transport = () => {};
+
 // ../protocol/src/index.ts
 var init_src = __esm(() => {
   init_agent_identity();
   init_agent_address();
   init_agent_selectors();
+  init_lifecycle();
   init_agent_runs();
   init_scout_composer();
   init_inbox();
   init_permission_policy();
+  init_cursor_transport();
 });
 
 // ../../apps/desktop/src/cli/options.ts
@@ -1140,6 +1159,15 @@ function parseComposerRoutedBody(input, commandName, currentDirectory) {
       message: parsed.body
     };
   }
+  if (target.kind === "session_id") {
+    if (commandName === "send") {
+      throw new ScoutCliError("send route operator must target an agent label, ref, channel, or broadcast");
+    }
+    return {
+      targetLabel: `session:${target.sessionId}`,
+      message: parsed.body
+    };
+  }
   if (target.kind === "project_path") {
     if (commandName === "send") {
       throw new ScoutCliError("send route operator must target an agent label, ref, channel, or broadcast");
@@ -1627,6 +1655,7 @@ function parseChannelCommandOptions(args, defaultCurrentDirectory) {
   const parsed = parseContextRootPrefix(args, defaultCurrentDirectory);
   let channel;
   let latest;
+  let markRead = false;
   for (let index = 0;index < parsed.args.length; index += 1) {
     const current = parsed.args[index] ?? "";
     if (current === "--channel" || current.startsWith("--channel=")) {
@@ -1645,20 +1674,28 @@ function parseChannelCommandOptions(args, defaultCurrentDirectory) {
       index = value.nextIndex;
       continue;
     }
+    if (current === "--mark-read" || current === "--read" || current === "--clear") {
+      markRead = true;
+      continue;
+    }
     if (!current.startsWith("-") && !channel) {
       channel = current;
       continue;
     }
     unexpectedArgs("channel", args);
   }
-  if (channel && !latest) {
-    throw new ScoutCliError("channel name is only valid with --latest");
+  if (latest && markRead) {
+    throw new ScoutCliError("provide either --latest or --mark-read, not both");
+  }
+  if (channel && !latest && !markRead) {
+    throw new ScoutCliError("channel name is only valid with --latest or --mark-read");
   }
   return {
     currentDirectory: parsed.currentDirectory,
     args: parsed.args,
     channel,
-    latest
+    latest,
+    markRead
   };
 }
 function parseInboxCommandOptions(args, defaultCurrentDirectory) {
@@ -1805,6 +1842,7 @@ function parseCardCreateCommandOptions(args, defaultCurrentDirectory) {
   let permissionProfile;
   let requesterId = null;
   let noInput = false;
+  let oneTimeUse = false;
   for (let index = 0;index < parsed.args.length; index += 1) {
     const current = parsed.args[index] ?? "";
     if (current === "--name" || current.startsWith("--name=")) {
@@ -1868,6 +1906,10 @@ function parseCardCreateCommandOptions(args, defaultCurrentDirectory) {
       noInput = true;
       continue;
     }
+    if (current === "--one-time") {
+      oneTimeUse = true;
+      continue;
+    }
     if (current.startsWith("--")) {
       unexpectedArgs("card create", args);
     }
@@ -1887,7 +1929,8 @@ function parseCardCreateCommandOptions(args, defaultCurrentDirectory) {
     reasoningEffort,
     permissionProfile,
     requesterId,
-    noInput
+    noInput,
+    oneTimeUse
   };
 }
 function parseTuiCommandOptions(args, defaultCurrentDirectory) {
@@ -6209,6 +6252,15 @@ async function maybeReadJsonFromActiveScoutBrokerService(baseUrl, path) {
       includeAcknowledged: url.searchParams.get("includeAcknowledged") === "1" || url.searchParams.get("includeAcknowledged") === "true"
     }));
   }
+  const invocationLifecycleMatch = url.pathname.match(/^\/v1\/invocations\/([^/]+)\/lifecycle$/);
+  if (invocationLifecycleMatch) {
+    if (!service.readInvocationLifecycle) {
+      return unhandled();
+    }
+    return handled(await service.readInvocationLifecycle({
+      invocationId: decodeURIComponent(invocationLifecycleMatch[1] ?? "")
+    }));
+  }
   if (url.pathname === "/v1/activity") {
     if (!service.readActivity) {
       return unhandled();
@@ -7089,6 +7141,17 @@ async function fetchHealthSnapshot(config) {
         nodes: payload.counts.nodes ?? 0,
         actors: payload.counts.actors ?? 0,
         agents: payload.counts.agents ?? 0,
+        agentRecords: payload.counts.agentRecords,
+        rawAgentRecords: payload.counts.rawAgentRecords,
+        configuredAgents: payload.counts.configuredAgents,
+        scoutManagedAgents: payload.counts.scoutManagedAgents,
+        currentAgentRegistrations: payload.counts.currentAgentRegistrations,
+        localAgentRegistrations: payload.counts.localAgentRegistrations,
+        remoteAgentRegistrations: payload.counts.remoteAgentRegistrations,
+        staleAgentRegistrations: payload.counts.staleAgentRegistrations,
+        retiredAgentRegistrations: payload.counts.retiredAgentRegistrations,
+        oneTimeAgentCards: payload.counts.oneTimeAgentCards,
+        persistentAgentCards: payload.counts.persistentAgentCards,
         conversations: payload.counts.conversations ?? 0,
         messages: payload.counts.messages ?? 0,
         flights: payload.counts.flights ?? 0,
@@ -7261,6 +7324,9 @@ var init_broker_process_manager = __esm(() => {
   }
 });
 
+// ../runtime/src/dispatch-stalled.ts
+var init_dispatch_stalled = () => {};
+
 // ../runtime/src/managed-agent-environment.ts
 function managedAgentEnvironmentEntries(options) {
   const agentName = options.agentName.trim();
@@ -13525,6 +13591,15 @@ function readCodexAppServerReasoningEffortFromLaunchArgs(launchArgs) {
   }
   return null;
 }
+function codexAppServerExitMessage(input) {
+  if (input.exitKind === "proactive_shutdown") {
+    return `Codex app-server session for ${input.agentName} was stopped by OpenScout` + (input.reason ? `: ${input.reason}` : "") + ".";
+  }
+  if (input.exitKind === "external_sigterm") {
+    return `Codex app-server for ${input.agentName} was interrupted by SIGTERM.`;
+  }
+  return `Codex app-server exited for ${input.agentName}` + (input.exitCode !== null ? ` with code ${input.exitCode}` : "") + (input.signal ? ` (${input.signal})` : "");
+}
 function resolveRequesterTimeoutMs2(timeoutMs) {
   if (typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0) {
     return timeoutMs;
@@ -13696,6 +13771,7 @@ class CodexAppServerSession {
   activeTurn = null;
   threadId = null;
   threadPath = null;
+  proactiveShutdown = null;
   lastConfigSignature;
   constructor(options) {
     this.options = options;
@@ -13826,13 +13902,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;
@@ -13842,7 +13928,7 @@ class CodexAppServerSession {
     if (child && child.exitCode === null && !child.killed) {
       child.kill("SIGTERM");
       await new Promise((resolve8) => setTimeout(resolve8, 250));
-      if (child.exitCode === null && !child.killed) {
+      if (child.exitCode === null && child.signalCode === null) {
         child.kill("SIGKILL");
       }
     }
@@ -13893,6 +13979,7 @@ class CodexAppServerSession {
     await mkdir5(this.options.runtimeDirectory, { recursive: true });
     await mkdir5(this.options.logsDirectory, { recursive: true });
     await writeFile5(join14(this.options.runtimeDirectory, "prompt.txt"), this.options.systemPrompt);
+    this.proactiveShutdown = null;
     const codexExecutable = resolveCodexExecutable();
     const launchArgs = normalizeCodexAppServerLaunchArgs(this.options.launchArgs);
     const env = buildManagedAgentEnvironment({
@@ -13932,7 +14019,16 @@ class CodexAppServerSession {
       this.failSession(new Error(`Codex app-server failed for ${this.options.agentName}: ${errorMessage4(error)}`));
     });
     child.once("exit", (code, signal) => {
-      this.failSession(new Error(`Codex app-server exited for ${this.options.agentName}` + (code !== null ? ` with code ${code}` : "") + (signal ? ` (${signal})` : "")));
+      const proactiveShutdown = this.proactiveShutdown;
+      if (proactiveShutdown) {
+        this.handleProactiveProcessExit(child, proactiveShutdown, code, signal);
+        return;
+      }
+      this.failSession(new CodexAppServerExitError({
+        agentName: this.options.agentName,
+        exitCode: code,
+        signal
+      }));
     });
     await this.request("initialize", {
       clientInfo: {
@@ -14267,6 +14363,23 @@ class CodexAppServerSession {
     }
     this.pendingRequests.clear();
     appendFile3(this.stderrLogPath, `[openscout] ${error.message}
+`).catch(() => {
+      return;
+    });
+    this.persistState();
+  }
+  handleProactiveProcessExit(child, shutdown, code, signal) {
+    if (this.process === child) {
+      this.process = null;
+    }
+    this.proactiveShutdown = null;
+    this.starting = null;
+    const exitDetail = [
+      code !== null ? `code ${code}` : null,
+      signal
+    ].filter(Boolean).join(", ");
+    const detail = exitDetail ? ` (${exitDetail})` : "";
+    appendFile3(this.stderrLogPath, `[openscout] Codex app-server stopped for ${this.options.agentName}: ${shutdown.reason}${detail}
 `).catch(() => {
       return;
     });
@@ -14337,7 +14450,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);
@@ -14368,13 +14484,36 @@ async function shutdownCodexAppServerAgent(options, shutdownOptions = {}) {
   sessions2.delete(key);
   await session.shutdown(shutdownOptions);
 }
-var SESSION_CATALOG_FILENAME2 = "session-catalog.json", SESSION_CATALOG_MAX_ENTRIES2 = 64, CODEX_ROLLOUT_STALE_ACTIVE_TURN_MS, sessions2;
+var CodexAppServerExitError, SESSION_CATALOG_FILENAME2 = "session-catalog.json", SESSION_CATALOG_MAX_ENTRIES2 = 64, CODEX_ROLLOUT_STALE_ACTIVE_TURN_MS, sessions2;
 var init_codex_app_server = __esm(() => {
   init_src2();
   init_topology();
   init_codex_executable();
   init_requester_timeout();
   init_codex_executable();
+  CodexAppServerExitError = class CodexAppServerExitError extends Error {
+    code = "CODEX_APP_SERVER_EXIT";
+    exitKind;
+    agentName;
+    exitCode;
+    signal;
+    reason;
+    noteworthy;
+    constructor(input) {
+      const exitKind = input.exitKind ?? (input.signal === "SIGTERM" ? "external_sigterm" : "unexpected_exit");
+      super(codexAppServerExitMessage({
+        ...input,
+        exitKind
+      }));
+      this.name = "CodexAppServerExitError";
+      this.exitKind = exitKind;
+      this.agentName = input.agentName;
+      this.exitCode = input.exitCode;
+      this.signal = input.signal;
+      this.reason = input.reason ?? null;
+      this.noteworthy = exitKind !== "unexpected_exit";
+    }
+  };
   CODEX_ROLLOUT_STALE_ACTIVE_TURN_MS = 10 * 60 * 1000;
   sessions2 = new Map;
 });
@@ -14470,11 +14609,47 @@ var init_permission_policy2 = __esm(() => {
   init_src();
 });
 
+// ../runtime/src/user-config.ts
+import { existsSync as existsSync11, readFileSync as readFileSync6, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { homedir as homedir12 } from "os";
+import { dirname as dirname8, join as join15 } from "path";
+function userConfigPath() {
+  return join15(process.env.OPENSCOUT_HOME ?? join15(homedir12(), ".openscout"), "user.json");
+}
+function loadUserConfig() {
+  const configPath = userConfigPath();
+  if (!existsSync11(configPath))
+    return {};
+  try {
+    return JSON.parse(readFileSync6(configPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveUserConfig(config) {
+  const configPath = userConfigPath();
+  mkdirSync3(dirname8(configPath), { recursive: true });
+  writeFileSync3(configPath, JSON.stringify(config, null, 2) + `
+`, "utf8");
+}
+function resolveOperatorName() {
+  const config = loadUserConfig();
+  return config.name?.trim() || process.env.OPENSCOUT_OPERATOR_NAME?.trim() || process.env.USER?.trim() || "operator";
+}
+function normalizeHandle(value) {
+  return value?.trim().replace(/^@+/, "") ?? "";
+}
+function resolveOperatorHandle() {
+  const config = loadUserConfig();
+  return normalizeHandle(config.handle) || normalizeHandle(process.env.OPENSCOUT_OPERATOR_HANDLE) || normalizeHandle(config.name) || normalizeHandle(process.env.OPENSCOUT_OPERATOR_NAME) || normalizeHandle(process.env.USER) || "operator";
+}
+var init_user_config = () => {};
+
 // ../runtime/src/local-agents.ts
 import { execFileSync as execFileSync4, execSync } from "child_process";
-import { existsSync as existsSync11, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
 import { mkdir as mkdir6, rm as rm5, stat as stat3, writeFile as writeFile6 } from "fs/promises";
-import { basename as basename7, dirname as dirname8, join as join15, resolve as resolve8 } from "path";
+import { basename as basename7, dirname as dirname9, join as join16, resolve as resolve8 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 function resolveRelayHub() {
   return resolveOpenScoutSupportPaths().relayHubDirectory;
@@ -14485,14 +14660,14 @@ function resolveProjectsRoot(projectPath) {
   }
   try {
     const supportPaths = resolveOpenScoutSupportPaths();
-    if (!existsSync11(supportPaths.settingsPath)) {
-      return dirname8(projectPath);
+    if (!existsSync12(supportPaths.settingsPath)) {
+      return dirname9(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 ? resolve8(workspaceRoot) : dirname8(projectPath);
+    return workspaceRoot ? resolve8(workspaceRoot) : dirname9(projectPath);
   } catch {
-    return dirname8(projectPath);
+    return dirname9(projectPath);
   }
 }
 function resolveBrokerUrl() {
@@ -14502,7 +14677,7 @@ function nowSeconds2() {
   return Math.floor(Date.now() / 1000);
 }
 function scoutCliPath() {
-  return join15(OPENSCOUT_REPO_ROOT, "packages", "cli", "bin", "scout.mjs");
+  return join16(OPENSCOUT_REPO_ROOT, "packages", "cli", "bin", "scout.mjs");
 }
 function legacyNodeBrokerRelayCommand() {
   return `node ${JSON.stringify(scoutCliPath())}`;
@@ -14515,13 +14690,13 @@ function titleCaseLocalAgentName(value) {
 }
 function resolveScoutSkillPath() {
   const candidatePaths = [
-    join15(OPENSCOUT_REPO_ROOT, ".agents", "skills", "scout", "SKILL.md"),
-    join15(process.env.HOME ?? "", ".agents", "skills", "scout", "SKILL.md"),
-    join15(OPENSCOUT_REPO_ROOT, ".agents", "skills", "relay-agent-comms", "SKILL.md"),
-    join15(process.env.HOME ?? "", ".agents", "skills", "relay-agent-comms", "SKILL.md")
+    join16(OPENSCOUT_REPO_ROOT, ".agents", "skills", "scout", "SKILL.md"),
+    join16(process.env.HOME ?? "", ".agents", "skills", "scout", "SKILL.md"),
+    join16(OPENSCOUT_REPO_ROOT, ".agents", "skills", "relay-agent-comms", "SKILL.md"),
+    join16(process.env.HOME ?? "", ".agents", "skills", "relay-agent-comms", "SKILL.md")
   ];
   for (const path of candidatePaths) {
-    if (existsSync11(path)) {
+    if (existsSync12(path)) {
       return path;
     }
   }
@@ -14629,6 +14804,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);
@@ -14783,13 +15026,20 @@ function expandHomePath4(value) {
     return process.env.HOME ?? process.cwd();
   }
   if (value.startsWith("~/")) {
-    return join15(process.env.HOME ?? process.cwd(), value.slice(2));
+    return join16(process.env.HOME ?? process.cwd(), value.slice(2));
   }
   return value;
 }
 function normalizeProjectPath(value) {
   return resolve8(expandHomePath4(value.trim() || "."));
 }
+function compactHomePath(value) {
+  const home = process.env.HOME;
+  if (!home) {
+    return value;
+  }
+  return value.startsWith(home) ? value.replace(home, "~") : value;
+}
 function normalizeTmuxSessionName2(value, agentId) {
   const fallback = `relay-${agentId}`;
   const trimmed = value?.trim() ?? "";
@@ -15043,6 +15293,21 @@ function applyRequestedRuntimeOptionsToLaunchArgs(harness, launchArgs, options)
     ...buildLaunchArgsForRequestedReasoningEffort(harness, requestedReasoningEffort)
   ];
 }
+function setLaunchModelForHarness(harness, launchArgs, model) {
+  const normalized = normalizeLaunchArgsForHarness(harness, launchArgs);
+  if (model === undefined) {
+    return normalized;
+  }
+  const stripped = stripLaunchModelForHarness(harness, normalized);
+  const requestedModel = normalizeRequestedModel(model ?? undefined);
+  if (!requestedModel) {
+    return stripped;
+  }
+  return [
+    ...stripped,
+    ...buildLaunchArgsForRequestedModel(harness, requestedModel)
+  ];
+}
 function defaultHarnessForOverride(override, fallback = "claude") {
   return normalizeManagedHarness2(override.defaultHarness ?? override.runtime?.harness, fallback);
 }
@@ -15163,6 +15428,31 @@ function recordForHarness(record, harnessOverride) {
     permissionProfile: profile.permissionProfile
   };
 }
+function normalizeCardTimestamp(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : undefined;
+}
+function normalizeLocalAgentCardLifecycle(value, now = Date.now()) {
+  if (!value) {
+    return;
+  }
+  const kind = value.kind === "one_time" ? "one_time" : value.kind === "persistent" ? "persistent" : undefined;
+  if (!kind) {
+    return;
+  }
+  const createdAt = normalizeCardTimestamp(value.createdAt) ?? now;
+  const expiresAt = normalizeCardTimestamp(value.expiresAt);
+  const maxUses = typeof value.maxUses === "number" && Number.isFinite(value.maxUses) && value.maxUses > 0 ? Math.floor(value.maxUses) : undefined;
+  const createdById = value.createdById?.trim();
+  const inboxConversationId = value.inboxConversationId?.trim();
+  return {
+    kind,
+    createdAt,
+    ...createdById ? { createdById } : {},
+    ...expiresAt ? { expiresAt } : {},
+    ...maxUses ? { maxUses } : {},
+    ...inboxConversationId ? { inboxConversationId } : {}
+  };
+}
 function normalizeLocalAgentRecord(agentId, record) {
   const cwd = normalizeProjectPath(record.cwd || process.cwd());
   const projectRoot = normalizeProjectPath(record.projectRoot || cwd);
@@ -15192,7 +15482,8 @@ function normalizeLocalAgentRecord(agentId, record) {
     capabilities: normalizeLocalAgentCapabilities(record.capabilities),
     launchArgs: activeProfile?.launchArgs ?? normalizeLaunchArgsForHarness(harness, record.launchArgs),
     permissionProfile: activeProfile?.permissionProfile ?? record.permissionProfile,
-    registrationSource: record.registrationSource
+    registrationSource: record.registrationSource,
+    card: normalizeLocalAgentCardLifecycle(record.card)
   };
 }
 function localAgentStatusFromRecord(agentId, record, source) {
@@ -15246,7 +15537,8 @@ function localAgentRecordFromRelayAgentOverride(agentId, override) {
     harnessProfiles: override.harnessProfiles,
     transport: normalizeLocalAgentTransport(override.runtime?.transport, normalizeLocalAgentHarness(override.runtime?.harness)),
     capabilities: override.capabilities,
-    launchArgs: override.launchArgs
+    launchArgs: override.launchArgs,
+    card: override.card
   });
 }
 function relayAgentOverrideFromLocalAgentRecord(agentId, record, existing) {
@@ -15267,6 +15559,7 @@ function relayAgentOverrideFromLocalAgentRecord(agentId, record, existing) {
     capabilities: normalizeLocalAgentCapabilities(normalizedRecord.capabilities),
     defaultHarness: normalizeManagedHarness2(normalizedRecord.defaultHarness, "claude"),
     harnessProfiles: normalizedRecord.harnessProfiles,
+    ...normalizedRecord.card ? { card: normalizedRecord.card } : {},
     runtime: {
       cwd: normalizeProjectPath(normalizedRecord.cwd),
       harness: normalizeLocalAgentHarness(normalizedRecord.harness),
@@ -15276,6 +15569,245 @@ function relayAgentOverrideFromLocalAgentRecord(agentId, record, existing) {
     }
   };
 }
+function buildLocalAgentConfigState(agentId, record) {
+  const harness = normalizeLocalAgentHarness(record.harness);
+  const launchArgs = normalizeLaunchArgsForHarness(harness, record.launchArgs);
+  return {
+    agentId,
+    editable: true,
+    model: readLaunchModelForHarness(harness, launchArgs) ?? null,
+    permissionProfile: record.permissionProfile ?? null,
+    systemPrompt: record.systemPrompt || buildLocalAgentSystemPromptTemplate(),
+    runtime: {
+      cwd: compactHomePath(record.cwd),
+      harness,
+      transport: normalizeLocalAgentTransport(record.transport, harness),
+      sessionId: record.tmuxSession,
+      wakePolicy: "on_demand"
+    },
+    launchArgs,
+    capabilities: normalizeLocalAgentCapabilities(record.capabilities),
+    applyMode: "restart",
+    templateHint: LOCAL_AGENT_SYSTEM_PROMPT_TEMPLATE_HINT
+  };
+}
+async function assertDirectoryExists(directory) {
+  const stats = await stat3(directory);
+  if (!stats.isDirectory()) {
+    throw new Error(`${directory} is not a directory.`);
+  }
+}
+async function resolveConfiguredLocalAgentRecord(agentId) {
+  const overrides = await readRelayAgentOverrides();
+  const override = overrides[agentId];
+  if (override) {
+    return localAgentRecordFromRelayAgentOverride(agentId, override);
+  }
+  const registry = await readLocalAgentRegistry();
+  const record = registry[agentId];
+  return record ? normalizeLocalAgentRecord(agentId, record) : null;
+}
+async function getLocalAgentConfig(agentId) {
+  const record = await resolveConfiguredLocalAgentRecord(agentId);
+  if (!record) {
+    return null;
+  }
+  return buildLocalAgentConfigState(agentId, record);
+}
+function defaultLocalAgentSessionId(agentId, harness) {
+  return normalizeTmuxSessionName2(undefined, `${agentId}-${harness}`);
+}
+async function updateLocalAgentCard(agentId, input) {
+  const existing = await getLocalAgentConfig(agentId);
+  if (!existing) {
+    return null;
+  }
+  const nextHarness = input.harness ? normalizeLocalAgentHarness(input.harness) : existing.runtime.harness;
+  const harnessChanged = nextHarness !== existing.runtime.harness;
+  const model = input.model === undefined ? harnessChanged ? null : undefined : input.model;
+  return updateLocalAgentConfig(agentId, {
+    runtime: {
+      cwd: existing.runtime.cwd,
+      harness: nextHarness,
+      transport: harnessChanged ? normalizeLocalAgentTransport(undefined, nextHarness) : existing.runtime.transport,
+      sessionId: harnessChanged ? defaultLocalAgentSessionId(agentId, nextHarness) : existing.runtime.sessionId
+    },
+    systemPrompt: existing.systemPrompt,
+    launchArgs: harnessChanged ? [] : existing.launchArgs,
+    model,
+    reasoningEffort: input.reasoningEffort,
+    permissionProfile: input.permissionProfile,
+    capabilities: existing.capabilities
+  });
+}
+async function updateLocalAgentConfig(agentId, input) {
+  const [registry, overrides] = await Promise.all([
+    readLocalAgentRegistry(),
+    readRelayAgentOverrides()
+  ]);
+  const record = registry[agentId] ?? (overrides[agentId] ? localAgentRecordFromRelayAgentOverride(agentId, overrides[agentId]) : undefined);
+  if (!record) {
+    return null;
+  }
+  const cwd = normalizeProjectPath(input.runtime.cwd || record.cwd);
+  await assertDirectoryExists(cwd);
+  const nextHarness = normalizeLocalAgentHarness(input.runtime.harness);
+  const nextTransport = normalizeLocalAgentTransport(input.runtime.transport ?? record.transport, nextHarness);
+  let nextLaunchArgs = setLaunchModelForHarness(nextHarness, input.launchArgs, input.model);
+  if (input.reasoningEffort !== undefined) {
+    const stripped = stripLaunchReasoningEffortForHarness(nextHarness, nextLaunchArgs);
+    const requestedReasoningEffort = normalizeRequestedReasoningEffort(input.reasoningEffort ?? undefined);
+    nextLaunchArgs = requestedReasoningEffort ? [
+      ...stripped,
+      ...buildLaunchArgsForRequestedReasoningEffort(nextHarness, requestedReasoningEffort)
+    ] : stripped;
+  }
+  const nextPermissionProfile = input.permissionProfile === undefined ? record.permissionProfile : input.permissionProfile === null ? undefined : parseScoutPermissionProfile(input.permissionProfile);
+  const nextRecord = normalizeLocalAgentRecord(agentId, {
+    ...record,
+    cwd,
+    tmuxSession: input.runtime.sessionId,
+    harness: nextHarness,
+    defaultHarness: nextHarness,
+    harnessProfiles: {
+      ...record.harnessProfiles ?? {},
+      [normalizeManagedHarness2(input.runtime.harness, "claude")]: {
+        cwd,
+        transport: nextTransport,
+        sessionId: normalizeTmuxSessionName2(input.runtime.sessionId, `${agentId}-${normalizeManagedHarness2(input.runtime.harness, "claude")}`),
+        launchArgs: nextLaunchArgs,
+        ...nextPermissionProfile ? { permissionProfile: nextPermissionProfile } : {}
+      }
+    },
+    transport: nextTransport,
+    systemPrompt: input.systemPrompt.trim() || undefined,
+    launchArgs: nextLaunchArgs,
+    permissionProfile: nextPermissionProfile,
+    capabilities: input.capabilities
+  });
+  registry[agentId] = nextRecord;
+  await writeLocalAgentRegistry(registry);
+  return buildLocalAgentConfigState(agentId, nextRecord);
+}
+async function updateLocalAgentCardLifecycle(agentId, input) {
+  const overrides = await readRelayAgentOverrides();
+  const override = overrides[agentId];
+  if (!override) {
+    return null;
+  }
+  const lifecycle2 = normalizeLocalAgentCardLifecycle({
+    ...override.card ?? {},
+    ...input
+  });
+  if (!lifecycle2) {
+    return null;
+  }
+  overrides[agentId] = {
+    ...override,
+    card: lifecycle2
+  };
+  await writeRelayAgentOverrides(overrides);
+  return lifecycle2;
+}
+function oneTimeCardCreatedAt(lifecycle2) {
+  return normalizeCardTimestamp(lifecycle2.createdAt) ?? 0;
+}
+function shouldPruneOneTimeCard(lifecycle2, now, maxAgeMs) {
+  if (lifecycle2.kind !== "one_time") {
+    return false;
+  }
+  if (lifecycle2.expiresAt !== undefined && lifecycle2.expiresAt <= now) {
+    return true;
+  }
+  const createdAt = oneTimeCardCreatedAt(lifecycle2);
+  return createdAt > 0 && createdAt + maxAgeMs <= now;
+}
+function oneTimeCardMatchesScope(agentId, override, input) {
+  if (BUILT_IN_AGENT_DEFINITION_IDS.has(agentId)) {
+    return false;
+  }
+  const lifecycle2 = normalizeLocalAgentCardLifecycle(override.card);
+  if (lifecycle2?.kind !== "one_time") {
+    return false;
+  }
+  if (input.createdById?.trim() && lifecycle2.createdById !== input.createdById.trim()) {
+    return false;
+  }
+  if (input.projectRoot?.trim()) {
+    const scopedRoot = normalizeProjectPath(input.projectRoot);
+    const cardRoot = normalizeProjectPath(override.projectRoot || override.runtime?.cwd || ".");
+    if (cardRoot !== scopedRoot) {
+      return false;
+    }
+  }
+  return true;
+}
+async function retireLocalAgentOverrides(overrides, agentIds) {
+  const retired = [];
+  for (const agentId of agentIds) {
+    const override = overrides[agentId];
+    if (!override) {
+      continue;
+    }
+    const record = localAgentRecordFromRelayAgentOverride(agentId, override);
+    const status = localAgentStatusFromRecord(agentId, record, localAgentStatusSource(agentId, overrides));
+    await stopLocalAgent(agentId).catch(() => null);
+    retired.push({
+      ...status,
+      isOnline: false
+    });
+    delete overrides[agentId];
+  }
+  if (retired.length > 0) {
+    await writeRelayAgentOverrides(overrides);
+  }
+  return retired;
+}
+async function pruneOneTimeLocalAgentCards(input = {}) {
+  const now = input.now ?? Date.now();
+  const maxAgeMs = Math.max(0, input.maxAgeMs ?? DEFAULT_ONE_TIME_LOCAL_AGENT_CARD_TTL_MS);
+  const maxCount = Math.max(0, input.maxCount ?? DEFAULT_ONE_TIME_LOCAL_AGENT_CARD_RETAIN);
+  const excluded = new Set(input.excludeAgentIds ?? []);
+  const overrides = await readRelayAgentOverrides();
+  const candidates = Object.entries(overrides).filter(([agentId, override]) => !excluded.has(agentId) && oneTimeCardMatchesScope(agentId, override, input)).map(([agentId, override]) => ({
+    agentId,
+    override,
+    lifecycle: normalizeLocalAgentCardLifecycle(override.card)
+  })).sort((left, right) => oneTimeCardCreatedAt(right.lifecycle) - oneTimeCardCreatedAt(left.lifecycle) || left.agentId.localeCompare(right.agentId));
+  const retireIds = new Set;
+  for (const candidate of candidates) {
+    if (shouldPruneOneTimeCard(candidate.lifecycle, now, maxAgeMs)) {
+      retireIds.add(candidate.agentId);
+    }
+  }
+  const retained = candidates.filter((candidate) => !retireIds.has(candidate.agentId));
+  for (const candidate of retained.slice(maxCount)) {
+    retireIds.add(candidate.agentId);
+  }
+  const retired = await retireLocalAgentOverrides({ ...overrides }, retireIds);
+  return {
+    inspected: candidates.length,
+    remaining: Math.max(0, candidates.length - retired.length),
+    retired
+  };
+}
+async function retireLocalAgent(agentId) {
+  const overrides = await readRelayAgentOverrides();
+  const override = overrides[agentId];
+  if (!override) {
+    return null;
+  }
+  const record = localAgentRecordFromRelayAgentOverride(agentId, override);
+  const status = localAgentStatusFromRecord(agentId, record, localAgentStatusSource(agentId, overrides));
+  await stopLocalAgent(agentId).catch(() => null);
+  const nextOverrides = { ...overrides };
+  delete nextOverrides[agentId];
+  await writeRelayAgentOverrides(nextOverrides);
+  return {
+    ...status,
+    isOnline: false
+  };
+}
 function buildCodexAgentSessionOptions(agentName, record, systemPrompt) {
   const permissionPosture = compileCodexPermissionProfile(record.permissionProfile);
   return {
@@ -15326,6 +15858,90 @@ function buildLocalAgentSystemPrompt(agentName, projectName, projectPath, option
 function buildLocalAgentInitialMessage(projectName, agentName) {
   return `You are now online as the ${agentName} relay agent for ${projectName}. Announce yourself on the relay with: ${brokerRelayCommand()} send --as ${agentName} "relay agent online \u2014 ready to assist with ${projectName}"`;
 }
+function tmuxDispatchSleep(ms) {
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
+}
+function captureTmuxPaneTail(sessionName, lines) {
+  try {
+    return execFileSync4("tmux", ["capture-pane", "-p", "-t", sessionName, "-S", `-${lines}`, "-E", "-"], { stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" });
+  } catch {
+    return "";
+  }
+}
+async function waitForTmuxHarnessReady(sessionName, harness) {
+  if (harness !== "claude") {
+    return;
+  }
+  const deadline = Date.now() + TMUX_READY_TIMEOUT_MS;
+  let paneTail = "";
+  while (Date.now() < deadline) {
+    if (!isLocalAgentSessionAlive(sessionName)) {
+      throw new Error(`tmux session ${sessionName} exited before Claude Code was ready.`);
+    }
+    paneTail = captureTmuxPaneTail(sessionName, TMUX_READY_TAIL_LINES);
+    if (tmuxPaneTailShowsReadyComposer(paneTail)) {
+      return;
+    }
+    await tmuxDispatchSleep(TMUX_READY_POLL_MS);
+  }
+  const tail = stripTerminalControlSequences(paneTail).trim().split(/\r?\n/).slice(-20).join(`
+`).trim();
+  throw new Error(`tmux session ${sessionName} did not show a ready Claude Code composer within ${TMUX_READY_TIMEOUT_MS}ms.` + (tail ? `
+Recent pane tail:
+${tail}` : ""));
+}
+function tmuxPaneTailShowsReadyComposer(paneTail) {
+  const cleanedTail = stripTerminalControlSequences(paneTail);
+  const lines = cleanedTail.split(/\r?\n/);
+  const anchor = findActiveTmuxComposerAnchor(lines);
+  if (!anchor) {
+    return false;
+  }
+  const afterComposerLines = [];
+  for (const line of lines.slice(anchor.index + 1)) {
+    if (isTmuxComposerBoundary(line)) {
+      break;
+    }
+    afterComposerLines.push(line);
+  }
+  return !tmuxPaneTailShowsHarnessActivity(afterComposerLines.join(`
+`));
+}
+function stripTerminalControlSequences(value) {
+  return value.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
+}
+function findActiveTmuxComposerAnchor(lines) {
+  const inlineComposerIndex = findLastIndex(lines, (line) => /^\s*[\u276F\u203A]\s*/.test(line));
+  const boxedComposerIndex = findLastIndex(lines, (line) => /^\s*[\u2502\u2503]\s*[>\u276F]\s*/.test(line));
+  if (inlineComposerIndex < 0 && boxedComposerIndex < 0) {
+    return null;
+  }
+  if (inlineComposerIndex > boxedComposerIndex) {
+    return { index: inlineComposerIndex, kind: "inline" };
+  }
+  return { index: boxedComposerIndex, kind: "boxed" };
+}
+function findLastIndex(items, predicate) {
+  for (let index = items.length - 1;index >= 0; index -= 1) {
+    if (predicate(items[index])) {
+      return index;
+    }
+  }
+  return -1;
+}
+function isTmuxComposerBoundary(line) {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return false;
+  }
+  if (/^[\u2500\u2501\u2550\u256D\u256E\u2570\u256F\u250C\u2510\u2514\u2518\u2554\u2557\u255A\u255D\u255F\u2562\u2560\u2563\u256A\u256B\u256C\u2569\u2566\u2564\u2567\u254C\u254D\u254E\u254F\s]+$/.test(trimmed)) {
+    return true;
+  }
+  return /^--\s*(?:INSERT|NORMAL)\s*--/.test(trimmed) || /^(?:Opus|Sonnet|Haiku|Claude|Codex|GPT)\b/.test(trimmed);
+}
+function tmuxPaneTailShowsHarnessActivity(paneTail) {
+  return /(?:^|\n)\s*(?:[\u23FA\u25CF\u273D\u2722\u273B\u23BF]|Bash\(|Read\(|Edit\(|Write\(|Grep\(|Glob\(|TodoWrite\()/.test(paneTail);
+}
 function shellQuoteArguments(args) {
   return args.map((arg) => JSON.stringify(arg)).join(" ");
 }
@@ -15336,10 +15952,10 @@ function buildLocalAgentLaunchCommand(agentName, record, projectPath, promptFile
   const harness = normalizeLocalAgentHarness(record.harness);
   const extraArgs = shellQuoteArguments(harness === "claude" ? normalizeClaudeRuntimeLaunchArgs(record.launchArgs) : normalizeLaunchArgsForHarness(harness, record.launchArgs));
   if (harness === "codex") {
-    return `exec bash ${JSON.stringify(workerScript ?? join15(relayAgentRuntimeDirectory(agentName), "codex-worker.sh"))}`;
+    return `exec bash ${JSON.stringify(workerScript ?? join16(relayAgentRuntimeDirectory(agentName), "codex-worker.sh"))}`;
   }
   if (harness === "pi") {
-    const sessionDir = join15(relayAgentRuntimeDirectory(agentName), "pi-sessions");
+    const sessionDir = join16(relayAgentRuntimeDirectory(agentName), "pi-sessions");
     return [
       "pi",
       `--append-system-prompt "$(cat ${JSON.stringify(promptFile)})"`,
@@ -15409,7 +16025,7 @@ async function ensureLocalAgentOnline(agentName, record) {
   await mkdir6(agentRuntimeDir, { recursive: true });
   await mkdir6(logsDir, { recursive: true });
   if (normalizedRecord.transport === "codex_app_server") {
-    await writeFile6(join15(agentRuntimeDir, "prompt.txt"), systemPrompt);
+    await writeFile6(join16(agentRuntimeDir, "prompt.txt"), systemPrompt);
     await ensureCodexAppServerAgentOnline(buildCodexAgentSessionOptions(agentName, normalizedRecord, systemPrompt));
     const registry2 = await readLocalAgentRegistry();
     registry2[agentName] = {
@@ -15421,7 +16037,7 @@ async function ensureLocalAgentOnline(agentName, record) {
     return registry2[agentName];
   }
   if (normalizedRecord.transport === "claude_stream_json") {
-    await writeFile6(join15(agentRuntimeDir, "prompt.txt"), systemPrompt);
+    await writeFile6(join16(agentRuntimeDir, "prompt.txt"), systemPrompt);
     await ensureClaudeStreamJsonAgentOnline(buildClaudeAgentSessionOptions(agentName, normalizedRecord, systemPrompt));
     const registry2 = await readLocalAgentRegistry();
     registry2[agentName] = {
@@ -15434,17 +16050,17 @@ async function ensureLocalAgentOnline(agentName, record) {
   }
   const initialMessage = buildLocalAgentInitialMessage(projectName, agentName);
   const bootstrapPrompt = buildLocalAgentBootstrapPrompt(normalizeLocalAgentHarness(normalizedRecord.harness), systemPrompt, initialMessage);
-  const queueDirectory = join15(agentRuntimeDir, "queue");
-  const processingDirectory = join15(queueDirectory, "processing");
-  const processedDirectory = join15(queueDirectory, "processed");
-  const promptFile = join15(agentRuntimeDir, "prompt.txt");
-  const initialFile = join15(agentRuntimeDir, "initial.txt");
-  const launchScript = join15(agentRuntimeDir, "launch.sh");
-  const workerScript = join15(agentRuntimeDir, "codex-worker.sh");
-  const codexSessionIdFile = join15(agentRuntimeDir, "codex-session-id.txt");
-  const stateFile = join15(agentRuntimeDir, "state.json");
-  const stdoutLogFile = join15(logsDir, "stdout.log");
-  const stderrLogFile = join15(logsDir, "stderr.log");
+  const queueDirectory = join16(agentRuntimeDir, "queue");
+  const processingDirectory = join16(queueDirectory, "processing");
+  const processedDirectory = join16(queueDirectory, "processed");
+  const promptFile = join16(agentRuntimeDir, "prompt.txt");
+  const initialFile = join16(agentRuntimeDir, "initial.txt");
+  const launchScript = join16(agentRuntimeDir, "launch.sh");
+  const workerScript = join16(agentRuntimeDir, "codex-worker.sh");
+  const codexSessionIdFile = join16(agentRuntimeDir, "codex-session-id.txt");
+  const stateFile = join16(agentRuntimeDir, "state.json");
+  const stdoutLogFile = join16(logsDir, "stdout.log");
+  const stderrLogFile = join16(logsDir, "stderr.log");
   await writeFile6(promptFile, systemPrompt);
   await writeFile6(initialFile, bootstrapPrompt);
   await writeFile6(stderrLogFile, "");
@@ -15509,11 +16125,17 @@ async function ensureLocalAgentOnline(agentName, record) {
     await new Promise((resolve9) => setTimeout(resolve9, 100));
   }
   if (!isLocalAgentSessionAlive(normalizedRecord.tmuxSession)) {
-    const stderrTail = existsSync11(stderrLogFile) ? readFileSync6(stderrLogFile, "utf8").trim().split(/\r?\n/).slice(-10).join(`
+    const stderrTail = existsSync12(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 (error) {
+    killAgentSession(normalizedRecord.tmuxSession);
+    throw error;
+  }
   const registry = await readLocalAgentRegistry();
   registry[agentName] = {
     ...normalizedRecord,
@@ -15695,6 +16317,7 @@ async function startLocalAgent(input) {
   const effectiveCwd = input.cwdOverride ? normalizeProjectPath(input.cwdOverride) : undefined;
   const shouldEnsureOnline = input.ensureOnline !== false;
   const requestedPermissionProfile = parseScoutPermissionProfile(input.permissionProfile);
+  const cardLifecycle = normalizeLocalAgentCardLifecycle(input.card);
   const requestedDefinitionId = input.agentName?.trim() ? normalizeAgentSelectorSegment(input.agentName.trim()) : "";
   if (input.agentName?.trim() && !requestedDefinitionId) {
     throw new Error(`Invalid agent name "${input.agentName}".`);
@@ -15744,7 +16367,8 @@ async function startLocalAgent(input) {
     const configDefinitionId = coldProjectConfig?.agent?.id?.trim() ? normalizeAgentSelectorSegment(coldProjectConfig.agent.id.trim()) : "";
     const definitionId = requestedDefinitionId || configDefinitionId || normalizeAgentSelectorSegment(basename7(projectRoot)) || "agent";
     const configDisplayName = coldProjectConfig?.agent?.displayName?.trim() || "";
-    const effectiveDisplayName = input.displayName || configDisplayName || titleCaseLocalAgentName(definitionId);
+    const operatorAugmentDefaults = operatorAugmentDefaultsForDefinitionId(definitionId);
+    const effectiveDisplayName = input.displayName || operatorAugmentDefaults?.displayName || configDisplayName || titleCaseLocalAgentName(definitionId);
     const instance = buildRelayAgentInstance(definitionId, projectRoot);
     const configDefaultHarness = coldProjectConfig?.agent?.runtime?.defaultHarness;
     const effectiveHarness = normalizeManagedHarness2(preferredHarness ?? configDefaultHarness, "claude");
@@ -15767,8 +16391,10 @@ async function startLocalAgent(input) {
       projectConfigPath: coldProjectConfigPath,
       source: "manual",
       startedAt: nowSeconds2(),
+      ...operatorAugmentDefaults ? { systemPrompt: operatorAugmentDefaults.systemPrompt } : {},
       launchArgs,
       defaultHarness: effectiveHarness,
+      ...cardLifecycle ? { card: cardLifecycle } : {},
       harnessProfiles: {
         [effectiveHarness]: {
           cwd: effectiveCwd ?? projectRoot,
@@ -15804,18 +16430,21 @@ async function startLocalAgent(input) {
       reasoningEffort: input.reasoningEffort
     });
     const nextTransport = normalizeLocalAgentTransport(preferredHarness ? undefined : matchingOverride.runtime?.transport, nextHarness);
+    const operatorAugmentDefaults = operatorAugmentDefaultsForDefinitionId(requestedDefinitionId);
     overrides[instance.id] = {
       agentId: instance.id,
       definitionId: requestedDefinitionId,
-      displayName: input.displayName || titleCaseLocalAgentName(requestedDefinitionId),
+      displayName: input.displayName || operatorAugmentDefaults?.displayName || titleCaseLocalAgentName(requestedDefinitionId),
       projectName: matchingOverride.projectName ?? basename7(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]: {
@@ -15837,7 +16466,9 @@ async function startLocalAgent(input) {
     await writeRelayAgentOverrides(overrides);
     targetAgentId = instance.id;
   } else {
-    if (input.model || input.reasoningEffort || requestedPermissionProfile) {
+    const operatorAugmentDefaults = operatorAugmentDefaultsForDefinitionId(matchingOverride.definitionId ?? requestedDefinitionId);
+    const shouldApplyOperatorAugmentPrompt = Boolean(operatorAugmentDefaults && !matchingOverride.systemPrompt?.trim());
+    if (input.model || input.reasoningEffort || requestedPermissionProfile || cardLifecycle || shouldApplyOperatorAugmentPrompt) {
       const existingHarness = normalizeManagedHarness2(preferredHarness ?? matchingOverride.defaultHarness ?? matchingOverride.runtime?.harness, "claude");
       const nextLaunchArgs = applyRequestedRuntimeOptionsToLaunchArgs(existingHarness, launchArgsForOverrideHarness(matchingOverride, existingHarness), {
         model: input.model,
@@ -15845,6 +16476,8 @@ async function startLocalAgent(input) {
       });
       overrides[matchingAgentId] = {
         ...matchingOverride,
+        ...cardLifecycle ? { card: cardLifecycle } : {},
+        ...shouldApplyOperatorAugmentPrompt ? { systemPrompt: operatorAugmentDefaults.systemPrompt } : {},
         launchArgs: existingHarness === defaultHarnessForOverride(matchingOverride, existingHarness) ? nextLaunchArgs : matchingOverride.launchArgs,
         harnessProfiles: {
           ...matchingOverride.harnessProfiles ?? {},
@@ -15949,9 +16582,9 @@ async function restartAllLocalAgents(options = {}) {
 function readPersistedClaudeSessionId(agentName) {
   try {
     const runtimeDir = relayAgentRuntimeDirectory(agentName);
-    const catalogPath = join15(runtimeDir, "session-catalog.json");
-    if (existsSync11(catalogPath)) {
-      const raw = readFileSync6(catalogPath, "utf8").trim();
+    const catalogPath = join16(runtimeDir, "session-catalog.json");
+    if (existsSync12(catalogPath)) {
+      const raw = readFileSync7(catalogPath, "utf8").trim();
       if (raw) {
         const catalog = JSON.parse(raw);
         if (typeof catalog.activeSessionId === "string" && catalog.activeSessionId.trim()) {
@@ -15959,9 +16592,9 @@ function readPersistedClaudeSessionId(agentName) {
         }
       }
     }
-    const legacyPath = join15(runtimeDir, "claude-session-id.txt");
-    if (existsSync11(legacyPath)) {
-      const value = readFileSync6(legacyPath, "utf8").trim();
+    const legacyPath = join16(runtimeDir, "claude-session-id.txt");
+    if (existsSync12(legacyPath)) {
+      const value = readFileSync7(legacyPath, "utf8").trim();
       return value || null;
     }
     return null;
@@ -15973,6 +16606,7 @@ function buildLocalAgentBinding(agentId, record, alive, nodeId, source) {
   const normalizedRecord = normalizeLocalAgentRecord(agentId, record);
   const configuredModel = readLaunchModelForHarness(normalizeLocalAgentHarness(normalizedRecord.harness), normalizedRecord.launchArgs);
   const codexPermissionPosture = normalizeLocalAgentHarness(normalizedRecord.harness) === "codex" ? compileCodexPermissionProfile(normalizedRecord.permissionProfile) : null;
+  const cardLifecycle = normalizeLocalAgentCardLifecycle(normalizedRecord.card);
   const definitionId = normalizedRecord.definitionId ?? agentId;
   const displayName = titleCaseLocalAgentName(definitionId);
   const projectRoot = normalizedRecord.projectRoot ?? normalizedRecord.cwd;
@@ -16000,6 +16634,7 @@ function buildLocalAgentBinding(agentId, record, alive, nodeId, source) {
         workspaceQualifier: instance.workspaceQualifier,
         branch: instance.branch,
         ...configuredModel ? { model: configuredModel } : {},
+        ...cardLifecycle ? { cardLifecycle } : {},
         ...codexPermissionPosture ? {
           permissionProfile: codexPermissionPosture.profile,
           approvalPolicy: codexPermissionPosture.approvalPolicy,
@@ -16035,6 +16670,7 @@ function buildLocalAgentBinding(agentId, record, alive, nodeId, source) {
         workspaceQualifier: instance.workspaceQualifier,
         branch: instance.branch,
         ...configuredModel ? { model: configuredModel } : {},
+        ...cardLifecycle ? { cardLifecycle } : {},
         ...codexPermissionPosture ? {
           permissionProfile: codexPermissionPosture.profile,
           approvalPolicy: codexPermissionPosture.approvalPolicy,
@@ -16075,6 +16711,7 @@ function buildLocalAgentBinding(agentId, record, alive, nodeId, source) {
         workspaceQualifier: instance.workspaceQualifier,
         branch: instance.branch,
         ...configuredModel ? { model: configuredModel } : {},
+        ...cardLifecycle ? { cardLifecycle } : {},
         ...codexPermissionPosture ? {
           permissionProfile: codexPermissionPosture.profile,
           approvalPolicy: codexPermissionPosture.approvalPolicy,
@@ -16161,9 +16798,10 @@ async function ensureLocalAgentBindingOnline(agentId, nodeId, options = {}) {
   const onlineRecord = await ensureLocalAgentOnline(agentId, recordForHarness(localAgentRecordFromRelayAgentOverride(agentId, override), options.harness));
   return buildLocalAgentBinding(agentId, onlineRecord, isLocalAgentRecordOnline(agentId, onlineRecord), nodeId, "relay-agent-registry");
 }
-var MODULE_DIRECTORY, OPENSCOUT_REPO_ROOT, DEFAULT_LOCAL_AGENT_CAPABILITIES, DEFAULT_LOCAL_AGENT_HARNESS = "claude", SUPPORTED_LOCAL_AGENT_HARNESSES, SUPPORTED_SCOUT_HARNESSES, DEFAULT_CLAUDE_SCOUT_ALLOWED_TOOLS;
+var MODULE_DIRECTORY, OPENSCOUT_REPO_ROOT, DEFAULT_LOCAL_AGENT_CAPABILITIES, DEFAULT_LOCAL_AGENT_HARNESS = "claude", DEFAULT_ONE_TIME_LOCAL_AGENT_CARD_TTL_MS, DEFAULT_ONE_TIME_LOCAL_AGENT_CARD_RETAIN = 24, SUPPORTED_LOCAL_AGENT_HARNESSES, SUPPORTED_SCOUT_HARNESSES, DEFAULT_CLAUDE_SCOUT_ALLOWED_TOOLS, TMUX_READY_TIMEOUT_MS = 20000, TMUX_READY_POLL_MS = 250, TMUX_READY_TAIL_LINES = 80;
 var init_local_agents = __esm(() => {
   init_src();
+  init_dispatch_stalled();
   init_claude_stream_json();
   init_codex_app_server();
   init_setup();
@@ -16173,9 +16811,11 @@ var init_local_agents = __esm(() => {
   init_local_agent_template();
   init_permission_policy2();
   init_requester_timeout();
-  MODULE_DIRECTORY = dirname8(fileURLToPath6(import.meta.url));
+  init_user_config();
+  MODULE_DIRECTORY = dirname9(fileURLToPath6(import.meta.url));
   OPENSCOUT_REPO_ROOT = resolve8(MODULE_DIRECTORY, "..", "..", "..");
   DEFAULT_LOCAL_AGENT_CAPABILITIES = ["chat", "invoke", "deliver"];
+  DEFAULT_ONE_TIME_LOCAL_AGENT_CARD_TTL_MS = 24 * 60 * 60 * 1000;
   SUPPORTED_LOCAL_AGENT_HARNESSES = ["claude", "codex", "pi"];
   SUPPORTED_SCOUT_HARNESSES = [
     ...SUPPORTED_LOCAL_AGENT_HARNESSES,
@@ -16190,8 +16830,8 @@ var init_local_agents = __esm(() => {
     "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",
@@ -16214,6 +16854,9 @@ function scoutBrokerInvocationPath(invocationId) {
 function scoutBrokerInvocationStreamPath(invocationId) {
   return `${scoutBrokerInvocationPath(invocationId)}/stream`;
 }
+function scoutBrokerInvocationLifecyclePath(invocationId) {
+  return `${scoutBrokerInvocationPath(invocationId)}/lifecycle`;
+}
 var scoutBrokerPaths, openAiAudioSpeechUrl = "https://api.openai.com/v1/audio/speech";
 var init_paths = __esm(() => {
   scoutBrokerPaths = {
@@ -16256,35 +16899,6 @@ function buildScoutAskMetadata(input) {
   };
 }
 
-// ../runtime/src/user-config.ts
-import { existsSync as existsSync12, readFileSync as readFileSync7, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
-import { homedir as homedir12 } from "os";
-import { dirname as dirname9, join as join16 } from "path";
-function userConfigPath() {
-  return join16(process.env.OPENSCOUT_HOME ?? join16(homedir12(), ".openscout"), "user.json");
-}
-function loadUserConfig() {
-  const configPath = userConfigPath();
-  if (!existsSync12(configPath))
-    return {};
-  try {
-    return JSON.parse(readFileSync7(configPath, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function saveUserConfig(config) {
-  const configPath = userConfigPath();
-  mkdirSync3(dirname9(configPath), { recursive: true });
-  writeFileSync3(configPath, JSON.stringify(config, null, 2) + `
-`, "utf8");
-}
-function resolveOperatorName() {
-  const config = loadUserConfig();
-  return config.name?.trim() || process.env.OPENSCOUT_OPERATOR_NAME?.trim() || process.env.USER?.trim() || "operator";
-}
-var init_user_config = () => {};
-
 // ../../apps/desktop/src/core/broker/sender.ts
 import { basename as basename8 } from "path";
 function resolveScoutAgentName(agentName) {
@@ -16449,7 +17063,7 @@ function buildScoutReturnAddress2(snapshot, actorId, options = {}) {
     replyToMessageId: options.replyToMessageId,
     nodeId: endpoint?.nodeId || agent?.authorityNodeId || agent?.homeNodeId,
     projectRoot,
-    sessionId: endpoint?.sessionId
+    sessionId: options.sessionId ?? endpoint?.sessionId
   });
 }
 function sanitizeConversationSegment(value) {
@@ -16562,11 +17176,7 @@ function isSupersededBrokerAgent(snapshot, agentId) {
   if (!agent) {
     return false;
   }
-  if (!metadataBoolean(agent.metadata, "staleLocalRegistration")) {
-    return false;
-  }
-  const replacementAgentId = metadataString2(agent.metadata, "replacedByAgentId");
-  return Boolean(replacementAgentId && snapshot.agents[replacementAgentId]);
+  return metadataBoolean(agent.metadata, "retiredFromFleet") || metadataBoolean(agent.metadata, "staleLocalRegistration");
 }
 function isBuiltInBrokerAgent(snapshot, agentId) {
   const agent = snapshot.agents[agentId];
@@ -16677,6 +17287,17 @@ async function readScoutBrokerHealth(baseUrl = resolveScoutBrokerUrl()) {
         nodes: health.counts.nodes ?? 0,
         actors: health.counts.actors ?? 0,
         agents: health.counts.agents ?? 0,
+        agentRecords: health.counts.agentRecords,
+        rawAgentRecords: health.counts.rawAgentRecords,
+        configuredAgents: health.counts.configuredAgents,
+        scoutManagedAgents: health.counts.scoutManagedAgents,
+        currentAgentRegistrations: health.counts.currentAgentRegistrations,
+        localAgentRegistrations: health.counts.localAgentRegistrations,
+        remoteAgentRegistrations: health.counts.remoteAgentRegistrations,
+        staleAgentRegistrations: health.counts.staleAgentRegistrations,
+        retiredAgentRegistrations: health.counts.retiredAgentRegistrations,
+        oneTimeAgentCards: health.counts.oneTimeAgentCards,
+        persistentAgentCards: health.counts.persistentAgentCards,
         conversations: health.counts.conversations ?? 0,
         messages: health.counts.messages ?? 0,
         flights: health.counts.flights ?? 0,
@@ -17134,7 +17755,7 @@ async function resolveMentionTargets(snapshot, text, currentDirectory) {
   const ambiguous = [];
   const candidateMap = new Map;
   const endpointBackedAgentIds = [
-    ...new Set(Object.values(snapshot.endpoints).map((endpoint) => endpoint.agentId).filter((agentId) => agentId && agentId !== OPERATOR_ID))
+    ...new Set(Object.values(snapshot.endpoints).map((endpoint) => endpoint.agentId).filter((agentId) => agentId && agentId !== OPERATOR_ID && !isSupersededBrokerAgent(snapshot, agentId)))
   ];
   for (const agent of Object.values(snapshot.agents)) {
     if (isSupersededBrokerAgent(snapshot, agent.id)) {
@@ -17306,6 +17927,48 @@ async function registerScoutLocalAgentBinding(input) {
     brokerRegistered: Boolean(broker)
   };
 }
+async function retireScoutLocalAgentBinding(input) {
+  const broker = input.broker ?? await loadScoutBrokerContext();
+  if (!broker) {
+    return false;
+  }
+  const retiredAt = Date.now();
+  let retired = false;
+  const agent = broker.snapshot.agents[input.agentId];
+  if (agent) {
+    const nextAgent = {
+      ...agent,
+      metadata: {
+        ...agent.metadata ?? {},
+        retiredFromFleet: true,
+        retiredAt
+      }
+    };
+    await brokerPostJson(broker.baseUrl, scoutBrokerPaths.v1.agents, nextAgent);
+    broker.snapshot.agents[input.agentId] = nextAgent;
+    retired = true;
+  }
+  for (const endpoint of Object.values(broker.snapshot.endpoints)) {
+    if (endpoint.agentId !== input.agentId) {
+      continue;
+    }
+    const nextEndpoint = {
+      ...endpoint,
+      state: "offline",
+      metadata: {
+        ...endpoint.metadata ?? {},
+        retiredFromFleet: true,
+        retiredAt,
+        lastError: "local agent card retired",
+        lastFailedAt: retiredAt
+      }
+    };
+    await brokerPostJson(broker.baseUrl, scoutBrokerPaths.v1.endpoints, nextEndpoint);
+    broker.snapshot.endpoints[endpoint.id] = nextEndpoint;
+    retired = true;
+  }
+  return retired;
+}
 async function resolveConversationActorId(baseUrl, snapshot, nodeId, actorId, currentDirectory, displayName) {
   const normalized = actorId.trim() || OPERATOR_ID;
   if (snapshot.agents[normalized] || snapshot.actors[normalized]) {
@@ -18123,6 +18786,11 @@ async function attachScoutManagedLocalSession(input) {
 async function sendScoutDirectMessage(input) {
   const broker = await requireScoutBrokerContext();
   const source = input.source?.trim() || "scout-mobile";
+  const targetEndpoints = Object.values(broker.snapshot.endpoints ?? {}).filter((endpoint) => endpoint.agentId === input.agentId);
+  const targetIsStale = isSupersededBrokerAgent(broker.snapshot, input.agentId) || targetEndpoints.length > 0 && targetEndpoints.every((endpoint) => metadataBoolean(endpoint.metadata, "retiredFromFleet") || metadataBoolean(endpoint.metadata, "staleLocalRegistration"));
+  if (targetIsStale) {
+    throw new Error(`${displayNameForBrokerActor(broker.snapshot, input.agentId)} is a stale local registration. Start the current project session from Workspaces before sending.`);
+  }
   const delivery = await brokerPostDeliver(broker.baseUrl, {
     caller: {
       actorId: OPERATOR_ID,
@@ -18185,6 +18853,41 @@ async function askScoutAgentById(input) {
     workspace: input.workspace,
     senderContext: input.senderContext,
     labels: input.labels,
+    replyToSessionId: input.replyToSessionId,
+    currentDirectory: input.currentDirectory,
+    source: input.source ?? "scout-mcp"
+  });
+  return {
+    usedBroker: result.usedBroker,
+    flight: result.flight,
+    conversationId: result.conversationId,
+    messageId: result.messageId,
+    workItem: result.workItem,
+    unresolvedTargetId: result.unresolvedTarget,
+    targetDiagnostic: result.targetDiagnostic
+  };
+}
+async function askScoutSessionById(input) {
+  const targetSessionId = input.targetSessionId.trim();
+  const result = await deliverScoutAsk({
+    senderId: input.senderId,
+    target: {
+      kind: "session_id",
+      sessionId: targetSessionId
+    },
+    targetLabel: `session:${targetSessionId}`,
+    targetSessionId,
+    body: input.body,
+    workItem: input.workItem,
+    channel: input.channel,
+    shouldSpeak: input.shouldSpeak,
+    createdAtMs: input.createdAtMs,
+    executionHarness: input.executionHarness,
+    executionSession: "existing",
+    workspace: input.workspace,
+    senderContext: input.senderContext,
+    labels: input.labels,
+    replyToSessionId: input.replyToSessionId,
     currentDirectory: input.currentDirectory,
     source: input.source ?? "scout-mcp"
   });
@@ -18204,6 +18907,8 @@ function renderedScoutAskTarget(target) {
       return target.agentId.trim();
     case "agent_label":
       return target.label.trim();
+    case "session_id":
+      return `session:${target.sessionId.trim()}`;
     case "binding_ref":
       return `ref:${target.ref.trim()}`;
     case "project_path":
@@ -18217,8 +18922,11 @@ function renderedScoutAskTarget(target) {
 function directAgentIdForAskTarget(target) {
   return target.kind === "agent_id" ? target.agentId.trim() : undefined;
 }
+function directSessionIdForAskTarget(target) {
+  return target.kind === "session_id" ? target.sessionId.trim() : undefined;
+}
 function defaultAskExecutionSession(target) {
-  return target.kind === "binding_ref" ? "existing" : "new";
+  return target.kind === "binding_ref" || target.kind === "session_id" ? "existing" : "new";
 }
 async function deliverScoutAsk(input) {
   const broker = await loadScoutBrokerContext();
@@ -18235,6 +18943,7 @@ async function deliverScoutAsk(input) {
     return { usedBroker: true, unresolvedTarget: renderedTarget };
   }
   const labels = normalizeWorkItemLabels(input.labels);
+  const targetSessionId = directSessionIdForAskTarget(input.target) ?? input.targetSessionId?.trim();
   const workRecordId = input.workItem ? buildScoutEntityId("work", createdAtMs) : undefined;
   const deliveryWorkItem = input.workItem && workRecordId ? { id: workRecordId, ...input.workItem } : undefined;
   const askMetadata = buildScoutAskMetadata({
@@ -18244,6 +18953,12 @@ async function deliverScoutAsk(input) {
     workspace: input.workspace,
     labels
   });
+  const replyToSessionId = input.replyToSessionId?.trim();
+  const deliveryMetadata = targetSessionId || replyToSessionId ? {
+    ...askMetadata,
+    ...targetSessionId ? { targetSessionId } : {},
+    ...replyToSessionId ? { replyToSessionId } : {}
+  } : askMetadata;
   const delivery = await brokerPostDeliver(broker.baseUrl, {
     caller: {
       actorId: senderId,
@@ -18253,7 +18968,9 @@ async function deliverScoutAsk(input) {
     },
     target: input.target,
     ...targetAgentId ? { targetAgentId } : {},
+    ...targetSessionId ? { targetSessionId } : {},
     targetLabel: renderedTarget,
+    ...replyToSessionId ? { replyToSessionId } : {},
     body: input.body.trim(),
     intent: "consult",
     channel: input.channel,
@@ -18261,12 +18978,13 @@ async function deliverScoutAsk(input) {
     ...deliveryWorkItem ? { collaborationRecordId: workRecordId, workItem: deliveryWorkItem } : {},
     execution: {
       ...input.executionHarness ? { harness: input.executionHarness } : {},
+      ...targetSessionId ? { targetSessionId } : {},
       session: input.executionSession ?? defaultAskExecutionSession(input.target)
     },
     ensureAwake: true,
     ...labels ? { labels } : {},
-    messageMetadata: askMetadata,
-    invocationMetadata: askMetadata
+    messageMetadata: deliveryMetadata,
+    invocationMetadata: deliveryMetadata
   });
   if (delivery.kind !== "delivery") {
     return {
@@ -18311,6 +19029,8 @@ async function askScoutQuestion(input) {
     workspace: input.workspace,
     senderContext: input.senderContext,
     labels: input.labels,
+    targetSessionId: input.targetSessionId,
+    replyToSessionId: input.replyToSessionId,
     currentDirectory: input.currentDirectory,
     source: input.source ?? "scout-cli"
   });
@@ -18329,6 +19049,16 @@ async function loadScoutInvocationSnapshot(baseUrl, invocationId) {
   }
   return snapshot;
 }
+async function loadScoutInvocationLifecycle(baseUrl, invocationId) {
+  try {
+    return await brokerReadJson(baseUrl, scoutBrokerInvocationLifecyclePath(invocationId));
+  } catch (error) {
+    if (error instanceof Error && error.message.includes(`${scoutBrokerInvocationLifecyclePath(invocationId)} returned 404`)) {
+      return null;
+    }
+    throw error;
+  }
+}
 async function resolveScoutWaitReference(baseUrl, input) {
   const original = input.trim();
   const normalized = normalizeScoutWaitRef(original);
@@ -18662,6 +19392,18 @@ async function readScoutBrokerFeed(options) {
     return null;
   }
 }
+async function markScoutConversationRead(options = {}) {
+  const broker = await requireScoutBrokerContext(options.baseUrl);
+  const conversationId = options.conversationId ?? scoutConversationIdForChannel(options.channel);
+  return brokerPostJson(broker.baseUrl, `/v1/conversations/${encodeURIComponent(conversationId)}/read-cursors`, {
+    actorId: options.actorId,
+    readerNodeId: options.readerNodeId ?? broker.node.id,
+    lastReadMessageId: options.lastReadMessageId,
+    lastReadSeq: options.lastReadSeq,
+    lastReadAt: options.lastReadAt,
+    metadata: options.metadata
+  });
+}
 async function loadScoutActivityItems(options = {}) {
   const search = new URLSearchParams;
   if (options.agentId)
@@ -18793,9 +19535,20 @@ async function loadConfiguredAgentIds() {
     return new Set;
   }
 }
+async function loadDiscoveredAgentMap(currentDirectory) {
+  try {
+    const setup = await loadResolvedRelayAgents({ currentDirectory });
+    return new Map(setup.discoveredAgents.map((agent) => [agent.agentId, agent]));
+  } catch {
+    return new Map;
+  }
+}
 async function listScoutAgents(options = {}) {
   const broker = await requireScoutBrokerContext();
-  const configuredAgentIds = await loadConfiguredAgentIds();
+  const [configuredAgentIds, discoveredAgents] = await Promise.all([
+    loadConfiguredAgentIds(),
+    loadDiscoveredAgentMap(options.currentDirectory ?? process.cwd())
+  ]);
   const endpointsByAgent = new Map;
   const messageStats = new Map;
   for (const endpoint of Object.values(broker.snapshot.endpoints ?? {})) {
@@ -18832,12 +19585,13 @@ async function listScoutAgents(options = {}) {
       ...Object.keys(broker.snapshot.agents ?? {}),
       ...Array.from(endpointsByAgent.keys()),
       ...Array.from(messageStats.keys()),
-      ...Array.from(configuredAgentIds.values())
+      ...Array.from(configuredAgentIds.values()),
+      ...Array.from(discoveredAgents.keys())
     ])
   ].filter((agentId) => agentId && agentId !== OPERATOR_ID).filter((agentId) => !isBuiltInBrokerAgent(broker.snapshot, agentId)).filter((agentId) => !isSupersededBrokerAgent(broker.snapshot, agentId)).map((agentId) => {
     const endpoints = endpointsByAgent.get(agentId) ?? [];
     const brokerMessages = messageStats.get(agentId);
-    const registrationKind = configuredAgentIds.has(agentId) ? "configured" : "broker";
+    const registrationKind = discoveredAgents.get(agentId)?.registrationKind ?? (configuredAgentIds.has(agentId) ? "configured" : "broker");
     const state = whoEntryState(endpoints, registrationKind);
     const lastSeen = maxDefined([
       brokerMessages?.lastSeen,
@@ -19099,6 +19853,8 @@ function renderedAskTarget(target) {
       return target.agentId;
     case "agent_label":
       return target.label;
+    case "session_id":
+      return `session:${target.sessionId}`;
     case "binding_ref":
       return `ref:${target.ref}`;
     case "project_path":
@@ -19120,6 +19876,9 @@ function askTargetFor(to) {
   if (parsed.kind === "binding_ref") {
     return { kind: "binding_ref", ref: parsed.ref };
   }
+  if (parsed.kind === "session_id") {
+    return { kind: "session_id", sessionId: parsed.sessionId };
+  }
   if (parsed.kind === "agent_label") {
     return { kind: "agent_label", label: parsed.label };
   }
@@ -19200,6 +19959,7 @@ var scoutAskHandler = async (command) => {
     body: command.body,
     workItem: command.workItem,
     labels: command.labels,
+    replyToSessionId: command.replyToSessionId,
     channel: command.channel,
     shouldSpeak: command.shouldSpeak,
     executionHarness: command.harness,
@@ -19239,11 +19999,14 @@ function renderAskCommandHelp() {
     "  one target + no channel            -> DM",
     "  --channel <name>                   -> named group thread",
     "  short @name                        -> must resolve to exactly one routable agent",
+    "  --project <path>                   -> ask by repo/workspace path; Scout resolves the concrete agent/session",
+    "  '>> project:<path> ...'             -> composer route form for the same project-path ask",
     "",
     'Use ask when the meaning is "do this and get back to me."',
     "The command creates durable broker work; the target should acknowledge quickly in the same DM or channel.",
     `Default inline mode returns once the target has acknowledged, completed immediately, or stays unacknowledged for ${DEFAULT_ASK_ACK_TIMEOUT_SECONDS}s.`,
     "Use the flight id, conversation, notify mode, or an explicit wait to follow the final completion.",
+    "Use --project when you know the project path but do not want to look up or pin an agent id first.",
     "",
     "Input:",
     "  inline message                    -> primary prompt body",
@@ -19254,6 +20017,8 @@ function renderAskCommandHelp() {
     '  scout ask --to hudson "review the parser"',
     '  scout ask --ref 7f3a9c21 "continue from that result"',
     '  scout ask --project ../talkie "how did you handle auth?"',
+    '  scout ask --project ../talkie --harness codex "review this from a fresh Codex session"',
+    "  scout ask '>> project:../talkie compare auth against this branch'",
     "  scout ask --to hudson --prompt-file ./handoff.md",
     '  scout ask --as premotion.master.mini --to hudson "build the editor"',
     '  scout ask --to hudson --reply-mode notify "take the next pass and report back"',
@@ -19862,6 +20627,7 @@ function buildScoutAgentCard(binding, options = {}) {
   const supportedInterfaces = metadataRecordArray(binding.agent.metadata, "supportedInterfaces");
   const securitySchemes = metadataRecord2(binding.agent.metadata, "securitySchemes");
   const securityRequirements = metadataStringMatrix(binding.agent.metadata, "securityRequirements");
+  const lifecycle2 = options.lifecycle ?? metadataRecord2(binding.agent.metadata, "cardLifecycle");
   return {
     id: binding.agent.id,
     agentId: binding.agent.id,
@@ -19891,6 +20657,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,
@@ -19908,7 +20675,8 @@ function buildScoutAgentCard(binding, options = {}) {
       actorId: binding.actor.id,
       endpointId: binding.endpoint.id,
       wakePolicy: binding.agent.wakePolicy,
-      ...model ? { model } : {}
+      ...model ? { model } : {},
+      ...lifecycle2 ? { cardLifecycle: lifecycle2 } : {}
     }
   };
 }
@@ -19917,13 +20685,24 @@ var init_scout_agent_cards = __esm(() => {
 });
 
 // ../runtime/src/control-plane-agents.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { basename as basename11 } from "path";
+function oneTimeAgentName(input) {
+  const base = normalizeAgentSelectorSegment(input.agentName || basename11(input.projectPath)) || "agent";
+  return `${base}-card-${randomUUID2().slice(0, 8)}`;
+}
 function createScoutAgentService(deps) {
   const localAgents = {
     listLocalAgents: deps.localAgents?.listLocalAgents ?? listLocalAgents,
+    retireLocalAgent: deps.localAgents?.retireLocalAgent ?? retireLocalAgent,
     restartAllLocalAgents: deps.localAgents?.restartAllLocalAgents ?? restartAllLocalAgents,
+    restartLocalAgent: deps.localAgents?.restartLocalAgent ?? restartLocalAgent,
     startLocalAgent: deps.localAgents?.startLocalAgent ?? startLocalAgent,
     stopAllLocalAgents: deps.localAgents?.stopAllLocalAgents ?? stopAllLocalAgents,
     stopLocalAgent: deps.localAgents?.stopLocalAgent ?? stopLocalAgent,
+    updateLocalAgentCard: deps.localAgents?.updateLocalAgentCard ?? updateLocalAgentCard,
+    updateLocalAgentCardLifecycle: deps.localAgents?.updateLocalAgentCardLifecycle ?? updateLocalAgentCardLifecycle,
+    pruneOneTimeLocalAgentCards: deps.localAgents?.pruneOneTimeLocalAgentCards ?? pruneOneTimeLocalAgentCards,
     inferLocalAgentBinding: deps.localAgents?.inferLocalAgentBinding ?? inferLocalAgentBinding
   };
   return {
@@ -19940,22 +20719,62 @@ function createScoutAgentService(deps) {
     async downScoutAgent(agentId) {
       return localAgents.stopLocalAgent(agentId);
     },
+    async retireScoutAgentCard(agentId) {
+      const broker = await deps.loadScoutBrokerContext().catch(() => null);
+      const retired = await localAgents.retireLocalAgent(agentId);
+      if (retired) {
+        await deps.retireScoutLocalAgentBinding?.({ agentId, broker }).catch(() => false);
+      }
+      return retired;
+    },
+    async updateScoutAgentCard(agentId, input) {
+      const config = await localAgents.updateLocalAgentCard(agentId, input);
+      if (!config) {
+        return null;
+      }
+      if (input.restart === true) {
+        await localAgents.restartLocalAgent(agentId);
+      }
+      await deps.registerScoutLocalAgentBinding({ agentId }).catch(() => {});
+      return config;
+    },
     async downAllScoutAgents(input = {}) {
       return localAgents.stopAllLocalAgents(input);
     },
     async restartScoutAgents(input = {}) {
       return localAgents.restartAllLocalAgents(input);
     },
+    async cleanupScoutAgentCards(input = {}) {
+      const broker = await deps.loadScoutBrokerContext().catch(() => null);
+      const result = await localAgents.pruneOneTimeLocalAgentCards(input);
+      await Promise.all(result.retired.map((status) => deps.retireScoutLocalAgentBinding?.({ agentId: status.agentId, broker }).catch(() => false)));
+      return result;
+    },
     async createScoutAgentCard(input) {
+      const createdAt = Date.now();
+      const oneTimeUse = input.oneTimeUse === true;
+      const createdById = input.createdById?.trim() || undefined;
+      const agentName = oneTimeUse ? oneTimeAgentName({
+        agentName: input.agentName,
+        projectPath: input.projectPath
+      }) : input.agentName;
+      const lifecycle2 = oneTimeUse ? {
+        kind: "one_time",
+        createdAt,
+        ...createdById ? { createdById } : {},
+        expiresAt: createdAt + Math.max(1, input.ttlMs ?? DEFAULT_ONE_TIME_SCOUT_AGENT_CARD_TTL_MS),
+        maxUses: 1
+      } : undefined;
       const status = await localAgents.startLocalAgent({
         projectPath: input.projectPath,
-        agentName: input.agentName,
+        agentName,
         displayName: input.displayName,
         harness: input.harness,
         model: input.model,
         reasoningEffort: input.reasoningEffort,
         permissionProfile: input.permissionProfile,
         currentDirectory: input.currentDirectory,
+        ...lifecycle2 ? { card: lifecycle2 } : {},
         ensureOnline: false
       });
       const currentDirectory = input.currentDirectory ?? input.projectPath;
@@ -19969,48 +20788,70 @@ function createScoutAgentService(deps) {
         throw new Error(`Agent ${status.agentId} did not expose an addressable binding.`);
       }
       let inboxConversationId;
-      let createdById = input.createdById?.trim() || undefined;
-      if (broker && createdById && createdById !== binding.agent.id) {
+      let resolvedCreatedById = createdById;
+      if (broker && resolvedCreatedById && resolvedCreatedById !== binding.agent.id) {
         const session = await deps.openScoutPeerSession({
-          sourceId: createdById,
+          sourceId: resolvedCreatedById,
           targetId: binding.agent.id,
           currentDirectory
         });
         inboxConversationId = session.conversation.id;
-        createdById = session.sourceId;
+        resolvedCreatedById = session.sourceId;
+      }
+      const finalLifecycle = lifecycle2 ? {
+        ...lifecycle2,
+        ...resolvedCreatedById ? { createdById: resolvedCreatedById } : {},
+        ...inboxConversationId ? { inboxConversationId } : {}
+      } : undefined;
+      if (finalLifecycle) {
+        await localAgents.updateLocalAgentCardLifecycle(status.agentId, finalLifecycle).catch(() => null);
+        const cleaned = await localAgents.pruneOneTimeLocalAgentCards({
+          createdById: finalLifecycle.createdById,
+          projectRoot: binding.endpoint.projectRoot ?? input.projectPath,
+          excludeAgentIds: [status.agentId]
+        }).catch(() => null);
+        if (cleaned?.retired.length) {
+          await Promise.all(cleaned.retired.map((retired) => deps.retireScoutLocalAgentBinding?.({ agentId: retired.agentId, broker }).catch(() => false)));
+        }
       }
       return buildScoutAgentCard(binding, {
         currentDirectory,
-        createdById,
+        createdById: resolvedCreatedById,
         brokerRegistered: syncResult?.brokerRegistered ?? false,
-        inboxConversationId
+        inboxConversationId,
+        lifecycle: finalLifecycle
       });
     }
   };
 }
+var DEFAULT_ONE_TIME_SCOUT_AGENT_CARD_TTL_MS;
 var init_control_plane_agents = __esm(() => {
+  init_src();
   init_local_agents();
   init_scout_agent_cards();
+  DEFAULT_ONE_TIME_SCOUT_AGENT_CARD_TTL_MS = 24 * 60 * 60 * 1000;
 });
 
 // ../../apps/desktop/src/core/agents/service.ts
-var scoutAgentService, createScoutAgentCard, downAllScoutAgents, downScoutAgent, loadScoutAgentStatuses, restartScoutAgents, upScoutAgent;
+var scoutAgentService, cleanupScoutAgentCards, createScoutAgentCard, downAllScoutAgents, downScoutAgent, loadScoutAgentStatuses, retireScoutAgentCard, restartScoutAgents, updateScoutAgentCard, upScoutAgent;
 var init_service2 = __esm(() => {
   init_control_plane_agents();
   init_service();
   scoutAgentService = createScoutAgentService({
     loadScoutBrokerContext,
     openScoutPeerSession,
-    registerScoutLocalAgentBinding
-  });
-  ({
-    createScoutAgentCard,
-    downAllScoutAgents,
-    downScoutAgent,
-    loadScoutAgentStatuses,
-    restartScoutAgents,
-    upScoutAgent
-  } = scoutAgentService);
+    registerScoutLocalAgentBinding,
+    retireScoutLocalAgentBinding
+  });
+  cleanupScoutAgentCards = scoutAgentService.cleanupScoutAgentCards;
+  createScoutAgentCard = scoutAgentService.createScoutAgentCard;
+  downAllScoutAgents = scoutAgentService.downAllScoutAgents;
+  downScoutAgent = scoutAgentService.downScoutAgent;
+  loadScoutAgentStatuses = scoutAgentService.loadScoutAgentStatuses;
+  retireScoutAgentCard = scoutAgentService.retireScoutAgentCard;
+  restartScoutAgents = scoutAgentService.restartScoutAgents;
+  updateScoutAgentCard = scoutAgentService.updateScoutAgentCard;
+  upScoutAgent = scoutAgentService.upScoutAgent;
 });
 
 // ../../apps/desktop/src/ui/terminal/cards.ts
@@ -20078,16 +20919,129 @@ __export(exports_card, {
 import { createInterface } from "readline";
 function renderCardCommandHelp() {
   return [
-    "Usage: scout card create [path] [--name <alias>] [--display-name <name>] [--harness <claude|codex|pi>] [--model <model>] [--reasoning-effort <effort>] [--permission-profile <profile>] [--as <requester>] [--no-input] [--path <path>]",
+    "Usage:",
+    "  scout card create [path] [--name <alias>] [--display-name <name>] [--harness <claude|codex|pi>] [--model <model>] [--reasoning-effort <effort>] [--permission-profile <profile>] [--as <requester>] [--one-time] [--no-input] [--path <path>]",
+    `  scout card update <agent> [--harness <claude|codex|pi>] [--model <model>|--clear-model] [--reasoning-effort <effort>|--clear-reasoning-effort] [--permission-profile <${formatScoutPermissionProfiles()}>|--clear-permission-profile] [--restart]`,
+    "  scout card cleanup [--all]",
+    "  scout card retire <agent>",
     "",
-    "Create a dedicated Scout agent card with a reply-ready return address.",
+    "Create, update, or retire a dedicated Scout agent card with a reply-ready return address.",
     "",
     "Use this when another agent should get back to you on a fresh project-scoped inbox,",
     "or when a worktree needs its own obvious handle instead of reusing a shared project agent.",
     "",
     "Examples:",
     "  scout card create",
-    "  scout card create ~/dev/openscout-worktrees/shell-fix --name shellfix --harness claude --model claude-sonnet-4-6"
+    "  scout card create ~/dev/openscout-worktrees/shell-fix --name shellfix --harness claude --model claude-sonnet-4-6",
+    "  scout card create --one-time --name review",
+    "  scout card cleanup",
+    "  scout card update talkie-drift-investigator --harness claude --model claude-opus-4-7",
+    "  scout card retire talkie-drift-investigator"
+  ].join(`
+`);
+}
+function readRequiredFlagValue(args, index, flag) {
+  const current = args[index] ?? "";
+  if (current.startsWith(`${flag}=`)) {
+    return { value: current.slice(flag.length + 1), index };
+  }
+  const value = args[index + 1];
+  if (!value) {
+    throw new ScoutCliError(`missing value for ${flag}`);
+  }
+  return { value, index: index + 1 };
+}
+function parseCardUpdateOptions(args) {
+  const target = args[0]?.trim();
+  if (!target) {
+    throw new ScoutCliError(renderCardCommandHelp());
+  }
+  const options = { restart: false };
+  for (let index = 1;index < args.length; index += 1) {
+    const current = args[index] ?? "";
+    if (current === "--harness" || current.startsWith("--harness=")) {
+      const parsed = readRequiredFlagValue(args, index, "--harness");
+      options.harness = parsed.value;
+      index = parsed.index;
+      continue;
+    }
+    if (current === "--model" || current.startsWith("--model=")) {
+      const parsed = readRequiredFlagValue(args, index, "--model");
+      options.model = parsed.value;
+      index = parsed.index;
+      continue;
+    }
+    if (current === "--clear-model") {
+      options.model = null;
+      continue;
+    }
+    if (current === "--reasoning-effort" || current === "--effort" || current.startsWith("--reasoning-effort=") || current.startsWith("--effort=")) {
+      const flag = current.startsWith("--effort") ? "--effort" : "--reasoning-effort";
+      const parsed = readRequiredFlagValue(args, index, flag);
+      options.reasoningEffort = parsed.value;
+      index = parsed.index;
+      continue;
+    }
+    if (current === "--clear-reasoning-effort") {
+      options.reasoningEffort = null;
+      continue;
+    }
+    if (current === "--permission-profile" || current.startsWith("--permission-profile=")) {
+      const parsed = readRequiredFlagValue(args, index, "--permission-profile");
+      options.permissionProfile = parsed.value;
+      index = parsed.index;
+      continue;
+    }
+    if (current === "--clear-permission-profile") {
+      options.permissionProfile = null;
+      continue;
+    }
+    if (current === "--restart") {
+      options.restart = true;
+      continue;
+    }
+    if (current.startsWith("--")) {
+      throw new ScoutCliError(`unexpected argument for card update: ${current}`);
+    }
+    throw new ScoutCliError(`unexpected arguments for card update: ${args.join(" ")}`);
+  }
+  return { target, options };
+}
+async function resolveCardAgentId(target) {
+  const resolved = await resolveLocalAgentByName(target) ?? await resolveLocalAgentByName(target, { matchProjectName: true });
+  if (!resolved) {
+    throw new ScoutCliError(`unknown Scout card "${target}"`);
+  }
+  return resolved.agentId;
+}
+function renderCardUpdateResult(value) {
+  return [
+    `Updated ${value.agentId}`,
+    `Harness: ${value.config.runtime.harness}`,
+    `Transport: ${value.config.runtime.transport}`,
+    `Session: ${value.config.runtime.sessionId}`,
+    `Model: ${value.config.model ?? "default"}`,
+    `Permission: ${value.config.permissionProfile ?? "default"}`,
+    `Restarted: ${value.restarted ? "yes" : "no"}`
+  ].join(`
+`);
+}
+function renderCardRetireResult(value) {
+  if (!value) {
+    return "Agent not found.";
+  }
+  return `Retired ${value.agentId}`;
+}
+function renderCardCleanupResult(value) {
+  const count = value.retired.length;
+  if (count === 0) {
+    return `No one-time cards retired. Inspected ${value.inspected}.`;
+  }
+  const agents = value.retired.map((agent) => `- ${agent.agentId}`).join(`
+`);
+  return [
+    `Retired ${count} one-time card${count === 1 ? "" : "s"}.`,
+    agents
   ].join(`
 `);
 }
@@ -20106,6 +21060,60 @@ async function runCardCommand(context, args) {
     context.output.writeText(renderCardCommandHelp());
     return;
   }
+  if (subcommand === "update") {
+    if (args.slice(1).some((arg) => HELP_FLAGS4.has(arg))) {
+      context.output.writeText(renderCardCommandHelp());
+      return;
+    }
+    const { target, options: options2 } = parseCardUpdateOptions(args.slice(1));
+    const agentId = await resolveCardAgentId(target);
+    const config = await updateScoutAgentCard(agentId, {
+      harness: parseScoutLocalHarness(options2.harness),
+      model: options2.model,
+      reasoningEffort: options2.reasoningEffort,
+      permissionProfile: options2.permissionProfile,
+      restart: options2.restart
+    });
+    if (!config) {
+      throw new ScoutCliError(`unknown Scout card "${target}"`);
+    }
+    context.output.writeValue({ agentId, config, restarted: options2.restart }, renderCardUpdateResult);
+    return;
+  }
+  if (subcommand === "retire" || subcommand === "delete" || subcommand === "remove") {
+    if (args.slice(1).some((arg) => HELP_FLAGS4.has(arg))) {
+      context.output.writeText(renderCardCommandHelp());
+      return;
+    }
+    const target = args[1]?.trim();
+    if (!target || args.length > 2) {
+      throw new ScoutCliError(renderCardCommandHelp());
+    }
+    const agentId = await resolveCardAgentId(target);
+    const retired = await retireScoutAgentCard(agentId);
+    context.output.writeValue(retired, renderCardRetireResult);
+    return;
+  }
+  if (subcommand === "cleanup" || subcommand === "prune") {
+    if (args.slice(1).some((arg) => HELP_FLAGS4.has(arg))) {
+      context.output.writeText(renderCardCommandHelp());
+      return;
+    }
+    let all = false;
+    for (const arg of args.slice(1)) {
+      if (arg === "--all") {
+        all = true;
+        continue;
+      }
+      throw new ScoutCliError(`unexpected argument for card cleanup: ${arg}`);
+    }
+    const cleaned = await cleanupScoutAgentCards({
+      currentDirectory: defaultScoutContextDirectory(context),
+      maxCount: all ? 0 : undefined
+    });
+    context.output.writeValue(cleaned, renderCardCleanupResult);
+    return;
+  }
   if (subcommand !== "create") {
     throw new ScoutCliError(renderCardCommandHelp());
   }
@@ -20155,12 +21163,14 @@ async function runCardCommand(context, args) {
     reasoningEffort: options.reasoningEffort,
     permissionProfile: options.permissionProfile,
     currentDirectory: options.currentDirectory,
-    createdById: resolveScoutAgentName(options.requesterId)
+    createdById: resolveScoutAgentName(options.requesterId),
+    oneTimeUse: options.oneTimeUse
   });
   context.output.writeValue(card, renderScoutAgentCard);
 }
 var HELP_FLAGS4;
 var init_card = __esm(() => {
+  init_src();
   init_local_agents();
   init_context();
   init_errors();
@@ -48656,17 +49666,29 @@ __export(exports_channel, {
 function newestMessagesFirst(messages2) {
   return [...messages2].sort((left, right) => right.createdAt - left.createdAt);
 }
+function renderChannelMarkReadReport(report) {
+  const message = report.lastReadMessageId ? ` through ${report.lastReadMessageId}` : "";
+  return [
+    `Marked ${report.conversationId} read for ${report.actorId}${message}.`,
+    `Acknowledged deliveries: ${report.acknowledgedDeliveries}`
+  ].join(`
+`);
+}
 function renderChannelCommandHelp() {
   return [
     "Usage: scout channel [--context-root <path>]",
     "       scout channel [<name>] --latest <count> [--json]",
+    "       scout channel [<name>] --mark-read [--json]",
     "",
     "Run a Scout channel server over stdio.",
     "Read recent channel messages with --latest and exit.",
+    "Mark a channel read with --mark-read (aliases: --read, --clear).",
     "",
     "Examples:",
     "  scout channel --latest 10 --json",
     "  scout channel homepage-polish --latest 10 --json",
+    "  scout channel shared --mark-read",
+    "  scout channel triage --clear",
     "",
     "This command is intended to be launched by Claude Code as a channel.",
     "It subscribes to the Scout broker event stream and pushes incoming",
@@ -48683,7 +49705,7 @@ function renderChannelCommandHelp() {
     "",
     "Do not name this server scout if you also use the full Scout MCP server.",
     "The channel server only exposes scout_send/scout_reply; scout mcp exposes",
-    "agents_start, invocations_ask, and the rest of the coordination tools."
+    "ask, agents_start, invocations_get, invocations_wait, and the rest of the coordination tools."
   ].join(`
 `);
 }
@@ -48701,6 +49723,22 @@ async function runChannelCommand(context, args) {
     context.output.writeValue(newestMessagesFirst(messages2), renderScoutMessageList);
     return;
   }
+  if (options.markRead) {
+    const actorId = await resolveScoutSenderId(null, options.currentDirectory, context.env);
+    const result = await markScoutConversationRead({
+      channel: options.channel,
+      actorId,
+      metadata: { source: "scout-cli", action: "channel.mark-read" }
+    });
+    const report = {
+      conversationId: scoutConversationIdForChannel(options.channel),
+      actorId,
+      lastReadMessageId: result.cursor.lastReadMessageId ?? null,
+      acknowledgedDeliveries: result.acknowledgedDeliveries
+    };
+    context.output.writeValue(report, renderChannelMarkReadReport);
+    return;
+  }
   await runScoutChannelServer({
     defaultCurrentDirectory: options.currentDirectory,
     env: context.env
@@ -48721,34 +49759,39 @@ __export(exports_config, {
 });
 async function runConfigCommand(_context, args) {
   const [subcommand, key, ...rest] = args;
-  if (subcommand === "set" && key === "name" && rest.length > 0) {
-    const name = rest.join(" ").trim();
+  if (subcommand === "set" && (key === "name" || key === "handle") && rest.length > 0) {
+    const value = rest.join(" ").trim();
     const config2 = loadUserConfig();
-    config2.name = name;
+    config2[key] = value;
     saveUserConfig(config2);
-    console.log(`Name set to: ${name}`);
+    console.log(`${key === "name" ? "Name" : "Handle"} set to: ${value}`);
     return;
   }
-  if (subcommand === "get" && key === "name") {
-    console.log(resolveOperatorName());
+  if (subcommand === "get" && (key === "name" || key === "handle")) {
+    console.log(key === "name" ? resolveOperatorName() : resolveOperatorHandle());
     return;
   }
-  if (subcommand === "set" && key === "name") {
+  if (subcommand === "set" && (key === "name" || key === "handle")) {
     const config2 = loadUserConfig();
-    delete config2.name;
+    delete config2[key];
     saveUserConfig(config2);
-    console.log(`Name reset to default: ${resolveOperatorName()}`);
+    const fallback = key === "name" ? resolveOperatorName() : resolveOperatorHandle();
+    console.log(`${key === "name" ? "Name" : "Handle"} reset to default: ${fallback}`);
     return;
   }
   if (!subcommand || subcommand === "show") {
     const config2 = loadUserConfig();
     const name = resolveOperatorName();
+    const handle = resolveOperatorHandle();
     console.log(`name: ${name}${config2.name ? "" : " (default)"}`);
+    console.log(`handle: @${handle}${config2.handle ? "" : " (default)"}`);
     return;
   }
   console.error("usage: scout config [show]");
   console.error("       scout config set name <value>");
+  console.error("       scout config set handle <value>");
   console.error("       scout config get name");
+  console.error("       scout config get handle");
   process.exit(1);
 }
 var init_config = __esm(() => {
@@ -52087,7 +53130,7 @@ var init_mcp = __esm(() => {
 
 // ../../apps/desktop/src/core/mcp/scout-mcp.ts
 import { readFileSync as readFileSync10 } from "fs";
-import { basename as basename11, resolve as resolve13 } from "path";
+import { basename as basename12, resolve as resolve13 } from "path";
 function createAgentPickerFieldMeta(input) {
   return {
     kind: "agent-picker",
@@ -52245,7 +53288,7 @@ function renderMcpAskSummary(result) {
   ].filter(Boolean);
   const detailText = details.length > 0 ? `; ${details.join(", ")}` : "";
   const followText = result.followUrl ? ` Follow: ${result.followUrl}` : "";
-  if (result.waitStatus === "timeout" && result.flightId) {
+  if (result.waitStatus === "pending" && result.flightId) {
     const state = result.flight?.state ? ` ${result.flight.state}` : "";
     return `Ask dispatch is still${state}; use invocations_wait with flightId=${result.flightId}.${followText}`;
   }
@@ -52266,7 +53309,8 @@ function renderMcpAskPrimitiveSummary(receipt) {
     const target = receipt.ids.targetAgentId ? ` to ${receipt.ids.targetAgentId}` : "";
     const flight = receipt.ids.flightId ? `; flight ${receipt.ids.flightId}` : "";
     const work = receipt.ids.workId ? `; work ${receipt.ids.workId}` : "";
-    return `Ask ${receipt.state}${target}${flight}${work}.`;
+    const delivery = receipt.delivery === "mcp_notification" ? receipt.notification?.status === "scheduled" ? " Reply will be delivered by MCP notification." : receipt.ids.flightId ? ` MCP notification was not scheduled; use invocations_wait with flightId=${receipt.ids.flightId}.` : " MCP notification was not scheduled." : "";
+    return `Ask ${receipt.state}${target}${flight}${work}.${delivery}`;
   }
   if (receipt.next) {
     return `Ask was not sent: ${receipt.next.reason}`;
@@ -52282,6 +53326,9 @@ function resolveAskReplyMode(input) {
   }
   return input.awaitReply ? "inline" : "none";
 }
+function resolveMcpReplyToSessionId(explicitSessionId, env) {
+  return explicitSessionId?.trim() || env.CODEX_THREAD_ID?.trim() || undefined;
+}
 function workUrlFor(workItem, env) {
   return workItem ? buildScoutPath2(resolveScoutWebOrigin2(env), `/work/${encodeURIComponent(workItem.id)}`) : null;
 }
@@ -52326,7 +53373,7 @@ function buildScoutFollowArtifacts(input, env) {
     invocationId: input.flight?.invocationId ?? null,
     conversationId: input.conversationId,
     workId: input.workItem?.id ?? null,
-    sessionId: null,
+    sessionId: input.targetSessionId ?? null,
     targetAgentId: input.targetAgentId ?? input.flight?.targetAgentId ?? null
   };
   const origin = resolveScoutWebOrigin2(env);
@@ -52347,6 +53394,12 @@ function buildScoutFollowArtifacts(input, env) {
 function isTerminalFlightState2(state) {
   return state === "completed" || state === "failed" || state === "cancelled";
 }
+async function loadInvocationLifecycleForFlight(input) {
+  if (!input.flight?.invocationId || !input.deps.getInvocationLifecycle) {
+    return null;
+  }
+  return await input.deps.getInvocationLifecycle(input.brokerUrl, input.flight.invocationId);
+}
 function isAcknowledgedFlightState(state) {
   return state === "running" || state === "waiting";
 }
@@ -52367,7 +53420,7 @@ async function waitForFlightForMcp(input) {
       return { flight: latestFlight, waitStatus: "acknowledged" };
     }
     if (deadline !== null && Date.now() > deadline) {
-      return { flight: latestFlight, waitStatus: "timeout" };
+      return { flight: latestFlight, waitStatus: "pending" };
     }
     latestFlight = await input.deps.getFlight(input.brokerUrl, input.flight.id) ?? latestFlight;
     await new Promise((resolve14) => setTimeout(resolve14, 1000));
@@ -52378,9 +53431,9 @@ function buildInvocationLookupContent(input) {
     flight: input.flight,
     conversationId: null,
     workItem: null,
-    targetAgentId: input.flight?.targetAgentId ?? null
+    targetAgentId: input.lifecycle?.targetAgentId ?? input.flight?.targetAgentId ?? null
   }, input.env);
-  const terminal = isTerminalFlightState2(input.flight?.state);
+  const terminal = isTerminalFlightState2(input.flight?.state) || Boolean(input.lifecycle?.terminal);
   return {
     currentDirectory: input.currentDirectory,
     flightId: input.flightId,
@@ -52388,8 +53441,9 @@ function buildInvocationLookupContent(input) {
     waitStatus: input.waitStatus,
     terminal,
     flight: input.flight,
-    output: input.flight?.output ?? input.flight?.summary ?? null,
-    error: input.flight?.error ?? null,
+    lifecycle: input.lifecycle ?? null,
+    output: input.flight?.output ?? input.flight?.summary ?? input.lifecycle?.terminal?.summary ?? null,
+    error: input.flight?.error ?? input.lifecycle?.terminal?.errorClass ?? null,
     ids: followArtifacts.ids,
     links: followArtifacts.links,
     followUrl: followArtifacts.followUrl
@@ -52406,7 +53460,7 @@ function renderInvocationLookupSummary(result) {
     return result.error;
   }
   const followText = result.followUrl ? ` Follow: ${result.followUrl}` : "";
-  if (result.waitStatus === "timeout") {
+  if (result.waitStatus === "pending") {
     return `Flight ${result.flightId} is still ${result.flight.state}.${followText}`;
   }
   return `Flight ${result.flightId} is ${result.flight.state}.${followText}`;
@@ -52457,7 +53511,7 @@ function sendScoutReplyNotification(server, params) {
 function scheduleScoutReplyNotification(input) {
   (async () => {
     try {
-      const completedFlight = await input.deps.waitForFlight(input.brokerUrl, input.flight.id, { timeoutSeconds: input.timeoutSeconds });
+      const completedFlight = await input.deps.waitForFlight(input.brokerUrl, input.flight.id);
       await sendScoutReplyNotification(input.server, {
         ...input.context,
         status: "completed",
@@ -52619,7 +53673,7 @@ function isCanonicalOpenScoutProjectRoot(projectRoot) {
   if (!projectRoot) {
     return false;
   }
-  return normalizeSearchValue(basename11(resolve13(projectRoot))) === "openscout";
+  return normalizeSearchValue(basename12(resolve13(projectRoot))) === "openscout";
 }
 function isSameProjectRoot(left, right) {
   if (!left || !right) {
@@ -52765,7 +53819,8 @@ function decorateAgentLabels(entries) {
       workspace: entry.workspace,
       node: entry.node,
       projectRoot: entry.projectRoot,
-      transport: entry.transport
+      transport: entry.transport,
+      sessionId: entry.sessionId
     };
   });
 }
@@ -52826,7 +53881,7 @@ function scoreAgentCandidate(candidate, query) {
     candidate.model,
     candidate.workspace,
     candidate.node,
-    candidate.projectRoot ? basename11(candidate.projectRoot) : null
+    candidate.projectRoot ? basename12(candidate.projectRoot) : null
   ];
   let best = -1;
   for (const value of haystacks) {
@@ -52883,6 +53938,7 @@ async function loadScoutAgentDirectory(currentDirectory) {
       node: entry.node ?? existing.node,
       projectRoot: entry.projectRoot ?? existing.projectRoot,
       transport: entry.transport ?? existing.transport,
+      sessionId: entry.sessionId ?? existing.sessionId,
       state: rankState(entry.state) >= rankState(existing.state) ? entry.state : existing.state,
       registrationKind: entry.registrationKind === "broker" ? entry.registrationKind : existing.registrationKind,
       routable: entry.routable || existing.routable
@@ -52906,7 +53962,8 @@ async function loadScoutAgentDirectory(currentDirectory) {
       workspace: discovered.instance.workspaceQualifier || null,
       node: discovered.instance.nodeQualifier || null,
       projectRoot: discovered.projectRoot,
-      transport: discovered.runtime.transport ?? null
+      transport: discovered.runtime.transport ?? null,
+      sessionId: null
     });
   }
   for (const agent of Object.values(broker.snapshot.agents ?? {})) {
@@ -52933,7 +53990,8 @@ async function loadScoutAgentDirectory(currentDirectory) {
       workspace: normalizedStringOrNull(agent.workspaceQualifier),
       node: normalizedStringOrNull(agent.nodeQualifier),
       projectRoot: normalizedStringOrNull(preferredEndpoint?.projectRoot ?? preferredEndpoint?.cwd),
-      transport: normalizedStringOrNull(preferredEndpoint?.transport)
+      transport: normalizedStringOrNull(preferredEndpoint?.transport),
+      sessionId: normalizedStringOrNull(preferredEndpoint?.sessionId)
     });
   }
   return [...directory.values()].sort((left, right) => {
@@ -53038,7 +54096,9 @@ function defaultScoutMcpDependencies(env) {
       reasoningEffort,
       permissionProfile,
       currentDirectory,
-      createdById
+      createdById,
+      oneTimeUse,
+      ttlMs
     }) => createScoutAgentCard({
       projectPath,
       agentName,
@@ -53048,7 +54108,9 @@ function defaultScoutMcpDependencies(env) {
       reasoningEffort,
       permissionProfile,
       currentDirectory,
-      createdById
+      createdById,
+      oneTimeUse,
+      ttlMs
     }),
     startAgent: ({
       projectPath,
@@ -53146,6 +54208,7 @@ function defaultScoutMcpDependencies(env) {
       channel,
       shouldSpeak,
       labels,
+      replyToSessionId,
       currentDirectory,
       source
     }) => askScoutQuestion({
@@ -53156,6 +54219,7 @@ function defaultScoutMcpDependencies(env) {
       channel,
       shouldSpeak,
       labels,
+      replyToSessionId,
       currentDirectory,
       source
     }),
@@ -53167,6 +54231,7 @@ function defaultScoutMcpDependencies(env) {
       channel,
       shouldSpeak,
       labels,
+      replyToSessionId,
       currentDirectory,
       source
     }) => askScoutAgentById({
@@ -53177,12 +54242,37 @@ function defaultScoutMcpDependencies(env) {
       channel,
       shouldSpeak,
       labels,
+      replyToSessionId,
+      currentDirectory,
+      source
+    }),
+    askSessionById: ({
+      senderId,
+      targetSessionId,
+      body,
+      workItem,
+      channel,
+      shouldSpeak,
+      labels,
+      replyToSessionId,
+      currentDirectory,
+      source
+    }) => askScoutSessionById({
+      senderId,
+      targetSessionId,
+      body,
+      workItem,
+      channel,
+      shouldSpeak,
+      labels,
+      replyToSessionId,
       currentDirectory,
       source
     }),
     updateWorkItem: (input) => updateScoutWorkItem(input),
     waitForFlight: (baseUrl, flightId, options) => waitForScoutFlight(baseUrl, flightId, options),
     getFlight: (baseUrl, flightId) => loadScoutFlight(baseUrl, flightId),
+    getInvocationLifecycle: (baseUrl, invocationId) => loadScoutInvocationLifecycle(baseUrl, invocationId),
     readLabelBrief: (label, baseUrl) => readScoutLabelBrief(label, baseUrl),
     readLabelFeed: (label, baseUrl, options) => readScoutLabelFeed(label, options, baseUrl)
   };
@@ -53413,7 +54503,7 @@ function createScoutMcpServer(options) {
   });
   server.registerTool("messages_reply", {
     title: "Reply to Scout Message",
-    description: "Reply to the active inbound Scout broker ask. If conversationId and replyToMessageId are omitted, this uses the active ScoutReplyContext. If there is no active context, use messages_send for a new message or pass both ids explicitly.",
+    description: "Reply in an existing Scout conversation/thread. This is a normal threaded conversation message, not a fresh ask or owned-work lifecycle. If conversationId and replyToMessageId are omitted, this uses the current ScoutReplyContext. If there is no active context, use messages_send for a new message or ask for a new request.",
     inputSchema: object2({
       body: string2().min(1),
       currentDirectory: string2().optional(),
@@ -53454,7 +54544,7 @@ function createScoutMcpServer(options) {
         routingError: "missing_reply_context"
       };
       return {
-        content: createPlainTextContent("No active Scout broker reply context. Use messages_send for a new message, or pass conversationId and replyToMessageId explicitly."),
+        content: createPlainTextContent("No active Scout broker reply context. Use messages_send for a new message, use ask for a new request, or pass conversationId and replyToMessageId explicitly."),
         structuredContent: structuredContent2
       };
     }
@@ -53527,7 +54617,7 @@ function createScoutMcpServer(options) {
   });
   server.registerTool("card_create", {
     title: "Create Scout Agent Card",
-    description: "Create a dedicated Scout agent card with a reply-ready return address. Use this when another agent should get back to you on a fresh project-scoped inbox or worktree-scoped alias. One target stays private by default; group coordination still requires an explicit channel elsewhere.",
+    description: "Create a Scout agent card with a reply-ready return address. Agent-created cards default to one-time use so short-lived review/probe identities do not crowd the system; pass oneTimeUse=false for a persistent card. One target stays private by default; group coordination still requires an explicit channel elsewhere.",
     inputSchema: object2({
       projectPath: string2().optional(),
       currentDirectory: string2().optional(),
@@ -53537,7 +54627,9 @@ function createScoutMcpServer(options) {
       harness: _enum2(LOCAL_AGENT_HARNESS_VALUES).optional(),
       model: string2().optional(),
       reasoningEffort: string2().optional(),
-      permissionProfile: string2().optional()
+      permissionProfile: string2().optional(),
+      oneTimeUse: boolean2().optional(),
+      ttlSeconds: number2().positive().optional()
     }),
     outputSchema: cardCreateResultSchema,
     annotations: {
@@ -53555,7 +54647,9 @@ function createScoutMcpServer(options) {
     harness,
     model,
     reasoningEffort,
-    permissionProfile
+    permissionProfile,
+    oneTimeUse,
+    ttlSeconds
   }) => {
     const resolvedCurrentDirectory = resolveToolCurrentDirectory(currentDirectory, options.defaultCurrentDirectory);
     const resolvedSenderId = await resolveMcpSenderId(deps, senderId, resolvedCurrentDirectory, env);
@@ -53568,7 +54662,9 @@ function createScoutMcpServer(options) {
       reasoningEffort: reasoningEffort?.trim() || undefined,
       permissionProfile: permissionProfile?.trim() || undefined,
       currentDirectory: resolvedCurrentDirectory,
-      createdById: resolvedSenderId
+      createdById: resolvedSenderId,
+      oneTimeUse: oneTimeUse ?? true,
+      ttlMs: ttlSeconds === undefined ? undefined : Math.round(ttlSeconds * 1000)
     });
     const structuredContent = {
       currentDirectory: resolvedCurrentDirectory,
@@ -53679,7 +54775,7 @@ function createScoutMcpServer(options) {
     title: "Resolve Scout Agent",
     description: "Resolve one exact Scout agent handle or return ambiguity details. Use this when a short handle may be ambiguous; explicit target sends can let the broker resolve in one call.",
     inputSchema: object2({
-      label: string2().min(1).describe("Scout agent handle or selector, such as @talkie or @talkie#codex?5.5"),
+      label: string2().min(1).describe("Scout agent handle or selector, such as @talkie. Use harness/model/profile qualifiers only when you need a specific instance."),
       currentDirectory: string2().optional()
     }),
     outputSchema: resolveResultSchema,
@@ -53710,17 +54806,25 @@ function createScoutMcpServer(options) {
   });
   server.registerTool("ask", {
     title: "Ask",
-    description: "Ask another agent to answer, review, try, build, compare, or give feedback. This is the normal agent-to-agent ask primitive: pass who to ask in `to`, or pass `projectPath` when you know the project root and want Scout to choose the concrete agent. Scout resolves, routes, wakes when possible, and returns a compact receipt. Use discovery tools only when you need broker help rather than agent work.",
+    description: "Ask another agent to answer, review, try, build, compare, or give feedback. This is the single broker front door for requested work: pass who to ask in `to`, pass `projectPath` when you know the project root and want Scout to choose/create the concrete instance, or pass `targetSessionId` to keep a sticky session. Ask may create message, invocation, flight, delivery, and work records as side effects; use invocations_get/invocations_wait to observe flight records. Use discovery tools only when you need broker help rather than agent work.",
     inputSchema: object2({
       to: string2().min(1).optional().describe("Agent id, label, sibling, specialist, or recent collaborator."),
-      projectPath: string2().min(1).optional().describe("Project root to ask; Scout resolves the owning agent."),
+      targetSessionId: targetSessionIdInputSchema,
+      projectPath: projectPathInputSchema,
       body: string2().min(1),
       currentDirectory: string2().optional(),
       senderId: string2().optional(),
+      replyToSessionId: string2().optional().describe("Optional requester session that should receive the eventual reply. When omitted, Codex MCP uses the current CODEX_THREAD_ID when available."),
+      labels: array(string2()).optional(),
+      workItem: workItemInputSchema.optional(),
+      channel: string2().optional(),
+      shouldSpeak: boolean2().optional(),
+      replyMode: _enum2(REPLY_MODE_VALUES).describe("Reply delivery mode: 'none' returns durable ids only, 'inline' waits briefly, and 'notify' returns quickly then emits notifications/scout/reply later.").optional(),
+      timeoutSeconds: number2().int().min(1).optional().describe("Caller wait budget in seconds for inline waits only; it never cancels or fails the broker ask."),
       harness: _enum2(LOCAL_AGENT_HARNESS_VALUES).optional(),
       workspace: _enum2(["same", "new_worktree"]).optional(),
       session: _enum2(["reuse", "new"]).optional(),
-      wait: boolean2().optional()
+      wait: boolean2().optional().describe("Compatibility alias for replyMode='inline'.")
     }),
     outputSchema: askReceiptSchema,
     annotations: {
@@ -53738,10 +54842,18 @@ function createScoutMcpServer(options) {
     })
   }, async ({
     to,
+    targetSessionId,
     projectPath,
     body,
     currentDirectory,
     senderId,
+    replyToSessionId,
+    labels,
+    workItem,
+    channel,
+    shouldSpeak,
+    replyMode,
+    timeoutSeconds,
     harness,
     workspace,
     session,
@@ -53749,8 +54861,14 @@ function createScoutMcpServer(options) {
   }) => {
     const resolvedCurrentDirectory = resolveToolCurrentDirectory(currentDirectory, options.defaultCurrentDirectory);
     const resolvedSenderId = await resolveMcpSenderId(deps, senderId, resolvedCurrentDirectory, env);
-    const targetTo = to?.trim();
-    const targetProjectPath = projectPath?.trim();
+    const resolvedReplyToSessionId = resolveMcpReplyToSessionId(replyToSessionId, env);
+    const resolvedReplyMode = resolveAskReplyMode({
+      awaitReply: wait,
+      replyMode
+    });
+    const targetSession = targetSessionId?.trim();
+    const targetTo = targetSession ? `session:${targetSession}` : to?.trim();
+    const targetProjectPath = projectPath?.trim() ? resolve13(resolvedCurrentDirectory, projectPath.trim()) : undefined;
     let structuredContent = targetTo && targetProjectPath ? {
       ok: false,
       state: "failed",
@@ -53763,15 +54881,20 @@ function createScoutMcpServer(options) {
       senderId: resolvedSenderId,
       ...targetProjectPath ? { projectPath: targetProjectPath } : { to: targetTo ?? "" },
       body,
-      harness,
-      workspace,
-      session,
+      ...harness ? { harness } : {},
+      ...workspace ? { workspace } : {},
+      ...session ? { session } : {},
+      ...workItem ? { workItem } : {},
+      ...labels ? { labels } : {},
+      ...channel ? { channel } : {},
+      ...shouldSpeak !== undefined ? { shouldSpeak } : {},
+      ...resolvedReplyToSessionId ? { replyToSessionId: resolvedReplyToSessionId } : {},
       currentDirectory: resolvedCurrentDirectory,
       source: "scout-mcp"
     });
-    if (wait && structuredContent.ids.flightId) {
+    if (resolvedReplyMode === "inline" && structuredContent.ids.flightId) {
       try {
-        const flight = await deps.waitForFlight(deps.resolveBrokerUrl(), structuredContent.ids.flightId);
+        const flight = await deps.waitForFlight(deps.resolveBrokerUrl(), structuredContent.ids.flightId, timeoutSeconds ? { timeoutSeconds } : undefined);
         structuredContent = {
           ...structuredContent,
           state: flight.state === "completed" ? "completed" : flight.state === "failed" || flight.state === "cancelled" ? "failed" : "queued",
@@ -53784,6 +54907,58 @@ function createScoutMcpServer(options) {
           }
         };
       } catch {}
+    } else if (resolvedReplyMode === "notify" && structuredContent.ids.flightId) {
+      const flight = await deps.getFlight(deps.resolveBrokerUrl(), structuredContent.ids.flightId).catch(() => null);
+      if (flight) {
+        const followArtifacts = buildScoutFollowArtifacts({
+          flight,
+          conversationId: structuredContent.ids.conversationId ?? null,
+          workItem: null,
+          targetAgentId: structuredContent.ids.targetAgentId ?? flight.targetAgentId ?? null
+        }, env);
+        scheduleScoutReplyNotification({
+          server,
+          deps,
+          brokerUrl: deps.resolveBrokerUrl(),
+          flight,
+          context: {
+            currentDirectory: resolvedCurrentDirectory,
+            senderId: resolvedSenderId,
+            targetAgentId: structuredContent.ids.targetAgentId ?? flight.targetAgentId ?? null,
+            targetLabel: targetTo ?? targetProjectPath ?? null,
+            conversationId: structuredContent.ids.conversationId ?? null,
+            messageId: structuredContent.ids.messageId ?? null,
+            bindingRef: structuredContent.ids.bindingRef ? `ref:${structuredContent.ids.bindingRef}` : null,
+            flightId: flight.id,
+            workItem: null,
+            workId: structuredContent.ids.workId ?? null,
+            workUrl: null,
+            ids: followArtifacts.ids,
+            links: followArtifacts.links,
+            followUrl: followArtifacts.followUrl
+          }
+        });
+        structuredContent = {
+          ...structuredContent,
+          delivery: "mcp_notification",
+          notification: {
+            method: "notifications/scout/reply",
+            status: "scheduled"
+          }
+        };
+      }
+    }
+    if (structuredContent.ok && !structuredContent.delivery) {
+      structuredContent = {
+        ...structuredContent,
+        delivery: resolvedReplyMode === "notify" ? "mcp_notification" : resolvedReplyMode === "inline" ? "inline" : "none",
+        ...resolvedReplyMode === "notify" ? {
+          notification: {
+            method: "notifications/scout/reply",
+            status: "not_scheduled"
+          }
+        } : {}
+      };
     }
     return {
       content: createPlainTextContent(renderMcpAskPrimitiveSummary(structuredContent)),
@@ -53792,7 +54967,7 @@ function createScoutMcpServer(options) {
   });
   server.registerTool("messages_send", {
     title: "Send Scout Message",
-    description: "Post a broker-backed Scout tell/update. Use this for heads-up, replies, and status. Pass targets as fields: one explicit target without a channel becomes a DM, group delivery requires an explicit channel, and the body remains payload text. Targeted DMs are dispatched by the broker when the target can be reached; callers should not preflight wake/session mechanics. Use targetAgentId when agents_start returned exactTargetAgentId; this bypasses label resolution. Use channel='shared' only for shared updates. Pass targetLabel for the single-call broker-resolved path; mentionAgentIds remains available for exact-id compatibility. If a requested new or precise target is unresolved or mismatched, call agents_start and retry with the returned exactTargetAgentId instead of substituting a different agent. For agent-to-agent work, use ask instead.",
+    description: "Post a broker-backed Scout message/update/reply. Use this for heads-up, threaded conversation, and status when no new owned-work lifecycle is needed. Pass targets as fields: one explicit target without a channel becomes a DM, group delivery requires an explicit channel, and the body remains payload text. Targeted DMs are dispatched by the broker when the target can be reached; callers should not preflight wake/session mechanics. Use targetAgentId when agents_start returned exactTargetAgentId; this bypasses label resolution. Use channel='shared' only for shared updates. Pass targetLabel for the single-call broker-resolved path; mentionAgentIds remains available for exact-id compatibility. If a requested new or precise target is unresolved or mismatched, call agents_start and retry with the returned exactTargetAgentId instead of substituting a different agent. For new agent-to-agent work, use ask instead.",
     inputSchema: object2({
       body: string2().min(1),
       currentDirectory: string2().optional(),
@@ -54048,272 +55223,380 @@ function createScoutMcpServer(options) {
       structuredContent
     };
   });
-  server.registerTool("invocations_ask", {
-    title: "Create Scout Invocation",
-    description: "Low-level broker-backed invocation handoff. For normal agent-to-agent work, use ask. Use this only when you need exact invocation controls such as targetAgentId, workItem, or replyMode. Pass targetLabel or targetAgentId as routing fields; one target without a channel becomes a DM and the body remains payload text. Use targetAgentId when agents_start returned exactTargetAgentId; this bypasses label resolution. replyMode='inline' returns once the invocation is acknowledged or already complete; use invocations_wait for a longer follow-up poll. replyMode='notify' returns immediately and emits notifications/scout/reply later; replyMode='none' returns the durable receipt only. awaitReply is kept as a boolean alias for replyMode='inline'.",
-    inputSchema: object2({
-      body: string2().min(1),
-      currentDirectory: string2().optional(),
-      senderId: string2().optional(),
-      targetAgentId: targetAgentIdInputSchema,
-      targetLabel: targetLabelInputSchema,
-      labels: array(string2()).optional(),
-      workItem: workItemInputSchema.optional(),
-      channel: string2().optional(),
-      shouldSpeak: boolean2().optional(),
-      awaitReply: boolean2().describe("Compatibility alias for replyMode='inline'.").optional(),
-      replyMode: _enum2(REPLY_MODE_VALUES).describe("Reply delivery mode: 'inline' returns a quick acknowledgement or immediate completion, 'notify' returns immediately then emits notifications/scout/reply, and 'none' returns durable ids only. Inline acknowledgement waits default to 30 seconds unless timeoutSeconds is set.").optional(),
-      timeoutSeconds: number2().int().min(1).optional()
-    }).refine((value) => Boolean(value.targetAgentId?.trim() || value.targetLabel?.trim()), {
-      message: "Provide either targetAgentId or targetLabel.",
-      path: ["targetAgentId"]
-    }),
-    outputSchema: askResultSchema,
-    annotations: {
-      readOnlyHint: false,
-      idempotentHint: false,
-      destructiveHint: false,
-      openWorldHint: false
-    },
-    _meta: createToolUiMeta({
-      targetAgentId: createAgentPickerFieldMeta({
-        selection: "single",
-        valueField: "agentId"
+  if (env.OPENSCOUT_EXPOSE_DEPRECATED_INVOCATIONS_ASK === "1") {
+    server.registerTool("invocations_ask", {
+      title: "Deprecated Scout Invocation Ask",
+      description: "DEPRECATED compatibility surface. Do not use this as an agent front door; use ask to talk to the broker. Ask creates broker invocation and flight records as side effects, then use invocations_get or invocations_wait to observe those records. This tool is hidden unless OPENSCOUT_EXPOSE_DEPRECATED_INVOCATIONS_ASK=1 is set for an older client.",
+      inputSchema: object2({
+        body: string2().min(1),
+        currentDirectory: string2().optional(),
+        senderId: string2().optional(),
+        targetSessionId: targetSessionIdInputSchema,
+        targetAgentId: targetAgentIdInputSchema,
+        targetLabel: targetLabelInputSchema,
+        replyToSessionId: string2().describe("Optional requester session that should receive the eventual reply. When omitted, Codex MCP uses the current CODEX_THREAD_ID when available.").optional(),
+        labels: array(string2()).optional(),
+        workItem: workItemInputSchema.optional(),
+        channel: string2().optional(),
+        shouldSpeak: boolean2().optional(),
+        awaitReply: boolean2().describe("Compatibility alias for replyMode='inline'.").optional(),
+        replyMode: _enum2(REPLY_MODE_VALUES).describe("Reply delivery mode: 'inline' returns a quick acknowledgement or immediate completion, 'notify' returns immediately then emits notifications/scout/reply, and 'none' returns durable ids only. Inline acknowledgement waits use timeoutSeconds only as a caller wait budget.").optional(),
+        timeoutSeconds: number2().int().min(1).optional().describe("Caller wait budget in seconds for inline waits only; it never cancels or fails the broker ask.")
+      }).refine((value) => Boolean(value.targetSessionId?.trim() || value.targetAgentId?.trim() || value.targetLabel?.trim()), {
+        message: "Provide targetSessionId, targetAgentId, or targetLabel.",
+        path: ["targetSessionId"]
       }),
-      targetLabel: createAgentPickerFieldMeta({
-        selection: "single",
-        valueField: "label",
-        resolveTool: "agents_resolve"
+      outputSchema: askResultSchema,
+      annotations: {
+        readOnlyHint: false,
+        idempotentHint: false,
+        destructiveHint: false,
+        openWorldHint: false
+      },
+      _meta: createToolUiMeta({
+        targetSessionId: createAgentPickerFieldMeta({
+          selection: "single",
+          valueField: "sessionId"
+        }),
+        targetAgentId: createAgentPickerFieldMeta({
+          selection: "single",
+          valueField: "agentId"
+        }),
+        targetLabel: createAgentPickerFieldMeta({
+          selection: "single",
+          valueField: "label",
+          resolveTool: "agents_resolve"
+        })
       })
-    })
-  }, async ({
-    body,
-    currentDirectory,
-    senderId,
-    targetAgentId,
-    targetLabel,
-    labels,
-    workItem,
-    channel,
-    shouldSpeak,
-    awaitReply,
-    replyMode,
-    timeoutSeconds
-  }) => {
-    const resolvedCurrentDirectory = resolveToolCurrentDirectory(currentDirectory, options.defaultCurrentDirectory);
-    const resolvedSenderId = await resolveMcpSenderId(deps, senderId, resolvedCurrentDirectory, env);
-    const resolvedReplyMode = resolveAskReplyMode({ awaitReply, replyMode });
-    const shouldAwait = resolvedReplyMode === "inline";
-    if (targetAgentId?.trim()) {
-      const result2 = await deps.askAgentById({
+    }, async ({
+      body,
+      currentDirectory,
+      senderId,
+      targetSessionId,
+      targetAgentId,
+      targetLabel,
+      replyToSessionId,
+      labels,
+      workItem,
+      channel,
+      shouldSpeak,
+      awaitReply,
+      replyMode,
+      timeoutSeconds
+    }) => {
+      const resolvedCurrentDirectory = resolveToolCurrentDirectory(currentDirectory, options.defaultCurrentDirectory);
+      const resolvedSenderId = await resolveMcpSenderId(deps, senderId, resolvedCurrentDirectory, env);
+      const resolvedReplyMode = resolveAskReplyMode({ awaitReply, replyMode });
+      const shouldAwait = resolvedReplyMode === "inline";
+      const resolvedReplyToSessionId = resolveMcpReplyToSessionId(replyToSessionId, env);
+      if (targetSessionId?.trim()) {
+        const trimmedTargetSessionId = targetSessionId.trim();
+        const result2 = await deps.askSessionById({
+          senderId: resolvedSenderId,
+          targetSessionId: trimmedTargetSessionId,
+          body,
+          workItem,
+          channel,
+          shouldSpeak,
+          labels,
+          replyToSessionId: resolvedReplyToSessionId,
+          currentDirectory: resolvedCurrentDirectory,
+          source: "scout-mcp"
+        });
+        const waitResult2 = shouldAwait ? await waitForFlightForMcp({
+          deps,
+          brokerUrl: deps.resolveBrokerUrl(),
+          flight: result2.flight ?? null,
+          timeoutSeconds
+        }) : { flight: null, waitStatus: "not_requested" };
+        const completedFlight2 = waitResult2.flight;
+        const trackedWorkItem2 = result2.workItem ?? null;
+        const notificationScheduled2 = resolvedReplyMode === "notify" && Boolean(result2.flight);
+        const followArtifacts2 = buildScoutFollowArtifacts({
+          flight: completedFlight2 ?? result2.flight ?? null,
+          conversationId: result2.conversationId ?? null,
+          workItem: trackedWorkItem2,
+          targetSessionId: trimmedTargetSessionId,
+          targetAgentId: result2.flight?.targetAgentId ?? null
+        }, env);
+        if (resolvedReplyMode === "notify" && result2.flight) {
+          scheduleScoutReplyNotification({
+            server,
+            deps,
+            brokerUrl: deps.resolveBrokerUrl(),
+            flight: result2.flight,
+            context: {
+              currentDirectory: resolvedCurrentDirectory,
+              senderId: resolvedSenderId,
+              targetAgentId: result2.flight.targetAgentId ?? null,
+              targetLabel: null,
+              conversationId: result2.conversationId ?? null,
+              messageId: result2.messageId ?? null,
+              flightId: result2.flight.id,
+              workItem: trackedWorkItem2,
+              workId: trackedWorkItem2?.id ?? null,
+              workUrl: workUrlFor(trackedWorkItem2, env),
+              ids: followArtifacts2.ids,
+              links: followArtifacts2.links,
+              followUrl: followArtifacts2.followUrl
+            }
+          });
+        }
+        const unresolvedTargetId = result2.unresolvedTargetId ?? null;
+        const structuredContent2 = {
+          currentDirectory: resolvedCurrentDirectory,
+          senderId: resolvedSenderId,
+          targetAgentId: result2.flight?.targetAgentId ?? null,
+          targetSessionId: trimmedTargetSessionId,
+          targetLabel: null,
+          replyToSessionId: resolvedReplyToSessionId ?? null,
+          usedBroker: result2.usedBroker,
+          awaited: shouldAwait,
+          waitStatus: waitResult2.waitStatus,
+          replyMode: resolvedReplyMode,
+          delivery: notificationScheduled2 ? "mcp_notification" : shouldAwait ? "inline" : "none",
+          notification: resolvedReplyMode === "notify" ? {
+            method: "notifications/scout/reply",
+            status: notificationScheduled2 ? "scheduled" : "not_scheduled"
+          } : null,
+          conversationId: result2.conversationId ?? null,
+          messageId: result2.messageId ?? null,
+          flight: completedFlight2 ?? result2.flight ?? null,
+          flightId: completedFlight2?.id ?? result2.flight?.id ?? null,
+          output: waitResult2.waitStatus === "completed" || waitResult2.waitStatus === "terminal" ? completedFlight2?.output ?? completedFlight2?.summary ?? null : null,
+          unresolvedTargetId,
+          unresolvedTargetLabel: null,
+          workItem: trackedWorkItem2,
+          workId: trackedWorkItem2?.id ?? null,
+          workUrl: workUrlFor(trackedWorkItem2, env),
+          ids: followArtifacts2.ids,
+          links: followArtifacts2.links,
+          followUrl: followArtifacts2.followUrl,
+          targetDiagnostic: result2.targetDiagnostic ?? buildExactTargetIdsDiagnostic(unresolvedTargetId ? [unresolvedTargetId] : []),
+          startSuggestion: null
+        };
+        return {
+          content: createPlainTextContent(renderMcpAskSummary(structuredContent2)),
+          structuredContent: structuredContent2
+        };
+      }
+      if (targetAgentId?.trim()) {
+        const result2 = await deps.askAgentById({
+          senderId: resolvedSenderId,
+          targetAgentId: targetAgentId.trim(),
+          body,
+          workItem,
+          channel,
+          shouldSpeak,
+          labels,
+          replyToSessionId: resolvedReplyToSessionId,
+          currentDirectory: resolvedCurrentDirectory,
+          source: "scout-mcp"
+        });
+        const waitResult2 = shouldAwait ? await waitForFlightForMcp({
+          deps,
+          brokerUrl: deps.resolveBrokerUrl(),
+          flight: result2.flight ?? null,
+          timeoutSeconds
+        }) : { flight: null, waitStatus: "not_requested" };
+        const completedFlight2 = waitResult2.flight;
+        const trackedWorkItem2 = result2.workItem ?? null;
+        const notificationScheduled2 = resolvedReplyMode === "notify" && Boolean(result2.flight);
+        const followArtifacts2 = buildScoutFollowArtifacts({
+          flight: completedFlight2 ?? result2.flight ?? null,
+          conversationId: result2.conversationId ?? null,
+          workItem: trackedWorkItem2,
+          targetAgentId: targetAgentId.trim()
+        }, env);
+        if (resolvedReplyMode === "notify" && result2.flight) {
+          scheduleScoutReplyNotification({
+            server,
+            deps,
+            brokerUrl: deps.resolveBrokerUrl(),
+            flight: result2.flight,
+            context: {
+              currentDirectory: resolvedCurrentDirectory,
+              senderId: resolvedSenderId,
+              targetAgentId: targetAgentId.trim(),
+              targetLabel: null,
+              conversationId: result2.conversationId ?? null,
+              messageId: result2.messageId ?? null,
+              flightId: result2.flight.id,
+              workItem: trackedWorkItem2,
+              workId: trackedWorkItem2?.id ?? null,
+              workUrl: workUrlFor(trackedWorkItem2, env),
+              ids: followArtifacts2.ids,
+              links: followArtifacts2.links,
+              followUrl: followArtifacts2.followUrl
+            }
+          });
+        }
+        const unresolvedTargetId = result2.unresolvedTargetId ?? null;
+        const structuredContent2 = {
+          currentDirectory: resolvedCurrentDirectory,
+          senderId: resolvedSenderId,
+          targetAgentId: targetAgentId.trim(),
+          targetSessionId: null,
+          targetLabel: null,
+          replyToSessionId: resolvedReplyToSessionId ?? null,
+          usedBroker: result2.usedBroker,
+          awaited: shouldAwait,
+          waitStatus: waitResult2.waitStatus,
+          replyMode: resolvedReplyMode,
+          delivery: notificationScheduled2 ? "mcp_notification" : shouldAwait ? "inline" : "none",
+          notification: resolvedReplyMode === "notify" ? {
+            method: "notifications/scout/reply",
+            status: notificationScheduled2 ? "scheduled" : "not_scheduled"
+          } : null,
+          conversationId: result2.conversationId ?? null,
+          messageId: result2.messageId ?? null,
+          flight: completedFlight2 ?? result2.flight ?? null,
+          flightId: completedFlight2?.id ?? result2.flight?.id ?? null,
+          output: waitResult2.waitStatus === "completed" || waitResult2.waitStatus === "terminal" ? completedFlight2?.output ?? completedFlight2?.summary ?? null : null,
+          unresolvedTargetId,
+          unresolvedTargetLabel: null,
+          workItem: trackedWorkItem2,
+          workId: trackedWorkItem2?.id ?? null,
+          workUrl: workUrlFor(trackedWorkItem2, env),
+          ids: followArtifacts2.ids,
+          links: followArtifacts2.links,
+          followUrl: followArtifacts2.followUrl,
+          targetDiagnostic: result2.targetDiagnostic ?? buildExactTargetIdsDiagnostic(unresolvedTargetId ? [unresolvedTargetId] : []),
+          startSuggestion: null
+        };
+        return {
+          content: createPlainTextContent(renderMcpAskSummary(structuredContent2)),
+          structuredContent: structuredContent2
+        };
+      }
+      const targetCheck = await diagnosePreciseTargetLabel({
+        deps,
+        targetLabel,
+        currentDirectory: resolvedCurrentDirectory
+      });
+      if (targetCheck.blocked) {
+        const structuredContent2 = {
+          currentDirectory: resolvedCurrentDirectory,
+          senderId: resolvedSenderId,
+          targetAgentId: null,
+          targetSessionId: null,
+          targetLabel: targetLabel.trim(),
+          replyToSessionId: resolvedReplyToSessionId ?? null,
+          usedBroker: true,
+          awaited: shouldAwait,
+          waitStatus: "not_requested",
+          replyMode: resolvedReplyMode,
+          delivery: "none",
+          notification: null,
+          conversationId: null,
+          messageId: null,
+          flight: null,
+          flightId: null,
+          output: null,
+          unresolvedTargetId: null,
+          unresolvedTargetLabel: targetLabel.trim(),
+          workItem: null,
+          workId: null,
+          workUrl: null,
+          targetDiagnostic: targetCheck.diagnostic,
+          startSuggestion: targetCheck.startSuggestion
+        };
+        return {
+          content: createPlainTextContent(renderMcpAskSummary(structuredContent2)),
+          structuredContent: structuredContent2
+        };
+      }
+      const result = await deps.askQuestion({
         senderId: resolvedSenderId,
-        targetAgentId: targetAgentId.trim(),
+        targetLabel: targetLabel.trim(),
         body,
         workItem,
         channel,
         shouldSpeak,
         labels,
+        replyToSessionId: resolvedReplyToSessionId,
         currentDirectory: resolvedCurrentDirectory,
         source: "scout-mcp"
       });
-      const waitResult2 = shouldAwait ? await waitForFlightForMcp({
+      const waitResult = shouldAwait ? await waitForFlightForMcp({
         deps,
         brokerUrl: deps.resolveBrokerUrl(),
-        flight: result2.flight ?? null,
+        flight: result.flight ?? null,
         timeoutSeconds
       }) : { flight: null, waitStatus: "not_requested" };
-      const completedFlight2 = waitResult2.flight;
-      const trackedWorkItem2 = result2.workItem ?? null;
-      const notificationScheduled2 = resolvedReplyMode === "notify" && Boolean(result2.flight);
-      const followArtifacts2 = buildScoutFollowArtifacts({
-        flight: completedFlight2 ?? result2.flight ?? null,
-        conversationId: result2.conversationId ?? null,
-        workItem: trackedWorkItem2,
-        targetAgentId: targetAgentId.trim()
+      const completedFlight = waitResult.flight;
+      const trackedWorkItem = result.workItem ?? null;
+      const notificationScheduled = resolvedReplyMode === "notify" && Boolean(result.flight);
+      const followArtifacts = buildScoutFollowArtifacts({
+        flight: completedFlight ?? result.flight ?? null,
+        conversationId: result.conversationId ?? null,
+        workItem: trackedWorkItem,
+        targetAgentId: result.flight?.targetAgentId ?? null
       }, env);
-      if (resolvedReplyMode === "notify" && result2.flight) {
+      if (resolvedReplyMode === "notify" && result.flight) {
         scheduleScoutReplyNotification({
           server,
           deps,
           brokerUrl: deps.resolveBrokerUrl(),
-          flight: result2.flight,
-          timeoutSeconds,
+          flight: result.flight,
           context: {
             currentDirectory: resolvedCurrentDirectory,
             senderId: resolvedSenderId,
-            targetAgentId: targetAgentId.trim(),
-            targetLabel: null,
-            conversationId: result2.conversationId ?? null,
-            messageId: result2.messageId ?? null,
-            flightId: result2.flight.id,
-            workItem: trackedWorkItem2,
-            workId: trackedWorkItem2?.id ?? null,
-            workUrl: workUrlFor(trackedWorkItem2, env),
-            ids: followArtifacts2.ids,
-            links: followArtifacts2.links,
-            followUrl: followArtifacts2.followUrl
+            targetAgentId: result.flight.targetAgentId ?? null,
+            targetLabel: targetLabel.trim(),
+            conversationId: result.conversationId ?? null,
+            messageId: result.messageId ?? null,
+            bindingRef: result.bindingRef ? `ref:${result.bindingRef}` : null,
+            flightId: result.flight.id,
+            workItem: trackedWorkItem,
+            workId: trackedWorkItem?.id ?? null,
+            workUrl: workUrlFor(trackedWorkItem, env),
+            ids: followArtifacts.ids,
+            links: followArtifacts.links,
+            followUrl: followArtifacts.followUrl
           }
         });
       }
-      const unresolvedTargetId = result2.unresolvedTargetId ?? null;
-      const structuredContent2 = {
+      const startSuggestion = result.unresolvedTarget ? await buildStartSuggestionForTarget(result.unresolvedTarget, resolvedCurrentDirectory) : null;
+      const structuredContent = {
         currentDirectory: resolvedCurrentDirectory,
         senderId: resolvedSenderId,
-        targetAgentId: targetAgentId.trim(),
-        targetLabel: null,
-        usedBroker: result2.usedBroker,
+        targetAgentId: result.flight?.targetAgentId ?? null,
+        targetSessionId: null,
+        targetLabel: targetLabel.trim(),
+        replyToSessionId: resolvedReplyToSessionId ?? null,
+        usedBroker: result.usedBroker,
         awaited: shouldAwait,
-        waitStatus: waitResult2.waitStatus,
+        waitStatus: waitResult.waitStatus,
         replyMode: resolvedReplyMode,
-        delivery: notificationScheduled2 ? "mcp_notification" : shouldAwait ? "inline" : "none",
+        delivery: notificationScheduled ? "mcp_notification" : shouldAwait ? "inline" : "none",
         notification: resolvedReplyMode === "notify" ? {
           method: "notifications/scout/reply",
-          status: notificationScheduled2 ? "scheduled" : "not_scheduled"
+          status: notificationScheduled ? "scheduled" : "not_scheduled"
         } : null,
-        conversationId: result2.conversationId ?? null,
-        messageId: result2.messageId ?? null,
-        flight: completedFlight2 ?? result2.flight ?? null,
-        flightId: completedFlight2?.id ?? result2.flight?.id ?? null,
-        output: waitResult2.waitStatus === "completed" || waitResult2.waitStatus === "terminal" ? completedFlight2?.output ?? completedFlight2?.summary ?? null : null,
-        unresolvedTargetId,
-        unresolvedTargetLabel: null,
-        workItem: trackedWorkItem2,
-        workId: trackedWorkItem2?.id ?? null,
-        workUrl: workUrlFor(trackedWorkItem2, env),
-        ids: followArtifacts2.ids,
-        links: followArtifacts2.links,
-        followUrl: followArtifacts2.followUrl,
-        targetDiagnostic: result2.targetDiagnostic ?? buildExactTargetIdsDiagnostic(unresolvedTargetId ? [unresolvedTargetId] : []),
-        startSuggestion: null
-      };
-      return {
-        content: createPlainTextContent(renderMcpAskSummary(structuredContent2)),
-        structuredContent: structuredContent2
-      };
-    }
-    const targetCheck = await diagnosePreciseTargetLabel({
-      deps,
-      targetLabel,
-      currentDirectory: resolvedCurrentDirectory
-    });
-    if (targetCheck.blocked) {
-      const structuredContent2 = {
-        currentDirectory: resolvedCurrentDirectory,
-        senderId: resolvedSenderId,
-        targetAgentId: null,
-        targetLabel: targetLabel.trim(),
-        usedBroker: true,
-        awaited: shouldAwait,
-        waitStatus: "not_requested",
-        replyMode: resolvedReplyMode,
-        delivery: "none",
-        notification: null,
-        conversationId: null,
-        messageId: null,
-        flight: null,
-        flightId: null,
-        output: null,
+        conversationId: result.conversationId ?? null,
+        messageId: result.messageId ?? null,
+        bindingRef: result.bindingRef ? `ref:${result.bindingRef}` : null,
+        flight: completedFlight ?? result.flight ?? null,
+        flightId: completedFlight?.id ?? result.flight?.id ?? null,
+        output: waitResult.waitStatus === "completed" || waitResult.waitStatus === "terminal" ? completedFlight?.output ?? completedFlight?.summary ?? null : null,
         unresolvedTargetId: null,
-        unresolvedTargetLabel: targetLabel.trim(),
-        workItem: null,
-        workId: null,
-        workUrl: null,
-        targetDiagnostic: targetCheck.diagnostic,
-        startSuggestion: targetCheck.startSuggestion
+        unresolvedTargetLabel: result.unresolvedTarget ?? null,
+        workItem: trackedWorkItem,
+        workId: trackedWorkItem?.id ?? null,
+        workUrl: workUrlFor(trackedWorkItem, env),
+        ids: followArtifacts.ids,
+        links: followArtifacts.links,
+        followUrl: followArtifacts.followUrl,
+        targetDiagnostic: result.targetDiagnostic ?? null,
+        startSuggestion
       };
       return {
-        content: createPlainTextContent(renderMcpAskSummary(structuredContent2)),
-        structuredContent: structuredContent2
+        content: createPlainTextContent(renderMcpAskSummary(structuredContent)),
+        structuredContent
       };
-    }
-    const result = await deps.askQuestion({
-      senderId: resolvedSenderId,
-      targetLabel: targetLabel.trim(),
-      body,
-      workItem,
-      channel,
-      shouldSpeak,
-      labels,
-      currentDirectory: resolvedCurrentDirectory,
-      source: "scout-mcp"
     });
-    const waitResult = shouldAwait ? await waitForFlightForMcp({
-      deps,
-      brokerUrl: deps.resolveBrokerUrl(),
-      flight: result.flight ?? null,
-      timeoutSeconds
-    }) : { flight: null, waitStatus: "not_requested" };
-    const completedFlight = waitResult.flight;
-    const trackedWorkItem = result.workItem ?? null;
-    const notificationScheduled = resolvedReplyMode === "notify" && Boolean(result.flight);
-    const followArtifacts = buildScoutFollowArtifacts({
-      flight: completedFlight ?? result.flight ?? null,
-      conversationId: result.conversationId ?? null,
-      workItem: trackedWorkItem,
-      targetAgentId: result.flight?.targetAgentId ?? null
-    }, env);
-    if (resolvedReplyMode === "notify" && result.flight) {
-      scheduleScoutReplyNotification({
-        server,
-        deps,
-        brokerUrl: deps.resolveBrokerUrl(),
-        flight: result.flight,
-        timeoutSeconds,
-        context: {
-          currentDirectory: resolvedCurrentDirectory,
-          senderId: resolvedSenderId,
-          targetAgentId: result.flight.targetAgentId ?? null,
-          targetLabel: targetLabel.trim(),
-          conversationId: result.conversationId ?? null,
-          messageId: result.messageId ?? null,
-          bindingRef: result.bindingRef ? `ref:${result.bindingRef}` : null,
-          flightId: result.flight.id,
-          workItem: trackedWorkItem,
-          workId: trackedWorkItem?.id ?? null,
-          workUrl: workUrlFor(trackedWorkItem, env),
-          ids: followArtifacts.ids,
-          links: followArtifacts.links,
-          followUrl: followArtifacts.followUrl
-        }
-      });
-    }
-    const startSuggestion = result.unresolvedTarget ? await buildStartSuggestionForTarget(result.unresolvedTarget, resolvedCurrentDirectory) : null;
-    const structuredContent = {
-      currentDirectory: resolvedCurrentDirectory,
-      senderId: resolvedSenderId,
-      targetAgentId: result.flight?.targetAgentId ?? null,
-      targetLabel: targetLabel.trim(),
-      usedBroker: result.usedBroker,
-      awaited: shouldAwait,
-      waitStatus: waitResult.waitStatus,
-      replyMode: resolvedReplyMode,
-      delivery: notificationScheduled ? "mcp_notification" : shouldAwait ? "inline" : "none",
-      notification: resolvedReplyMode === "notify" ? {
-        method: "notifications/scout/reply",
-        status: notificationScheduled ? "scheduled" : "not_scheduled"
-      } : null,
-      conversationId: result.conversationId ?? null,
-      messageId: result.messageId ?? null,
-      bindingRef: result.bindingRef ? `ref:${result.bindingRef}` : null,
-      flight: completedFlight ?? result.flight ?? null,
-      flightId: completedFlight?.id ?? result.flight?.id ?? null,
-      output: waitResult.waitStatus === "completed" || waitResult.waitStatus === "terminal" ? completedFlight?.output ?? completedFlight?.summary ?? null : null,
-      unresolvedTargetId: null,
-      unresolvedTargetLabel: result.unresolvedTarget ?? null,
-      workItem: trackedWorkItem,
-      workId: trackedWorkItem?.id ?? null,
-      workUrl: workUrlFor(trackedWorkItem, env),
-      ids: followArtifacts.ids,
-      links: followArtifacts.links,
-      followUrl: followArtifacts.followUrl,
-      targetDiagnostic: result.targetDiagnostic ?? null,
-      startSuggestion
-    };
-    return {
-      content: createPlainTextContent(renderMcpAskSummary(structuredContent)),
-      structuredContent
-    };
-  });
+  }
   server.registerTool("invocations_get", {
     title: "Get Scout Ask",
     description: "Fetch the current broker flight state for a previously-created Scout ask or invocation. Use this with a flightId returned by ask to observe long-running work without blocking the original ask call.",
@@ -54331,11 +55614,18 @@ function createScoutMcpServer(options) {
   }, async ({ currentDirectory, flightId }) => {
     const resolvedCurrentDirectory = resolveToolCurrentDirectory(currentDirectory, options.defaultCurrentDirectory);
     const trimmedFlightId = flightId.trim();
-    const flight = await deps.getFlight(deps.resolveBrokerUrl(), trimmedFlightId);
+    const brokerUrl = deps.resolveBrokerUrl();
+    const flight = await deps.getFlight(brokerUrl, trimmedFlightId);
+    const lifecycle2 = await loadInvocationLifecycleForFlight({
+      deps,
+      brokerUrl,
+      flight
+    });
     const structuredContent = buildInvocationLookupContent({
       currentDirectory: resolvedCurrentDirectory,
       flightId: trimmedFlightId,
       flight,
+      lifecycle: lifecycle2,
       waitStatus: "not_requested",
       env
     });
@@ -54350,7 +55640,7 @@ function createScoutMcpServer(options) {
     inputSchema: object2({
       currentDirectory: string2().optional(),
       flightId: string2().min(1),
-      timeoutSeconds: number2().int().min(1).max(300).default(30)
+      timeoutSeconds: number2().int().min(1).max(300).default(30).describe("Caller wait budget in seconds; elapsed time returns the latest state and does not cancel or fail the ask.")
     }),
     outputSchema: invocationLookupResultSchema,
     annotations: {
@@ -54362,23 +55652,30 @@ function createScoutMcpServer(options) {
   }, async ({ currentDirectory, flightId, timeoutSeconds }) => {
     const resolvedCurrentDirectory = resolveToolCurrentDirectory(currentDirectory, options.defaultCurrentDirectory);
     const trimmedFlightId = flightId.trim();
+    const brokerUrl = deps.resolveBrokerUrl();
     let flight = null;
-    let waitStatus = "timeout";
+    let waitStatus = "pending";
     try {
-      flight = await deps.waitForFlight(deps.resolveBrokerUrl(), trimmedFlightId, { timeoutSeconds });
+      flight = await deps.waitForFlight(brokerUrl, trimmedFlightId, { timeoutSeconds });
       waitStatus = "completed";
     } catch (error48) {
-      flight = await deps.getFlight(deps.resolveBrokerUrl(), trimmedFlightId);
+      flight = await deps.getFlight(brokerUrl, trimmedFlightId);
       if (isTerminalFlightState2(flight?.state)) {
         waitStatus = "terminal";
       } else if (!(error48 instanceof Error) || !error48.message.includes("Timed out waiting for flight")) {
         throw error48;
       }
     }
+    const lifecycle2 = await loadInvocationLifecycleForFlight({
+      deps,
+      brokerUrl,
+      flight
+    });
     const structuredContent = buildInvocationLookupContent({
       currentDirectory: resolvedCurrentDirectory,
       flightId: trimmedFlightId,
       flight,
+      lifecycle: lifecycle2,
       waitStatus,
       env
     });
@@ -54545,7 +55842,7 @@ async function runScoutMcpServer(options) {
   const transport = new StdioServerTransport;
   await server.connect(transport);
 }
-var AGENT_STATE_VALUES, REGISTRATION_KIND_VALUES, RESOLVE_KIND_VALUES, MESSAGE_ROUTE_KIND_VALUES, MESSAGE_ROUTING_ERROR_VALUES, REPLY_MODE_VALUES, REPLY_DELIVERY_VALUES, LOCAL_AGENT_HARNESS_VALUES, DEFAULT_ASK_ACK_TIMEOUT_SECONDS2 = 30, SCOUT_MCP_UI_META_KEY = "openscout/ui", scoutAgentToolIconMeta, scoutAgentAvatarMeta, targetLabelInputSchema, targetAgentIdInputSchema, mentionAgentIdsInputSchema, flightSchema, labelBriefFlightSchema, labelBriefWorkItemSchema, labelBriefSchema, labelFeedEventSchema, labelFeedSchema, trackedWorkItemSchema, workItemInputSchema, waitingOnSchema, progressSchema, workItemUpdateSchema, agentCandidateSchema, scoutReturnAddressSchema, scoutAgentCardSchema, localAgentStatusSchema, whoAmISchema, brokerMessageSchema, messagesInboxResultSchema, messagesChannelResultSchema, brokerFeedRecordSchema, brokerFeedItemSchema, brokerFeedSchema, searchResultSchema, resolveResultSchema, startSuggestionSchema, followIdsSchema, followLinksSchema, sendRoutingAdviceSchema, sendResultSchema, replyContextSchema, currentReplyContextResultSchema, replyResultSchema, cardCreateResultSchema, agentStartResultSchema, currentSessionAttachResultSchema, askResultSchema, askReceiptSchema, invocationLookupResultSchema, workUpdateResultSchema;
+var AGENT_STATE_VALUES, REGISTRATION_KIND_VALUES, RESOLVE_KIND_VALUES, MESSAGE_ROUTE_KIND_VALUES, MESSAGE_ROUTING_ERROR_VALUES, REPLY_MODE_VALUES, REPLY_DELIVERY_VALUES, LOCAL_AGENT_HARNESS_VALUES, DEFAULT_ASK_ACK_TIMEOUT_SECONDS2 = 30, SCOUT_MCP_UI_META_KEY = "openscout/ui", scoutAgentToolIconMeta, scoutAgentAvatarMeta, targetLabelInputSchema, targetAgentIdInputSchema, targetSessionIdInputSchema, projectPathInputSchema, mentionAgentIdsInputSchema, flightSchema, invocationLifecycleSchema, labelBriefFlightSchema, labelBriefWorkItemSchema, labelBriefSchema, labelFeedEventSchema, labelFeedSchema, trackedWorkItemSchema, workItemInputSchema, waitingOnSchema, progressSchema, workItemUpdateSchema, agentCandidateSchema, scoutReturnAddressSchema, scoutAgentCardLifecycleSchema, scoutAgentCardSchema, localAgentStatusSchema, whoAmISchema, brokerMessageSchema, messagesInboxResultSchema, messagesChannelResultSchema, brokerFeedRecordSchema, brokerFeedItemSchema, brokerFeedSchema, searchResultSchema, resolveResultSchema, startSuggestionSchema, followIdsSchema, followLinksSchema, sendRoutingAdviceSchema, sendResultSchema, replyContextSchema, currentReplyContextResultSchema, replyResultSchema, cardCreateResultSchema, agentStartResultSchema, currentSessionAttachResultSchema, askResultSchema, askReceiptSchema, invocationLookupResultSchema, workUpdateResultSchema;
 var init_scout_mcp = __esm(() => {
   init_mcp();
   init_stdio2();
@@ -54590,8 +55887,10 @@ var init_scout_mcp = __esm(() => {
     colorSeedField: "agentId",
     fallbackGlyph: "@"
   };
-  targetLabelInputSchema = string2().describe("Scout agent handle to contact, such as @talkie or @talkie#codex?5.5").optional();
+  targetLabelInputSchema = string2().describe("Scout agent handle to contact, such as @talkie. Treat harness/model/profile as instance constraints, not the base agent identity.").optional();
   targetAgentIdInputSchema = string2().describe("Exact Scout agent id when already known, such as talkie.master.mini").optional();
+  targetSessionIdInputSchema = string2().describe("Exact Scout session id to continue, such as a CODEX_THREAD_ID or attached runtime session id").optional();
+  projectPathInputSchema = string2().min(1).describe("Project root to ask when you do not have a specific agent in mind; Scout resolves or creates the concrete agent instance.").optional();
   mentionAgentIdsInputSchema = array(string2()).describe("Exact Scout agent ids to target directly when you already know them").optional();
   flightSchema = object2({
     id: string2(),
@@ -54607,6 +55906,26 @@ var init_scout_mcp = __esm(() => {
     labels: array(string2()).optional(),
     metadata: record(string2(), unknown()).optional()
   });
+  invocationLifecycleSchema = object2({
+    invocationId: string2(),
+    flightId: string2().optional(),
+    state: string2(),
+    targetAgentId: string2().optional(),
+    targetEndpointId: string2().optional(),
+    peerNodeId: string2().optional(),
+    peerFlightId: string2().optional(),
+    workId: string2().optional(),
+    actionId: string2().optional(),
+    idempotencyKey: string2().optional(),
+    acknowledgedAt: number2().optional(),
+    startedAt: number2().optional(),
+    completedAt: number2().optional(),
+    expiresAt: number2().optional(),
+    lastProgressAt: number2().optional(),
+    terminal: object2({}).catchall(unknown()).optional(),
+    deliveries: array(object2({}).catchall(unknown())).optional(),
+    metadata: record(string2(), unknown()).optional()
+  }).catchall(unknown());
   labelBriefFlightSchema = object2({
     id: string2(),
     invocationId: string2(),
@@ -54762,7 +56081,8 @@ var init_scout_mcp = __esm(() => {
     workspace: string2().nullable(),
     node: string2().nullable(),
     projectRoot: string2().nullable(),
-    transport: string2().nullable()
+    transport: string2().nullable(),
+    sessionId: string2().nullable().optional()
   });
   scoutReturnAddressSchema = object2({
     actorId: string2(),
@@ -54777,6 +56097,14 @@ var init_scout_mcp = __esm(() => {
     sessionId: string2().optional(),
     metadata: record(string2(), unknown()).optional()
   });
+  scoutAgentCardLifecycleSchema = object2({
+    kind: _enum2(["persistent", "one_time"]),
+    createdAt: number2().optional(),
+    createdById: string2().optional(),
+    expiresAt: number2().optional(),
+    maxUses: number2().optional(),
+    inboxConversationId: string2().optional()
+  });
   scoutAgentCardSchema = object2({
     id: string2(),
     agentId: string2(),
@@ -54796,6 +56124,7 @@ var init_scout_mcp = __esm(() => {
     createdById: string2().optional(),
     brokerRegistered: boolean2(),
     inboxConversationId: string2().optional(),
+    lifecycle: scoutAgentCardLifecycleSchema.optional(),
     returnAddress: scoutReturnAddressSchema,
     metadata: record(string2(), unknown()).optional()
   });
@@ -55077,10 +56406,12 @@ var init_scout_mcp = __esm(() => {
     currentDirectory: string2(),
     senderId: string2(),
     targetAgentId: string2().nullable(),
+    targetSessionId: string2().nullable().optional(),
     targetLabel: string2().nullable(),
+    replyToSessionId: string2().nullable().optional(),
     usedBroker: boolean2(),
     awaited: boolean2(),
-    waitStatus: _enum2(["not_requested", "acknowledged", "completed", "terminal", "timeout"]).optional(),
+    waitStatus: _enum2(["not_requested", "acknowledged", "completed", "terminal", "pending"]).optional(),
     replyMode: _enum2(REPLY_MODE_VALUES).optional(),
     delivery: _enum2(REPLY_DELIVERY_VALUES).optional(),
     notification: object2({
@@ -55115,6 +56446,11 @@ var init_scout_mcp = __esm(() => {
       workId: string2().optional(),
       bindingRef: string2().optional()
     }),
+    delivery: _enum2(REPLY_DELIVERY_VALUES).optional(),
+    notification: object2({
+      method: literal("notifications/scout/reply"),
+      status: _enum2(["scheduled", "not_scheduled"])
+    }).optional(),
     next: object2({
       tool: _enum2(["agents_resolve", "agents_search", "agents_start"]),
       arguments: record(string2(), unknown()),
@@ -55129,9 +56465,10 @@ var init_scout_mcp = __esm(() => {
     currentDirectory: string2(),
     flightId: string2(),
     found: boolean2(),
-    waitStatus: _enum2(["not_requested", "completed", "terminal", "timeout"]).optional(),
+    waitStatus: _enum2(["not_requested", "completed", "terminal", "pending"]).optional(),
     terminal: boolean2(),
     flight: flightSchema.nullable(),
+    lifecycle: invocationLifecycleSchema.nullable().optional(),
     output: string2().nullable(),
     error: string2().nullable(),
     ids: followIdsSchema.optional(),
@@ -55489,14 +56826,13 @@ function renderMcpCommandHelp() {
     "  messages_channel read recent messages from a named channel",
     "  broker_feed      native broker messages/status/errors for an agent",
     "  session_attach_current",
-    "                   attach the current live Codex session to Scout",
-    "  card_create      fresh reply-ready return address",
-    "  agents_start     start/create a concrete local agent session",
+    "                   pro integration: attach the current live Codex session",
+    "  card_create      pro integration: fresh reply-ready return address",
+    "  agents_start     pro integration: start/create a concrete local agent session",
     "  agents_search    find likely targets when routing is ambiguous",
     "  agents_resolve   pin one exact target when needed",
-    "  ask              agent-to-agent work with compact lifecycle receipt",
+    "  ask              broker front door for agent-to-agent work/replies",
     "  messages_send    tell / update with explicit target fields or channel",
-    "  invocations_ask  low-level invocation compatibility surface",
     "  invocations_get  fetch current state for an existing ask flight",
     "  invocations_wait bounded wait for an existing ask flight",
     "  work_update      progress / waiting / review / done for existing work",
@@ -59527,6 +60863,14 @@ function sqlQuoteLiteral(value) {
 function sqlStringList(values) {
   return `(${values.map(sqlQuoteLiteral).join(",")})`;
 }
+function sqlTimestampMsExpression(valueExpression) {
+  return `CASE
+    WHEN ${valueExpression} IS NULL THEN NULL
+    WHEN CAST(${valueExpression} AS REAL) < ${EPOCH_MILLISECONDS_FLOOR}
+      THEN CAST(CAST(${valueExpression} AS REAL) * 1000 AS INTEGER)
+    ELSE CAST(${valueExpression} AS INTEGER)
+  END`;
+}
 function queryExecutingAgentIds() {
   return new Set(db().prepare(`SELECT DISTINCT target_agent_id FROM flights
        WHERE state = 'running'`).all().map((row) => row.target_agent_id));
@@ -59598,6 +60942,9 @@ function queryMobileAgents(limit = 50) {
   });
 }
 function queryMobileSessions(limit = 50) {
+  const conversationCreatedAtExpression = sqlTimestampMsExpression("c.created_at");
+  const messageCreatedAtExpression = sqlTimestampMsExpression("created_at");
+  const previewMessageCreatedAtExpression = sqlTimestampMsExpression("created_at");
   const rows = db().prepare(`SELECT
        c.id,
        c.kind,
@@ -59605,12 +60952,12 @@ function queryMobileSessions(limit = 50) {
        c.metadata_json
      FROM conversations c
      WHERE c.kind = 'direct'
-     ORDER BY c.created_at DESC
+     ORDER BY ${conversationCreatedAtExpression} DESC
      LIMIT ?`).all(limit);
   const memberStmt = db().prepare(`SELECT actor_id FROM conversation_members WHERE conversation_id = ?`);
-  const statsStmt = db().prepare(`SELECT COUNT(*) AS cnt, MAX(created_at) AS last_at FROM messages WHERE conversation_id = ?`);
+  const statsStmt = db().prepare(`SELECT COUNT(*) AS cnt, MAX(${messageCreatedAtExpression}) AS last_at FROM messages WHERE conversation_id = ?`);
   const previewStmt = db().prepare(`SELECT body FROM messages WHERE conversation_id = ? AND actor_id != 'operator'
-     ORDER BY created_at DESC LIMIT 1`);
+     ORDER BY ${previewMessageCreatedAtExpression} DESC LIMIT 1`);
   return rows.map((r) => {
     const participants = memberStmt.all(r.id).map((m) => m.actor_id);
     const agentId = participants.find((p) => p !== "operator") ?? null;
@@ -59786,7 +61133,7 @@ var _db = null, HOME, LATEST_AGENT_ENDPOINT_JOIN = `LEFT JOIN agent_endpoints ep
   WHERE ep2.agent_id = a.id
   ORDER BY ep2.updated_at DESC
   LIMIT 1
-)`, ACTIVE_FLIGHT_STATES_SQL, ACTIVE_FLIGHT_MAX_AGE_MS, ACTIVE_WORK_STATES_SQL;
+)`, ACTIVE_FLIGHT_STATES_SQL, ACTIVE_FLIGHT_MAX_AGE_MS, EPOCH_MILLISECONDS_FLOOR = 1000000000000, ACTIVE_WORK_STATES_SQL;
 var init_db_queries = __esm(() => {
   HOME = homedir23();
   ACTIVE_FLIGHT_STATES_SQL = sqlStringList(["running", "waking", "waiting", "queued"]);
@@ -59795,7 +61142,7 @@ var init_db_queries = __esm(() => {
 });
 
 // ../../apps/desktop/src/core/mobile/service.ts
-import { basename as basename12, resolve as resolve16 } from "path";
+import { basename as basename13, resolve as resolve16 } from "path";
 function normalizeTimestamp2(value) {
   if (!value)
     return null;
@@ -59810,6 +61157,27 @@ function metadataString4(metadata, key) {
   const value = metadata?.[key];
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
+function metadataBoolean2(metadata, key) {
+  return metadata?.[key] === true;
+}
+function isBrokerRequesterWaitTimeoutStatusMessage(message) {
+  if (message.class !== "status" || 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");
+}
+function isRequesterWaitTimeoutFlight(flight) {
+  return metadataBoolean2(flight.metadata, "requesterTimedOut") || metadataString4(flight.metadata, "timeoutScope") === "requester_wait" || Boolean(flight.summary?.includes("Scout stopped waiting for a synchronous result"));
+}
+function isInactiveAgent(agent) {
+  return metadataBoolean2(agent?.metadata, "retiredFromFleet") || metadataBoolean2(agent?.metadata, "staleLocalRegistration");
+}
+function isInactiveEndpoint(snapshot, endpoint) {
+  if (!endpoint) {
+    return true;
+  }
+  return metadataBoolean2(endpoint.metadata, "retiredFromFleet") || metadataBoolean2(endpoint.metadata, "staleLocalRegistration") || isInactiveAgent(snapshot.agents[endpoint.agentId]);
+}
 function titleCaseToken(value) {
   return value.length === 0 ? value : `${value[0].toUpperCase()}${value.slice(1)}`;
 }
@@ -59864,6 +61232,9 @@ async function loadMobileWorkspaceInventory(currentDirectory) {
 function latestMessageByConversation(snapshot) {
   const buckets = new Map;
   for (const message of Object.values(snapshot.messages)) {
+    if (isBrokerRequesterWaitTimeoutStatusMessage(message)) {
+      continue;
+    }
     const next = buckets.get(message.conversationId) ?? [];
     next.push(message);
     buckets.set(message.conversationId, next);
@@ -59882,14 +61253,14 @@ function agentDisplayName(snapshot, agentId) {
   return snapshot.agents[agentId]?.displayName ?? snapshot.actors[agentId]?.displayName ?? agentId;
 }
 function endpointForAgent(snapshot, agentId) {
-  return Object.values(snapshot.endpoints).find((endpoint) => endpoint.agentId === agentId) ?? null;
+  return Object.values(snapshot.endpoints).find((endpoint) => endpoint.agentId === agentId && !isInactiveEndpoint(snapshot, endpoint)) ?? null;
 }
 function buildMobileAgentSummary(snapshot, agent) {
   const endpoint = endpointForAgent(snapshot, agent.id);
   const flights = Object.values(snapshot.flights).filter((flight) => flight.targetAgentId === agent.id);
   const hasWorkingFlight = flights.some((flight) => flight.state === "running");
   const lastAuthoredMessageAt = Object.values(snapshot.messages).filter((message) => message.actorId === agent.id).reduce((latest, message) => {
-    const createdAt = normalizeTimestamp2(message.createdAt);
+    const createdAt = normalizeTimestampMs(message.createdAt);
     return typeof createdAt === "number" && (!latest || createdAt > latest) ? createdAt : latest;
   }, null);
   const state = hasWorkingFlight ? "working" : endpoint && endpoint.state !== "offline" ? "available" : "offline";
@@ -59916,7 +61287,7 @@ function buildMobileSessionSummaries(snapshot) {
     const latestMessage = messages2.at(-1) ?? null;
     const directAgentId = conversation.kind === "direct" ? conversation.participantIds.find((participantId) => participantId !== "operator") ?? null : null;
     const agent = directAgentId ? snapshot.agents[directAgentId] ?? null : null;
-    if (!directAgentId || !agent || messages2.length === 0) {
+    if (!directAgentId || !agent || isInactiveAgent(agent) || messages2.length === 0) {
       return [];
     }
     const endpoint = endpointForAgent(snapshot, directAgentId);
@@ -59934,7 +61305,7 @@ function buildMobileSessionSummaries(snapshot) {
       currentBranch: metadataString4(endpoint?.metadata, "branch") ?? metadataString4(endpoint?.metadata, "workspaceQualifier") ?? metadataString4(agent?.metadata, "branch") ?? metadataString4(agent?.metadata, "workspaceQualifier"),
       preview: latestMessage?.body ?? null,
       messageCount: messages2.length,
-      lastMessageAt: normalizeTimestamp2(latestMessage?.createdAt),
+      lastMessageAt: normalizeTimestampMs(latestMessage?.createdAt),
       workspaceRoot: endpoint?.projectRoot ?? endpoint?.cwd ?? null
     }];
   });
@@ -59958,7 +61329,7 @@ function buildMobileSessionSummaries(snapshot) {
   return [...deduped.values()].sort((left, right) => (right.lastMessageAt ?? 0) - (left.lastMessageAt ?? 0));
 }
 function messagesForConversation(snapshot, conversationId) {
-  return Object.values(snapshot.messages).filter((message) => message.conversationId === conversationId).sort((left, right) => (normalizeTimestamp2(left.createdAt) ?? 0) - (normalizeTimestamp2(right.createdAt) ?? 0));
+  return Object.values(snapshot.messages).filter((message) => !isBrokerRequesterWaitTimeoutStatusMessage(message)).filter((message) => message.conversationId === conversationId).sort((left, right) => (normalizeTimestamp2(left.createdAt) ?? 0) - (normalizeTimestamp2(right.createdAt) ?? 0));
 }
 function pageMessagesForConversation(snapshot, conversationId, options = {}) {
   const allMessages = messagesForConversation(snapshot, conversationId);
@@ -59995,7 +61366,7 @@ function pageMessagesForConversation(snapshot, conversationId, options = {}) {
 function latestActiveFlightForAgent(snapshot, agentId) {
   if (!agentId)
     return null;
-  return Object.values(snapshot.flights).filter((flight) => flight.targetAgentId === agentId && !["completed", "failed", "cancelled"].includes(flight.state)).sort((left, right) => (normalizeTimestamp2(right.startedAt) ?? 0) - (normalizeTimestamp2(left.startedAt) ?? 0))[0] ?? null;
+  return Object.values(snapshot.flights).filter((flight) => flight.targetAgentId === agentId && (flight.state === "running" || flight.state === "waiting") && !isRequesterWaitTimeoutFlight(flight)).sort((left, right) => (normalizeTimestamp2(right.startedAt) ?? 0) - (normalizeTimestamp2(left.startedAt) ?? 0))[0] ?? null;
 }
 async function loadMobileRelayState() {
   const broker = await loadScoutBrokerContext();
@@ -60003,7 +61374,10 @@ async function loadMobileRelayState() {
     return { agents: [], sessions: [] };
   }
   const snapshot = broker.snapshot;
-  const agents = Object.values(snapshot.agents).map((agent) => buildMobileAgentSummary(snapshot, agent)).sort((left, right) => (right.lastActiveAt ?? 0) - (left.lastActiveAt ?? 0) || left.title.localeCompare(right.title));
+  const agents = Object.values(snapshot.agents).filter((agent) => !isInactiveAgent(agent)).filter((agent) => {
+    const endpoints = Object.values(snapshot.endpoints).filter((endpoint) => endpoint.agentId === agent.id);
+    return endpoints.length === 0 || endpoints.some((endpoint) => !isInactiveEndpoint(snapshot, endpoint));
+  }).map((agent) => buildMobileAgentSummary(snapshot, agent)).sort((left, right) => (right.lastActiveAt ?? 0) - (left.lastActiveAt ?? 0) || left.title.localeCompare(right.title));
   return {
     agents,
     sessions: buildMobileSessionSummaries(snapshot)
@@ -60110,10 +61484,10 @@ async function getScoutMobileSessionSnapshot(conversationId, options = {}, curre
   const messages2 = messagePage.messages;
   const activeFlight = latestActiveFlightForAgent(snapshot, directAgentId);
   const lastAgentMessageAt = messages2.filter((message) => message.actorId === directAgentId).reduce((latest, message) => {
-    const createdAt = normalizeTimestamp2(message.createdAt);
+    const createdAt = normalizeTimestampMs(message.createdAt);
     return typeof createdAt === "number" && (!latest || createdAt > latest) ? createdAt : latest;
   }, null);
-  const shouldShowWorkingTurn = Boolean(activeFlight && (normalizeTimestamp2(activeFlight.startedAt) ?? 0) > (lastAgentMessageAt ?? 0));
+  const shouldShowWorkingTurn = Boolean(activeFlight && (normalizeTimestampMs(activeFlight.startedAt) ?? 0) > (lastAgentMessageAt ?? 0));
   const turns = messages2.map((message) => ({
     id: message.id,
     status: "completed",
@@ -60187,7 +61561,7 @@ async function createScoutSession(input, currentDirectory, deviceId) {
     throw new Error(`Invalid workspaceId.`);
   }
   const workspaceRoot = resolve16(rawWorkspaceId);
-  const projectName = basename12(workspaceRoot) || workspaceRoot;
+  const projectName = basename13(workspaceRoot) || workspaceRoot;
   const workspace = {
     id: workspaceRoot,
     title: projectName,
@@ -60264,6 +61638,9 @@ async function createScoutSession(input, currentDirectory, deviceId) {
   };
 }
 async function sendScoutMobileMessage(input, currentDirectory, deviceId) {
+  if (input.agentId === SCOUTBOT_AGENT_ID) {
+    return sendScoutbotMobileThreadMessage(input, currentDirectory, deviceId);
+  }
   return sendScoutDirectMessage({
     agentId: input.agentId,
     body: input.body,
@@ -60276,6 +61653,88 @@ async function sendScoutMobileMessage(input, currentDirectory, deviceId) {
     deviceId
   });
 }
+async function sendScoutbotMobileThreadMessage(input, currentDirectory, deviceId) {
+  const broker = await loadScoutBrokerContext();
+  if (!broker) {
+    throw new Error("Scoutbot is not available.");
+  }
+  const conversationId = broker.snapshot.conversations[SCOUTBOT_LEGACY_CONVERSATION_ID] ? SCOUTBOT_LEGACY_CONVERSATION_ID : SCOUTBOT_DEFAULT_CONVERSATION_ID;
+  const conversation = broker.snapshot.conversations[conversationId] ?? {
+    id: conversationId,
+    kind: "direct",
+    title: conversationId === SCOUTBOT_LEGACY_CONVERSATION_ID ? "Scout" : "Scout \xB7 default",
+    visibility: "private",
+    shareMode: "local",
+    authorityNodeId: broker.node.id,
+    participantIds: ["operator", SCOUTBOT_AGENT_ID].sort(),
+    metadata: {
+      surface: "scoutbot",
+      scoutbotThreadId: SCOUTBOT_DEFAULT_THREAD_ID
+    }
+  };
+  if (!broker.snapshot.conversations[conversationId]) {
+    await postMobileBrokerJson(broker.baseUrl, "/v1/conversations", conversation);
+  }
+  const now = Date.now();
+  const messageId = createMobileBrokerEntityId("msg", now);
+  const transportSessionId = scoutbotTransportSessionId(broker.snapshot);
+  await postMobileBrokerJson(broker.baseUrl, "/v1/messages", {
+    id: messageId,
+    conversationId,
+    actorId: "operator",
+    originNodeId: broker.node.id,
+    class: "agent",
+    body: input.body.trim(),
+    replyToMessageId: input.replyToMessageId ?? undefined,
+    mentions: [{ actorId: SCOUTBOT_AGENT_ID, label: "@scoutbot" }],
+    audience: { notify: [SCOUTBOT_AGENT_ID], reason: "direct_message" },
+    visibility: "private",
+    policy: "durable",
+    createdAt: now,
+    metadata: {
+      source: "scout-mobile",
+      destinationKind: "scoutbot_thread",
+      destinationId: SCOUTBOT_DEFAULT_THREAD_ID,
+      scoutbotThreadId: SCOUTBOT_DEFAULT_THREAD_ID,
+      ...transportSessionId ? { targetSessionId: transportSessionId } : {},
+      referenceMessageIds: input.referenceMessageIds ?? [],
+      clientMessageId: input.clientMessageId ?? null,
+      ...deviceId ? { deviceId } : {},
+      relayMessageId: messageId,
+      returnAddress: {
+        actorId: "operator",
+        conversationId,
+        replyToMessageId: messageId,
+        ...transportSessionId ? { sessionId: transportSessionId } : {}
+      }
+    }
+  });
+  return {
+    conversationId,
+    messageId
+  };
+}
+function scoutbotTransportSessionId(snapshot) {
+  const endpoint = Object.values(snapshot.endpoints ?? {}).find((candidate) => candidate.agentId === SCOUTBOT_AGENT_ID && candidate.transport === "codex_app_server" && !isInactiveEndpoint(snapshot, candidate));
+  if (!endpoint)
+    return null;
+  return metadataString4(endpoint.metadata, "threadId") ?? metadataString4(endpoint.metadata, "externalSessionId") ?? endpoint.sessionId?.trim() ?? null;
+}
+async function postMobileBrokerJson(baseUrl, path2, body) {
+  const response = await fetch(new URL(path2, baseUrl), {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Broker ${path2} failed (${response.status}): ${text || response.statusText}`);
+  }
+  return await response.json();
+}
+function createMobileBrokerEntityId(prefix, createdAtMs) {
+  return `${prefix}-${createdAtMs.toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
 async function deriveNewAgentName(projectName, branch, harness) {
   const parts = [projectName.toLowerCase()];
   if (branch) {
@@ -60342,7 +61801,7 @@ async function getScoutMobileActivity(filters = {}) {
     limit: filters.limit ?? 100
   });
 }
-var DEFAULT_MOBILE_RECENT_TURN_LIMIT = 24, DEFAULT_MOBILE_HISTORY_PAGE_LIMIT = 40;
+var SCOUTBOT_AGENT_ID = "scoutbot", SCOUTBOT_DEFAULT_THREAD_ID = "thr-default", SCOUTBOT_DEFAULT_CONVERSATION_ID = "dm.operator.scoutbot.default", SCOUTBOT_LEGACY_CONVERSATION_ID = "dm.operator.scoutbot", DEFAULT_MOBILE_RECENT_TURN_LIMIT = 24, DEFAULT_MOBILE_HISTORY_PAGE_LIMIT = 40;
 var init_service5 = __esm(() => {
   init_harness_catalog();
   init_setup();
@@ -60354,7 +61813,7 @@ var init_service5 = __esm(() => {
 // ../../apps/desktop/src/core/pairing/runtime/bridge/server.ts
 import { readdirSync as readdirSync4, readFileSync as readFileSync15, realpathSync, statSync as statSync5 } from "fs";
 import { execSync as execSync2 } from "child_process";
-import { basename as basename13, isAbsolute as isAbsolute3, join as join30, relative as relative3 } from "path";
+import { basename as basename14, isAbsolute as isAbsolute3, join as join30, relative as relative3 } from "path";
 import { homedir as homedir24 } from "os";
 function replaySyncEvents(bridge, sessionId, lastSeq) {
   return bridge.replay(sessionId, lastSeq);
@@ -60527,9 +61986,9 @@ async function handleRPCInner(bridge, req, deviceId) {
       }
       case "session/resume": {
         const p = req.params;
-        const sessionFilename = basename13(p.sessionPath, ".jsonl");
+        const sessionFilename = basename14(p.sessionPath, ".jsonl");
         const parentDir = p.sessionPath.substring(0, p.sessionPath.lastIndexOf("/"));
-        const dirName = basename13(parentDir);
+        const dirName = basename14(parentDir);
         let cwd;
         if (dirName.startsWith("-")) {
           const candidate = "/" + dirName.slice(1).replace(/-/g, "/");
@@ -60596,7 +62055,7 @@ async function handleRPCInner(bridge, req, deviceId) {
           return { id: req.id, error: { code: -32000, message: "Workspace target is not a directory" } };
         }
         const adapterType = p.adapter ?? "claude-code";
-        const name = p.name ?? basename13(projectPath);
+        const name = p.name ?? basename14(projectPath);
         const session = await bridge.createSession(adapterType, {
           name,
           cwd: projectPath
@@ -62066,7 +63525,7 @@ function planMessageDeliveries(input) {
   return [...deliveries2.values()];
 }
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/entity.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/entity.js
 function is(value, type) {
   if (!value || typeof value !== "object") {
     return false;
@@ -62094,7 +63553,7 @@ var init_entity = __esm(() => {
   hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
 });
 
-// ../../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
 var Column;
 var init_column = __esm(() => {
   init_entity();
@@ -62148,7 +63607,7 @@ var init_column = __esm(() => {
   };
 });
 
-// ../../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
 var ColumnBuilder;
 var init_column_builder = __esm(() => {
   init_entity();
@@ -62208,19 +63667,19 @@ var init_column_builder = __esm(() => {
   };
 });
 
-// ../../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;
 var init_table_utils = __esm(() => {
   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);
 }
 var init_tracing_utils = () => {};
 
-// ../../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`;
 }
@@ -62228,7 +63687,7 @@ var init_unique_constraint = __esm(() => {
   init_table_utils();
 });
 
-// ../../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
 var PgColumn, ExtraConfigColumn;
 var init_common = __esm(() => {
   init_column();
@@ -62282,7 +63741,7 @@ var init_common = __esm(() => {
   };
 });
 
-// ../../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
 function isPgEnum(obj) {
   return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
 }
@@ -62317,7 +63776,7 @@ var init_enum = __esm(() => {
   };
 });
 
-// ../../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
 var Subquery;
 var init_subquery = __esm(() => {
   init_entity();
@@ -62336,11 +63795,11 @@ var init_subquery = __esm(() => {
   };
 });
 
-// ../../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";
 var init_version = () => {};
 
-// ../../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, rawTracer, tracer;
 var init_tracing = __esm(() => {
   init_tracing_utils();
@@ -62370,13 +63829,13 @@ var init_tracing = __esm(() => {
   };
 });
 
-// ../../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;
 var init_view_common = __esm(() => {
   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, Columns, ExtraConfigColumns, OriginalName, BaseName, IsAlias, ExtraConfigBuilder, IsDrizzleTable, Table;
 var init_table = __esm(() => {
   init_entity();
@@ -62418,7 +63877,7 @@ var init_table = __esm(() => {
   };
 });
 
-// ../../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";
 }
@@ -62782,7 +64241,7 @@ var init_sql = __esm(() => {
   };
 });
 
-// ../../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
 var ColumnAliasProxyHandler, TableAliasProxyHandler;
 var init_alias = __esm(() => {
   init_column();
@@ -62844,13 +64303,13 @@ var init_alias = __esm(() => {
   };
 });
 
-// ../../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
 var init_errors5 = () => {};
 
-// ../../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
 var init_logger = () => {};
 
-// ../../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
 var QueryPromise;
 var init_query_promise = __esm(() => {
   init_entity();
@@ -62875,7 +64334,7 @@ var init_query_promise = __esm(() => {
   };
 });
 
-// ../../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 orderSelectedFields(fields, pathPrefix) {
   return Object.entries(fields).reduce((result, [name, field]) => {
     if (typeof name !== "string") {
@@ -62934,41 +64393,41 @@ var init_utils4 = __esm(() => {
   textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder;
 });
 
-// ../../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
 var init_conditions = () => {};
 
-// ../../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
 var init_select = () => {};
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sql/expressions/index.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sql/expressions/index.js
 var init_expressions = __esm(() => {
   init_conditions();
   init_select();
 });
 
-// ../../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
 var init_relations = () => {};
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sql/functions/aggregate.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sql/functions/aggregate.js
 var init_aggregate = () => {};
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sql/functions/vector.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sql/functions/vector.js
 var init_vector = () => {};
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sql/functions/index.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sql/functions/index.js
 var init_functions = __esm(() => {
   init_aggregate();
   init_vector();
 });
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sql/index.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sql/index.js
 var init_sql2 = __esm(() => {
   init_expressions();
   init_functions();
   init_sql();
 });
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/index.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/index.js
 var init_drizzle_orm = __esm(() => {
   init_alias();
   init_column_builder();
@@ -62985,13 +64444,13 @@ var init_drizzle_orm = __esm(() => {
   init_view_common();
 });
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/alias.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/alias.js
 var init_alias2 = () => {};
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/checks.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/checks.js
 var init_checks4 = () => {};
 
-// ../../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
 var ForeignKeyBuilder, ForeignKey;
 var init_foreign_keys = __esm(() => {
   init_entity();
@@ -63049,7 +64508,7 @@ var init_foreign_keys = __esm(() => {
   };
 });
 
-// ../../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(table2, columns) {
   return `${table2[TableName]}_${columns.join("_")}_unique`;
 }
@@ -63057,7 +64516,7 @@ var init_unique_constraint2 = __esm(() => {
   init_table_utils();
 });
 
-// ../../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
 var SQLiteColumnBuilder, SQLiteColumn;
 var init_common2 = __esm(() => {
   init_column_builder();
@@ -63115,7 +64574,7 @@ var init_common2 = __esm(() => {
   };
 });
 
-// ../../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
 function blob(a, b) {
   const { name, config: config2 } = getColumnNameAndConfig(a, b);
   if (config2?.mode === "json") {
@@ -63204,7 +64663,7 @@ var init_blob = __esm(() => {
   };
 });
 
-// ../../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
 function customType(customTypeParams) {
   return (a, b) => {
     const { name, config: config2 } = getColumnNameAndConfig(a, b);
@@ -63250,7 +64709,7 @@ var init_custom = __esm(() => {
   };
 });
 
-// ../../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
 function integer2(a, b) {
   const { name, config: config2 } = getColumnNameAndConfig(a, b);
   if (config2?.mode === "timestamp" || config2?.mode === "timestamp_ms") {
@@ -63352,7 +64811,7 @@ var init_integer = __esm(() => {
   };
 });
 
-// ../../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
 function numeric(a, b) {
   const { name, config: config2 } = getColumnNameAndConfig(a, b);
   const mode = config2?.mode;
@@ -63423,7 +64882,7 @@ var init_numeric = __esm(() => {
   };
 });
 
-// ../../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
 function real(name) {
   return new SQLiteRealBuilder(name ?? "");
 }
@@ -63448,7 +64907,7 @@ var init_real = __esm(() => {
   };
 });
 
-// ../../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
 function text(a, b = {}) {
   const { name, config: config2 } = getColumnNameAndConfig(a, b);
   if (config2.mode === "json") {
@@ -63506,7 +64965,7 @@ var init_text = __esm(() => {
   };
 });
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/columns/index.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/columns/index.js
 var init_columns = __esm(() => {
   init_blob();
   init_common2();
@@ -63517,7 +64976,7 @@ var init_columns = __esm(() => {
   init_text();
 });
 
-// ../../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
 var SelectionProxyHandler;
 var init_selection_proxy = __esm(() => {
   init_alias();
@@ -63578,7 +65037,7 @@ var init_selection_proxy = __esm(() => {
   };
 });
 
-// ../../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,
@@ -63598,7 +65057,7 @@ var init_all = __esm(() => {
   init_text();
 });
 
-// ../../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
 function sqliteTableBase(name, columns, extraConfig, schema, baseName = name) {
   const rawTable = new SQLiteTable(name, schema, baseName);
   const parsedColumns = typeof columns === "function" ? columns(getSQLiteColumnBuilders()) : columns;
@@ -63636,7 +65095,7 @@ var init_table2 = __esm(() => {
   };
 });
 
-// ../../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
 function index(name) {
   return new IndexBuilderOn(name, false);
 }
@@ -63681,10 +65140,10 @@ var init_indexes = __esm(() => {
   };
 });
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/primary-keys.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/primary-keys.js
 var init_primary_keys = () => {};
 
-// ../../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(table2) {
   if (is(table2, SQLiteTable)) {
     return [`${table2[Table.Symbol.BaseName]}`];
@@ -63705,10 +65164,10 @@ var init_utils5 = __esm(() => {
   init_table2();
 });
 
-// ../../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
 var init_delete = () => {};
 
-// ../../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
 var SQLiteViewBase;
 var init_view_base = __esm(() => {
   init_entity();
@@ -63718,10 +65177,10 @@ var init_view_base = __esm(() => {
   };
 });
 
-// ../../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
 var init_dialect = () => {};
 
-// ../../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
 var TypedQueryBuilder;
 var init_query_builder = __esm(() => {
   init_entity();
@@ -63733,7 +65192,7 @@ var init_query_builder = __esm(() => {
   };
 });
 
-// ../../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
 function createSetOperator(type, isAll) {
   return (leftSelect, rightSelect, ...restSelects) => {
     const setOperators = [rightSelect, ...restSelects].map((select2) => ({
@@ -64002,13 +65461,13 @@ var init_select2 = __esm(() => {
   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
 var init_query_builder2 = () => {};
 
-// ../../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
 var init_insert = () => {};
 
-// ../../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
 var SQLiteUpdateBase;
 var init_update = __esm(() => {
   init_entity();
@@ -64112,7 +65571,7 @@ var init_update = __esm(() => {
   };
 });
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/query-builders/index.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/query-builders/index.js
 var init_query_builders = __esm(() => {
   init_delete();
   init_insert();
@@ -64121,16 +65580,16 @@ var init_query_builders = __esm(() => {
   init_update();
 });
 
-// ../../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
 var init_db = () => {};
 
-// ../../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
 var init_session = () => {};
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/view.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/view.js
 var init_view = () => {};
 
-// ../../node_modules/.bun/drizzle-orm@0.45.2+29ab9a45addfc34e/node_modules/drizzle-orm/sqlite-core/index.js
+// ../../node_modules/.bun/drizzle-orm@0.45.2+e80f9ee8788b3855/node_modules/drizzle-orm/sqlite-core/index.js
 var init_sqlite_core = __esm(() => {
   init_alias2();
   init_checks4();
@@ -64149,10 +65608,11 @@ var init_sqlite_core = __esm(() => {
 });
 
 // ../runtime/src/drizzle-schema.ts
-var deliveriesTable, deliveryAttemptsTable, briefingsTable;
+var epochMsNow, deliveriesTable, deliveryAttemptsTable, briefingsTable;
 var init_drizzle_schema = __esm(() => {
   init_drizzle_orm();
   init_sqlite_core();
+  epochMsNow = sql`(CAST(strftime('%s','now') AS INTEGER) * 1000)`;
   deliveriesTable = sqliteTable("deliveries", {
     id: text("id").primaryKey(),
     messageId: text("message_id"),
@@ -64168,7 +65628,7 @@ var init_drizzle_schema = __esm(() => {
     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)
   }, (table3) => [
     index("idx_deliveries_status_transport").on(table3.status, table3.transport)
   ]);
@@ -64195,7 +65655,7 @@ var init_drizzle_schema = __esm(() => {
     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)
   }, (table3) => [
     index("idx_briefings_created_at").on(table3.createdAt),
     index("idx_briefings_kind_created_at").on(table3.kind, table3.createdAt)
@@ -64936,6 +66396,17 @@ var init_mesh_forwarding = __esm(() => {
   init_src();
   init_iroh_bridge();
 });
+
+// ../runtime/src/invocation-lifecycle-read-model.ts
+var init_invocation_lifecycle_read_model = __esm(() => {
+  init_src();
+});
+
+// ../runtime/src/broker-core-service.ts
+var init_broker_core_service = __esm(() => {
+  init_invocation_lifecycle_read_model();
+});
+
 // ../runtime/src/scout-broker.ts
 var init_scout_broker = __esm(() => {
   init_src();
@@ -66310,10 +67781,34 @@ function buildScoutVantagePlan(input) {
     manifest: {
       kind: HUDSON_VANTAGE_SETUP_KIND,
       schemaVersion: HUDSON_VANTAGE_SCHEMA_VERSION,
+      workspaceID: workspaceIdFor(input.currentDirectory),
       source: "openscout",
       generatedAt,
       currentDirectory: input.currentDirectory,
       broker: buildBrokerSummary(input.broker?.baseUrl ?? null, brokerNode, brokerSnapshot),
+      presentation: {
+        title: "Scout Vantage",
+        subtitle: "local runtime handoff",
+        badge: "runtime",
+        cobrand: "OpenScout",
+        productName: "Scout",
+        hostName: "Hudson Vantage",
+        theme: "jade",
+        accent: "cyan"
+      },
+      style: {
+        preset: "jade",
+        canvasGridMode: "dots",
+        canvasGridStep: 18,
+        focusPadding: 12
+      },
+      viewport: { fit: true },
+      layout: {
+        canvasTool: "select",
+        navigationFilter: "all",
+        minimapCollapsed: false,
+        inspectorCollapsed: false
+      },
       focus: focusAgentId ? { agentId: focusAgentId } : focusNativeSessionId ? { nativeSessionId: focusNativeSessionId } : null,
       selectedAgentIds,
       selectedNativeSessionIds,
@@ -66520,6 +68015,10 @@ function tmuxTargetKey(target) {
 function stableNodeId(kind, value) {
   return `vantage.${kind}.${slugify2(value)}.${fnv1a(value)}`;
 }
+function workspaceIdFor(currentDirectory) {
+  const lastSegment = currentDirectory.split(/[\\/]+/g).filter(Boolean).at(-1) ?? "workspace";
+  return `openscout-${slugify2(lastSegment)}`;
+}
 function slugify2(value) {
   const slug = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
   return slug || "node";
@@ -66571,6 +68070,7 @@ var init_src3 = __esm(() => {
   init_tailscale();
   init_broker_process_manager();
   init_broker_api();
+  init_broker_core_service();
   init_local_agents();
   init_control_plane_agents();
   init_scout_broker();
@@ -69874,7 +71374,7 @@ var init_tail_fanout = __esm(() => {
 // ../../apps/desktop/src/core/pairing/runtime/bridge/router.ts
 import { readFileSync as readFileSync17, readdirSync as readdirSync5, realpathSync as realpathSync2, statSync as statSync6 } from "fs";
 import { execSync as execSync3 } from "child_process";
-import { basename as basename14, isAbsolute as isAbsolute4, join as join32, relative as relative4 } from "path";
+import { basename as basename15, isAbsolute as isAbsolute4, join as join32, relative as relative4 } from "path";
 import { homedir as homedir25 } from "os";
 function resolveMobileCurrentDirectory2() {
   const config2 = resolveConfig();
@@ -70351,9 +71851,9 @@ var init_router = __esm(() => {
       adapterType: exports_external.string().optional(),
       name: exports_external.string().optional()
     })).mutation(async ({ input, ctx }) => {
-      const sessionFilename = basename14(input.sessionPath, ".jsonl");
+      const sessionFilename = basename15(input.sessionPath, ".jsonl");
       const parentDir = input.sessionPath.substring(0, input.sessionPath.lastIndexOf("/"));
-      const dirName = basename14(parentDir);
+      const dirName = basename15(parentDir);
       let cwd;
       if (dirName.startsWith("-")) {
         const candidate = "/" + dirName.slice(1).replace(/-/g, "/");
@@ -70653,7 +72153,7 @@ var init_router = __esm(() => {
         });
       }
       const adapterType = input.adapter ?? "claude-code";
-      const name = input.name ?? basename14(projectPath);
+      const name = input.name ?? basename15(projectPath);
       return ctx.bridge.createSession(adapterType, {
         name,
         cwd: projectPath
@@ -75005,6 +76505,7 @@ function renderServerCommandHelp() {
     "",
     "Usage:",
     "  scout server start [options]",
+    "  scout server restart [options]",
     "  scout server open [options]",
     "  scout server caddyfile [options]",
     "  scout server edge [options]",
@@ -75013,6 +76514,7 @@ function renderServerCommandHelp() {
     "",
     "Subcommands:",
     "  start              Start the Scout web UI server.",
+    "  restart            Restart the Scout web UI server via the broker supervisor.",
     "  open               Open the Scout web UI (starts server on demand if needed).",
     "  caddyfile          Print the local edge Caddyfile for scout.local.",
     "  edge               Publish local names and run the Caddy edge.",
@@ -75264,6 +76766,14 @@ function parseServerSelection(args) {
       mode: "openscout-web"
     };
   }
+  if (args[0] === "restart") {
+    return {
+      action: "restart",
+      flagArgs: args.slice(1),
+      entry: resolveScoutControlPlaneWebServerEntry(),
+      mode: "openscout-web"
+    };
+  }
   if (args[0] === "open") {
     return {
       action: "open",
@@ -75673,6 +77183,11 @@ async function runServerCommand(context, args) {
     context.output.writeText(renderLocalEdgeTrustResult(ensureScoutLocalEdgeTrust({ env: mergedEnv })));
     return;
   }
+  if (selection.action === "restart") {
+    const result = await restartScoutWebServer();
+    context.output.writeValue(result, renderServerRestartResult);
+    return;
+  }
   const bunExecutable = resolveBunExecutable4(mergedEnv);
   await new Promise((resolvePromise, rejectPromise) => {
     const child = spawn5(bunExecutable, ["run", selection.entry], {
@@ -75703,6 +77218,69 @@ async function runServerCommand(context, args) {
     });
   });
 }
+async function fetchSupervisorStatus() {
+  const brokerUrl = resolveScoutBrokerUrl();
+  const response = await fetch(new URL("/v1/web/status", brokerUrl));
+  if (!response.ok) {
+    throw new ScoutCliError(`broker supervisor returned HTTP ${response.status}`);
+  }
+  return await response.json();
+}
+async function waitForSupervisor(predicate, timeoutMs, intervalMs = 150) {
+  const deadline = Date.now() + timeoutMs;
+  let last = null;
+  while (Date.now() < deadline) {
+    last = await fetchSupervisorStatus().catch(() => last);
+    if (last && predicate(last))
+      return last;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  if (!last) {
+    throw new ScoutCliError("broker supervisor did not respond within the timeout");
+  }
+  return last;
+}
+async function restartScoutWebServer() {
+  const started = Date.now();
+  const before = await fetchSupervisorStatus().catch(() => null);
+  if (!before || !before.pid) {
+    throw new ScoutCliError("Scout web server is not running under the broker supervisor \u2014 start it with `scout server start`.");
+  }
+  const previousPid = before.pid;
+  try {
+    process.kill(previousPid, "SIGTERM");
+  } catch (error48) {
+    const code = error48.code;
+    if (code === "EPERM") {
+      throw new ScoutCliError(`not permitted to signal pid ${previousPid}`);
+    }
+    if (code === "ESRCH") {} else {
+      throw error48;
+    }
+  }
+  const drained = await waitForSupervisor((status) => status.pid === null || status.pid !== previousPid, 12000);
+  const drainMs = Date.now() - started;
+  const respawned = drained.pid && drained.pid !== previousPid ? drained : await waitForSupervisor((status) => status.running && status.pid !== null && status.pid !== previousPid, 15000);
+  return {
+    webUrl: respawned.webUrl,
+    port: respawned.port,
+    previousPid,
+    newPid: respawned.pid,
+    drainMs,
+    totalMs: Date.now() - started
+  };
+}
+function renderServerRestartResult(value) {
+  return [
+    `Restarted Scout web server`,
+    `  Previous PID: ${value.previousPid}`,
+    `  New PID:      ${value.newPid ?? "(unknown)"}`,
+    `  URL:          ${value.webUrl ?? "(unknown)"}`,
+    `  Drain:        ${value.drainMs}ms`,
+    `  Total:        ${value.totalMs}ms`
+  ].join(`
+`);
+}
 var SERVER_OPEN_TIMEOUT_MS = 15000, SERVER_HEALTH_TIMEOUT_MS = 1500;
 var init_server4 = __esm(() => {
   init_local_config();
@@ -75710,6 +77288,7 @@ var init_server4 = __esm(() => {
   init_tool_resolution();
   init_setup();
   init_local_edge_dependencies();
+  init_service();
   init_errors();
 });
 
@@ -75832,7 +77411,7 @@ import { resolve as resolve18, dirname as dirname17 } from "path";
 import { fileURLToPath as fileURLToPath11 } from "url";
 import { resolve as resolve22, isAbsolute as isAbsolute5, parse as parse7 } from "path";
 import { existsSync as existsSync25 } from "fs";
-import { basename as basename15, join as join35 } from "path";
+import { basename as basename16, join as join35 } from "path";
 import os from "os";
 import path2 from "path";
 import { EventEmitter as EventEmitter3 } from "events";
@@ -79123,7 +80702,7 @@ function getBunfsRootPath() {
   return process.platform === "win32" ? "B:\\~BUN\\root" : "/$bunfs/root";
 }
 function normalizeBunfsPath(fileName) {
-  return join35(getBunfsRootPath(), basename15(fileName));
+  return join35(getBunfsRootPath(), basename16(fileName));
 }
 function addDefaultParsers(parsers) {
   for (const parser of parsers) {
@@ -136307,14 +137886,18 @@ function displayName(actorId) {
   return segments[0] || trimmed;
 }
 function formatClock(value) {
-  const date6 = new Date(value * 1000);
+  const timestamp = normalizeUnixTimestamp2(value);
+  if (timestamp === null)
+    return "--:--:--";
+  const date6 = new Date(timestamp * 1000);
   return [date6.getHours(), date6.getMinutes(), date6.getSeconds()].map((entry) => String(entry).padStart(2, "0")).join(":");
 }
 function formatRelative(value) {
-  if (!value || !Number.isFinite(value)) {
+  const timestamp = normalizeUnixTimestamp2(value);
+  if (timestamp === null) {
     return "not seen";
   }
-  const age = Math.max(0, Math.floor(Date.now() / 1000) - value);
+  const age = Math.max(0, Math.floor(Date.now() / 1000) - timestamp);
   if (age < 60)
     return `${age}s ago`;
   if (age < 3600)
@@ -136324,7 +137907,10 @@ function formatRelative(value) {
   return `${Math.floor(age / 86400)}d ago`;
 }
 function formatUptime2(value) {
-  const age = Math.max(0, Math.floor(Date.now() / 1000) - value);
+  const timestamp = normalizeUnixTimestamp2(value);
+  if (timestamp === null)
+    return "unknown";
+  const age = Math.max(0, Math.floor(Date.now() / 1000) - timestamp);
   if (age < 60)
     return `${age}s`;
   if (age < 3600)
@@ -136495,15 +138081,15 @@ function ChatPanel({
 }) {
   const bodyWidth = Math.max(24, width - 20);
   const ordered = snapshot.recentMessages.slice().sort((left, right) => {
-    const leftTs = left.createdAt;
-    const rightTs = right.createdAt;
+    const leftTs = normalizeUnixTimestamp2(left.createdAt) ?? 0;
+    const rightTs = normalizeUnixTimestamp2(right.createdAt) ?? 0;
     if (leftTs !== rightTs)
       return leftTs - rightTs;
     return String(left.id).localeCompare(String(right.id));
   });
   const rendered = ordered.flatMap((message) => {
     const actor = truncate(displayName(message.actorId), 12).padEnd(12, " ");
-    const stamp = formatClock(Math.floor(message.createdAt / 1000));
+    const stamp = formatClock(message.createdAt);
     const lines = wrapText(message.body, bodyWidth);
     const color = messageTone(message);
     return lines.map((line, index2) => ({
@@ -137890,7 +139476,7 @@ var SCOUT_COMMANDS = [
   { name: "restart", summary: "Restart configured local agents" },
   { name: "menu", summary: "Launch the OpenScout macOS menu bar app" },
   { name: "vantage", summary: "Build a Hudson Vantage terminal canvas plan" },
-  { name: "config", summary: "View or set user config (name, etc.)" },
+  { name: "config", summary: "View or set user config (name, handle, etc.)" },
   { name: "mesh", summary: "Mesh status and diagnostics" },
   { name: "pair", summary: "Pair a companion device via QR" },
   { name: "server", summary: "Run the Scout web UI (Bun; see: scout server start/open)" },
@@ -137930,6 +139516,7 @@ function renderScoutHelp(version3 = "0.2.19") {
     "Fast path:",
     '  scout send --to hudson "ready for review"      # tell / update in a DM',
     '  scout ask --to hudson "review the parser"      # owned work; wait for ack',
+    '  scout ask --project ../talkie "compare auth"   # no agent id needed; route by project path',
     "  scout ask --to hudson --prompt-file ./handoff.md",
     "  scout wait inv_123 --timeout 600               # follow an existing ask",
     "  scout label watch release:0.2.66 --interval 2  # label-scoped activity firehose",
@@ -137972,6 +139559,12 @@ function renderScoutHelp(version3 = "0.2.19") {
     '  scout ask --as premotion.master.mini --to hudson "build the editor"',
     "  scout ask --to hudson --prompt-file ./handoff.md",
     "",
+    "Project targets:",
+    '  scout ask --project ../talkie "compare auth"   # broker resolves the concrete agent/session',
+    '  scout ask --project ../talkie --harness codex "review this from Codex"',
+    "  scout ask '>> project:../talkie compare auth'  # composer route form; quote >> in shells",
+    "  use --project when you know the repo path but not the current Scout handle",
+    "",
     "Routing:",
     '  scout send --to hudson "ready for review"      # one target -> DM',
     '  scout send --channel triage "need two reviewers"  # explicit group thread',