@openscout/scout 0.2.46 → 0.2.47

package/dist/main.mjs

@@ -382,6 +382,53 @@ function parseWatchCommandOptions(args, defaultCurrentDirectory) {
     channel
   };
 }
+function parseLatestCommandOptions(args, defaultCurrentDirectory) {
+  const parsed = parseContextRootPrefix(args, defaultCurrentDirectory);
+  let agentId;
+  let actorId;
+  let conversationId;
+  let limit = 12;
+  for (let index = 0;index < parsed.args.length; index += 1) {
+    const current = parsed.args[index] ?? "";
+    if (current === "--agent" || current.startsWith("--agent=")) {
+      const value = parseFlagValue(parsed.args, index, "--agent");
+      agentId = value.value;
+      index = value.nextIndex;
+      continue;
+    }
+    if (current === "--actor" || current.startsWith("--actor=")) {
+      const value = parseFlagValue(parsed.args, index, "--actor");
+      actorId = value.value;
+      index = value.nextIndex;
+      continue;
+    }
+    if (current === "--conversation" || current.startsWith("--conversation=")) {
+      const value = parseFlagValue(parsed.args, index, "--conversation");
+      conversationId = value.value;
+      index = value.nextIndex;
+      continue;
+    }
+    if (current === "--limit" || current.startsWith("--limit=")) {
+      const value = parseFlagValue(parsed.args, index, "--limit");
+      const parsedLimit = Number.parseInt(value.value, 10);
+      if (!Number.isFinite(parsedLimit) || parsedLimit <= 0) {
+        throw new ScoutCliError(`invalid limit: ${value.value}`);
+      }
+      limit = parsedLimit;
+      index = value.nextIndex;
+      continue;
+    }
+    unexpectedArgs("latest", args);
+  }
+  return {
+    currentDirectory: parsed.currentDirectory,
+    args: parsed.args,
+    agentId,
+    actorId,
+    conversationId,
+    limit
+  };
+}
 function parseEnrollCommandOptions(args, defaultCurrentDirectory) {
   const parsed = parseContextRootPrefix(args, defaultCurrentDirectory);
   let agentName = null;
@@ -10597,6 +10644,63 @@ function renderScoutBroadcastResult(result) {
   return lines.join(`
 `);
 }
+function renderScoutActivityKind(kind) {
+  switch (kind) {
+    case "ask_opened":
+      return "asked";
+    case "ask_working":
+      return "working";
+    case "ask_replied":
+      return "replied";
+    case "ask_failed":
+      return "failed";
+    case "handoff_sent":
+      return "handoff";
+    case "agent_message":
+      return "agent";
+    case "status_message":
+      return "status";
+    case "invocation_recorded":
+      return "invoke";
+    case "flight_updated":
+      return "flight";
+    case "collaboration_event":
+      return "collab";
+    case "message_posted":
+    default:
+      return "message";
+  }
+}
+function renderScoutActivityParticipants(item) {
+  const actor = item.actorId?.trim();
+  const counterpart = item.counterpartId?.trim();
+  if (actor && counterpart && actor !== counterpart) {
+    return `${actor} -> ${counterpart}`;
+  }
+  return actor || counterpart || item.agentId?.trim() || null;
+}
+function renderScoutActivityItem(item) {
+  const timestamp = normalizeUnixTimestamp2(item.ts) ?? Math.floor(Date.now() / 1000);
+  const label = renderScoutActivityKind(item.kind).padEnd(7, " ");
+  const participants = renderScoutActivityParticipants(item);
+  const title = item.title?.trim() || item.summary?.trim() || item.kind;
+  const summary = item.summary?.trim();
+  const detail = summary && summary !== title ? summary : null;
+  return [
+    formatScoutTimestamp(timestamp),
+    label,
+    participants,
+    title,
+    detail ? `(${detail})` : null
+  ].filter(Boolean).join("  ");
+}
+function renderScoutActivityList(items) {
+  if (items.length === 0) {
+    return "No Scout activity yet.";
+  }
+  return items.map(renderScoutActivityItem).join(`
+`);
+}
 var init_broker = () => {};
 
 // ../../apps/desktop/src/cli/commands/broadcast.ts
@@ -11781,6 +11885,28 @@ var init_env = __esm(async () => {
   await init_service();
 });
 
+// ../../apps/desktop/src/cli/commands/latest.ts
+var exports_latest = {};
+__export(exports_latest, {
+  runLatestCommand: () => runLatestCommand
+});
+async function runLatestCommand(context, args) {
+  const options = parseLatestCommandOptions(args, defaultScoutContextDirectory(context));
+  const items = await loadScoutActivityItems({
+    agentId: options.agentId,
+    actorId: options.actorId,
+    conversationId: options.conversationId,
+    limit: options.limit
+  });
+  context.output.writeValue(items, renderScoutActivityList);
+}
+var init_latest = __esm(async () => {
+  init_context();
+  init_options();
+  init_broker();
+  await init_service();
+});
+
 // ../runtime/src/tailscale.ts
 import { readFile as readFile8 } from "fs/promises";
 import { execFile } from "child_process";
@@ -41167,11 +41293,12 @@ __export(exports_server, {
   runServerCommand: () => runServerCommand,
   resolveScoutWebServerEntry: () => resolveScoutWebServerEntry,
   resolveScoutControlPlaneWebServerEntry: () => resolveScoutControlPlaneWebServerEntry,
-  renderServerCommandHelp: () => renderServerCommandHelp
+  renderServerCommandHelp: () => renderServerCommandHelp,
+  normalizeServerOpenPath: () => normalizeServerOpenPath
 });
 import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync16 } from "fs";
-import { dirname as dirname10, join as join24 } from "path";
+import { dirname as dirname10, join as join24, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 function renderServerCommandHelp() {
   return [
@@ -41179,11 +41306,15 @@ function renderServerCommandHelp() {
     "",
     "Usage:",
     "  scout server start [options]",
+    "  scout server open [options]",
     "  scout server control-plane start [options]",
+    "  scout server control-plane open [options]",
     "",
     "Subcommands:",
     "  start              Full desktop web API + UI assets (default stack).",
+    "  open               Open the full web UI and start it on demand if needed.",
     "  control-plane start Pairing + relay/shell activity only (`@openscout/web` surface).",
+    "  control-plane open  Open the control-plane UI and start it on demand if needed.",
     "",
     "Options:",
     "  --port <n>        Listen port (default 3200; env SCOUT_WEB_PORT)",
@@ -41191,6 +41322,7 @@ function renderServerCommandHelp() {
     "  --static-root DIR Static client root (env SCOUT_STATIC_ROOT)",
     "  --vite-url URL    Dev proxy target for non-API routes (env SCOUT_VITE_URL)",
     "  --cwd DIR         Workspace / setup root (env OPENSCOUT_SETUP_CWD)",
+    "  --path PATH       Browser path for `open` (default /)",
     "",
     "Requires `bun` on PATH.",
     "Published installs include dist/client for the full web UI and dist/control-plane-client",
@@ -41223,8 +41355,9 @@ function resolveScoutControlPlaneWebServerEntry() {
   }
   throw new ScoutCliError("Could not find Scout control-plane web server entry. Rebuild @openscout/scout or run from the OpenScout repository.");
 }
-function parseServerStartFlags(args) {
+function parseServerFlags(args) {
   const env = {};
+  let openPath = "/";
   for (let i = 0;i < args.length; i++) {
     const a = args[i];
     if (a === "--port") {
@@ -41259,9 +41392,36 @@ function parseServerStartFlags(args) {
       env.OPENSCOUT_SETUP_CWD = v;
       continue;
     }
+    if (a === "--path") {
+      const v = args[++i];
+      if (!v)
+        throw new ScoutCliError("--path requires a value");
+      openPath = v;
+      continue;
+    }
+    if (a.startsWith("--port=")) {
+      env.SCOUT_WEB_PORT = a.slice("--port=".length);
+      continue;
+    }
+    if (a.startsWith("--static-root=")) {
+      env.SCOUT_STATIC_ROOT = a.slice("--static-root=".length);
+      continue;
+    }
+    if (a.startsWith("--vite-url=")) {
+      env.SCOUT_VITE_URL = a.slice("--vite-url=".length);
+      continue;
+    }
+    if (a.startsWith("--cwd=")) {
+      env.OPENSCOUT_SETUP_CWD = a.slice("--cwd=".length);
+      continue;
+    }
+    if (a.startsWith("--path=")) {
+      openPath = a.slice("--path=".length);
+      continue;
+    }
     throw new ScoutCliError(`unknown option: ${a}`);
   }
-  return { env };
+  return { env, openPath };
 }
 function resolveBundledStaticClientRoot(entry, mode) {
   const entryDir = dirname10(entry);
@@ -41269,29 +41429,7 @@ function resolveBundledStaticClientRoot(entry, mode) {
   const indexPath = join24(clientDirectory, "index.html");
   return existsSync16(indexPath) ? clientDirectory : null;
 }
-async function runServerCommand(context, args) {
-  if (args.length === 0 || args[0] === "help" || args[0] === "--help" || args[0] === "-h") {
-    context.output.writeText(renderServerCommandHelp());
-    return;
-  }
-  let flagArgs;
-  let entry;
-  let mode;
-  if (args[0] === "start") {
-    flagArgs = args.slice(1);
-    entry = resolveScoutWebServerEntry();
-    mode = "full";
-  } else if (args[0] === "control-plane") {
-    if (args[1] !== "start") {
-      throw new ScoutCliError("expected: scout server control-plane start");
-    }
-    flagArgs = args.slice(2);
-    entry = resolveScoutControlPlaneWebServerEntry();
-    mode = "control-plane";
-  } else {
-    throw new ScoutCliError(`unknown subcommand: ${args[0]} (try: scout server start)`);
-  }
-  const { env: flagEnv } = parseServerStartFlags(flagArgs);
+function buildMergedServerEnv(entry, mode, flagEnv) {
   const bundledStaticClientRoot = resolveBundledStaticClientRoot(entry, mode);
   const autoEnv = {};
   if (bundledStaticClientRoot) {
@@ -41301,9 +41439,254 @@ async function runServerCommand(context, args) {
       autoEnv.SCOUT_STATIC_ROOT = bundledStaticClientRoot;
     }
   }
-  const mergedEnv = { ...process.env, ...autoEnv, ...flagEnv };
+  return { ...process.env, ...autoEnv, ...flagEnv };
+}
+function parseServerSelection(args) {
+  if (args[0] === "start") {
+    return {
+      action: "start",
+      flagArgs: args.slice(1),
+      entry: resolveScoutWebServerEntry(),
+      mode: "full"
+    };
+  }
+  if (args[0] === "open") {
+    return {
+      action: "open",
+      flagArgs: args.slice(1),
+      entry: resolveScoutWebServerEntry(),
+      mode: "full"
+    };
+  }
+  if (args[0] === "control-plane") {
+    if (args[1] !== "start" && args[1] !== "open") {
+      throw new ScoutCliError("expected: scout server control-plane <start|open>");
+    }
+    return {
+      action: args[1],
+      flagArgs: args.slice(2),
+      entry: resolveScoutControlPlaneWebServerEntry(),
+      mode: "control-plane"
+    };
+  }
+  throw new ScoutCliError(`unknown subcommand: ${args[0]} (try: scout server open)`);
+}
+function normalizeServerOpenPath(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return "/";
+  }
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+    throw new ScoutCliError("--path must be a local path, not an absolute URL");
+  }
+  if (trimmed.startsWith("/")) {
+    return trimmed;
+  }
+  return `/${trimmed}`;
+}
+function resolveServerPort(env) {
+  const raw2 = env.SCOUT_WEB_PORT?.trim() || "3200";
+  const port = Number.parseInt(raw2, 10);
+  if (!Number.isFinite(port) || port <= 0) {
+    throw new ScoutCliError(`invalid port: ${raw2}`);
+  }
+  return port;
+}
+function resolveExpectedCurrentDirectory(env) {
+  return resolve9(env.OPENSCOUT_SETUP_CWD?.trim() || process.cwd());
+}
+function renderModeLabel(mode) {
+  return mode === "control-plane" ? "Scout control plane" : "Scout";
+}
+function renderSurfaceLabel(surface) {
+  switch (surface) {
+    case "control-plane":
+      return "control-plane";
+    case "openscout-web":
+      return "@openscout/web";
+    case "full":
+    default:
+      return "full";
+  }
+}
+function renderServerOpenResult(result) {
+  const prefix = result.mode === "control-plane" ? "Opened Scout control plane" : "Opened Scout";
+  return `${prefix} at ${result.url}${result.reusedExistingServer ? "" : " (started server)"}`;
+}
+function healthUrlForPort(port) {
+  return new URL(`/api/health`, `http://127.0.0.1:${port}`);
+}
+async function probeScoutServer(port) {
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), SERVER_HEALTH_TIMEOUT_MS);
+  try {
+    const response = await fetch(healthUrlForPort(port), {
+      headers: { accept: "application/json" },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      return {
+        status: "non-scout",
+        statusCode: response.status
+      };
+    }
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      return {
+        status: "non-scout",
+        statusCode: response.status
+      };
+    }
+    if (body.ok === true && (body.surface === "full" || body.surface === "control-plane" || body.surface === "openscout-web") && typeof body.currentDirectory === "string") {
+      return {
+        status: "healthy",
+        health: {
+          ok: true,
+          surface: body.surface,
+          currentDirectory: body.currentDirectory
+        }
+      };
+    }
+    return {
+      status: "non-scout",
+      statusCode: response.status
+    };
+  } catch {
+    return { status: "unreachable" };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function openBrowser(url2) {
+  await new Promise((resolvePromise, rejectPromise) => {
+    let command;
+    let args;
+    if (process.platform === "darwin") {
+      command = "open";
+      args = [url2];
+    } else if (process.platform === "win32") {
+      command = "cmd";
+      args = ["/c", "start", "", url2];
+    } else {
+      command = "xdg-open";
+      args = [url2];
+    }
+    const child = spawn5(command, args, {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true
+    });
+    child.once("error", (error48) => {
+      if (error48.code === "ENOENT") {
+        rejectPromise(new ScoutCliError(`could not open a browser automatically; ${command} is not available`));
+        return;
+      }
+      rejectPromise(error48);
+    });
+    child.once("spawn", () => {
+      child.unref();
+      resolvePromise();
+    });
+  });
+}
+async function spawnDetachedServer(entry, env) {
   await new Promise((resolvePromise, rejectPromise) => {
     const child = spawn5("bun", ["run", entry], {
+      detached: true,
+      stdio: "ignore",
+      env,
+      windowsHide: true
+    });
+    child.once("error", (error48) => {
+      if (error48.code === "ENOENT") {
+        rejectPromise(new ScoutCliError("`bun` was not found on PATH. Install Bun (https://bun.sh) to run scout server."));
+        return;
+      }
+      rejectPromise(error48);
+    });
+    child.once("spawn", () => {
+      child.unref();
+      resolvePromise();
+    });
+  });
+}
+async function waitForScoutServer(port, mode, expectedCurrentDirectory) {
+  const deadline = Date.now() + SERVER_OPEN_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    const probe = await probeScoutServer(port);
+    if (probe.status === "healthy") {
+      const actualCurrentDirectory = resolve9(probe.health.currentDirectory);
+      if (probe.health.surface !== mode) {
+        throw new ScoutCliError(`port ${port} is serving Scout ${renderSurfaceLabel(probe.health.surface)}, not ${renderModeLabel(mode)}.`);
+      }
+      if (actualCurrentDirectory !== expectedCurrentDirectory) {
+        throw new ScoutCliError(`port ${port} is already serving Scout for ${actualCurrentDirectory}, not ${expectedCurrentDirectory}.`);
+      }
+      return;
+    }
+    if (probe.status === "non-scout") {
+      throw new ScoutCliError(`port ${port} is already serving another HTTP app or an older Scout server; choose a different --port.`);
+    }
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, 250));
+  }
+  throw new ScoutCliError(`timed out waiting for ${renderModeLabel(mode)} on port ${port}`);
+}
+async function openScoutServer(options) {
+  const port = resolveServerPort(options.env);
+  const expectedCurrentDirectory = resolveExpectedCurrentDirectory(options.env);
+  const browserUrl = new URL(normalizeServerOpenPath(options.openPath), `http://127.0.0.1:${port}`).toString();
+  const probe = await probeScoutServer(port);
+  if (probe.status === "healthy") {
+    const actualCurrentDirectory = resolve9(probe.health.currentDirectory);
+    if (probe.health.surface !== options.mode) {
+      throw new ScoutCliError(`port ${port} is already serving Scout ${renderSurfaceLabel(probe.health.surface)}, not ${renderModeLabel(options.mode)}.`);
+    }
+    if (actualCurrentDirectory !== expectedCurrentDirectory) {
+      throw new ScoutCliError(`port ${port} is already serving Scout for ${actualCurrentDirectory}, not ${expectedCurrentDirectory}.`);
+    }
+    await openBrowser(browserUrl);
+    return {
+      url: browserUrl,
+      port,
+      mode: options.mode,
+      reusedExistingServer: true
+    };
+  }
+  if (probe.status === "non-scout") {
+    throw new ScoutCliError(`port ${port} is already serving another HTTP app or an older Scout server; choose a different --port.`);
+  }
+  await spawnDetachedServer(options.entry, options.env);
+  await waitForScoutServer(port, options.mode, expectedCurrentDirectory);
+  await openBrowser(browserUrl);
+  return {
+    url: browserUrl,
+    port,
+    mode: options.mode,
+    reusedExistingServer: false
+  };
+}
+async function runServerCommand(context, args) {
+  if (args.length === 0 || args[0] === "help" || args[0] === "--help" || args[0] === "-h") {
+    context.output.writeText(renderServerCommandHelp());
+    return;
+  }
+  const selection = parseServerSelection(args);
+  const { env: flagEnv, openPath } = parseServerFlags(selection.flagArgs);
+  const mergedEnv = buildMergedServerEnv(selection.entry, selection.mode, flagEnv);
+  if (selection.action === "open") {
+    const result = await openScoutServer({
+      entry: selection.entry,
+      mode: selection.mode,
+      env: mergedEnv,
+      openPath
+    });
+    context.output.writeValue(result, renderServerOpenResult);
+    return;
+  }
+  await new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn5("bun", ["run", selection.entry], {
       stdio: "inherit",
       env: mergedEnv
     });
@@ -41331,6 +41714,7 @@ async function runServerCommand(context, args) {
     });
   });
 }
+var SERVER_OPEN_TIMEOUT_MS = 15000, SERVER_HEALTH_TIMEOUT_MS = 1500;
 var init_server2 = __esm(() => {
   init_errors();
 });
@@ -41444,7 +41828,7 @@ import { EventEmitter } from "events";
 import { Buffer as Buffer2 } from "buffer";
 import { Buffer as Buffer3 } from "buffer";
 import { EventEmitter as EventEmitter2 } from "events";
-import { resolve as resolve9, dirname as dirname11 } from "path";
+import { resolve as resolve10, dirname as dirname11 } from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 import { resolve as resolve22, isAbsolute as isAbsolute5, parse as parse6 } from "path";
 import { existsSync as existsSync17 } from "fs";
@@ -44580,13 +44964,13 @@ class DebounceController {
   }
   debounce(id, ms, fn) {
     const scopeMap = TIMERS_MAP.get(this.scopeId);
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       if (scopeMap.has(id)) {
         clearTimeout(scopeMap.get(id));
       }
       const timerId = setTimeout(() => {
         try {
-          resolve11(fn());
+          resolve12(fn());
         } catch (error48) {
           reject(error48);
         }
@@ -44676,25 +45060,25 @@ function getParsers() {
         filetype: "javascript",
         aliases: ["javascriptreact"],
         queries: {
-          highlights: [resolve9(dirname11(fileURLToPath8(import.meta.url)), highlights_default)]
+          highlights: [resolve10(dirname11(fileURLToPath8(import.meta.url)), highlights_default)]
         },
-        wasm: resolve9(dirname11(fileURLToPath8(import.meta.url)), tree_sitter_javascript_default)
+        wasm: resolve10(dirname11(fileURLToPath8(import.meta.url)), tree_sitter_javascript_default)
       },
       {
         filetype: "typescript",
         aliases: ["typescriptreact"],
         queries: {
-          highlights: [resolve9(dirname11(fileURLToPath8(import.meta.url)), highlights_default2)]
+          highlights: [resolve10(dirname11(fileURLToPath8(import.meta.url)), highlights_default2)]
         },
-        wasm: resolve9(dirname11(fileURLToPath8(import.meta.url)), tree_sitter_typescript_default)
+        wasm: resolve10(dirname11(fileURLToPath8(import.meta.url)), tree_sitter_typescript_default)
       },
       {
         filetype: "markdown",
         queries: {
-          highlights: [resolve9(dirname11(fileURLToPath8(import.meta.url)), highlights_default3)],
-          injections: [resolve9(dirname11(fileURLToPath8(import.meta.url)), injections_default)]
+          highlights: [resolve10(dirname11(fileURLToPath8(import.meta.url)), highlights_default3)],
+          injections: [resolve10(dirname11(fileURLToPath8(import.meta.url)), injections_default)]
         },
-        wasm: resolve9(dirname11(fileURLToPath8(import.meta.url)), tree_sitter_markdown_default),
+        wasm: resolve10(dirname11(fileURLToPath8(import.meta.url)), tree_sitter_markdown_default),
         injectionMapping: {
           nodeTypes: {
             inline: "markdown_inline",
@@ -44717,16 +45101,16 @@ function getParsers() {
       {
         filetype: "markdown_inline",
         queries: {
-          highlights: [resolve9(dirname11(fileURLToPath8(import.meta.url)), highlights_default4)]
+          highlights: [resolve10(dirname11(fileURLToPath8(import.meta.url)), highlights_default4)]
         },
-        wasm: resolve9(dirname11(fileURLToPath8(import.meta.url)), tree_sitter_markdown_inline_default)
+        wasm: resolve10(dirname11(fileURLToPath8(import.meta.url)), tree_sitter_markdown_inline_default)
       },
       {
         filetype: "zig",
         queries: {
-          highlights: [resolve9(dirname11(fileURLToPath8(import.meta.url)), highlights_default5)]
+          highlights: [resolve10(dirname11(fileURLToPath8(import.meta.url)), highlights_default5)]
         },
-        wasm: resolve9(dirname11(fileURLToPath8(import.meta.url)), tree_sitter_zig_default)
+        wasm: resolve10(dirname11(fileURLToPath8(import.meta.url)), tree_sitter_zig_default)
       }
     ];
   }
@@ -73962,14 +74346,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
       actScopeDepth = prevActScopeDepth;
     }
-    function recursivelyFlushAsyncActWork(returnValue, resolve11, reject) {
+    function recursivelyFlushAsyncActWork(returnValue, resolve12, reject) {
       var queue = ReactSharedInternals.actQueue;
       if (queue !== null)
         if (queue.length !== 0)
           try {
             flushActQueue(queue);
             enqueueTask(function() {
-              return recursivelyFlushAsyncActWork(returnValue, resolve11, reject);
+              return recursivelyFlushAsyncActWork(returnValue, resolve12, reject);
             });
             return;
           } catch (error48) {
@@ -73977,7 +74361,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           }
         else
           ReactSharedInternals.actQueue = null;
-      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve11(returnValue);
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve12(returnValue);
     }
     function flushActQueue(queue) {
       if (!isFlushing) {
@@ -74153,14 +74537,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
         });
         return {
-          then: function(resolve11, reject) {
+          then: function(resolve12, reject) {
             didAwaitActCall = true;
             thenable.then(function(returnValue) {
               popActScope(prevActQueue, prevActScopeDepth);
               if (prevActScopeDepth === 0) {
                 try {
                   flushActQueue(queue), enqueueTask(function() {
-                    return recursivelyFlushAsyncActWork(returnValue, resolve11, reject);
+                    return recursivelyFlushAsyncActWork(returnValue, resolve12, reject);
                   });
                 } catch (error$0) {
                   ReactSharedInternals.thrownErrors.push(error$0);
@@ -74171,7 +74555,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
                   reject(_thrownError);
                 }
               } else
-                resolve11(returnValue);
+                resolve12(returnValue);
             }, function(error48) {
               popActScope(prevActQueue, prevActScopeDepth);
               0 < ReactSharedInternals.thrownErrors.length ? (error48 = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error48)) : reject(error48);
@@ -74187,11 +74571,11 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       if (0 < ReactSharedInternals.thrownErrors.length)
         throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
       return {
-        then: function(resolve11, reject) {
+        then: function(resolve12, reject) {
           didAwaitActCall = true;
           prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
-            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve11, reject);
-          })) : resolve11(returnValue$jscomp$0);
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve12, reject);
+          })) : resolve12(returnValue$jscomp$0);
         }
       };
     };
@@ -76672,8 +77056,8 @@ It can also happen if the client has a browser extension installed which messes
         currentEntangledActionThenable = {
           status: "pending",
           value: undefined,
-          then: function(resolve11) {
-            entangledListeners.push(resolve11);
+          then: function(resolve12) {
+            entangledListeners.push(resolve12);
           }
         };
       }
@@ -76697,8 +77081,8 @@ It can also happen if the client has a browser extension installed which messes
         status: "pending",
         value: null,
         reason: null,
-        then: function(resolve11) {
-          listeners.push(resolve11);
+        then: function(resolve12) {
+          listeners.push(resolve12);
         }
       };
       thenable.then(function() {
@@ -102680,14 +103064,14 @@ async function runScoutMonitorApp(options) {
   }
   const renderer = await createCliRenderer();
   let closed = false;
-  await new Promise((resolve11) => {
+  await new Promise((resolve12) => {
     const close = () => {
       if (closed) {
         return;
       }
       closed = true;
       renderer.destroy();
-      resolve11();
+      resolve12();
     };
     createRoot(renderer).render(/* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV(ScoutMonitorApp, {
       currentDirectory: options.currentDirectory,
@@ -102736,7 +103120,7 @@ __export(exports_up, {
   runUpCommand: () => runUpCommand
 });
 import { existsSync as existsSync18 } from "fs";
-import { resolve as resolve11 } from "path";
+import { resolve as resolve12 } from "path";
 function looksLikePath(value) {
   return value.includes("/") || value.startsWith(".") || value.startsWith("~");
 }
@@ -102784,8 +103168,8 @@ async function runUpCommand(context, args) {
     throw new ScoutCliError("usage: scout up <name|path> [--name <alias>] [--harness <claude|codex>]");
   }
   let projectPath;
-  if (looksLikePath(target) || existsSync18(resolve11(target))) {
-    projectPath = resolve11(target);
+  if (looksLikePath(target) || existsSync18(resolve12(target))) {
+    projectPath = resolve12(target);
   } else {
     const resolved = await resolveLocalAgentByName(target);
     if (!resolved) {
@@ -102861,6 +103245,52 @@ var init_who = __esm(async () => {
   await init_service();
 });
 
+// ../../apps/desktop/src/cli/commands/whoami.ts
+var exports_whoami = {};
+__export(exports_whoami, {
+  runWhoAmICommand: () => runWhoAmICommand
+});
+async function loadScoutWhoAmIReport(context, currentDirectory) {
+  const askWatchId = resolveScoutAgentName(null);
+  const sendSpeakId = await resolveScoutSenderId(null, currentDirectory);
+  const projectRoot = await findNearestProjectRoot(currentDirectory);
+  return {
+    askWatchId,
+    sendSpeakId,
+    envAgent: context.env.OPENSCOUT_AGENT?.trim() || null,
+    currentDirectory,
+    projectRoot,
+    brokerUrl: resolveScoutBrokerUrl()
+  };
+}
+function renderScoutWhoAmIReport(report) {
+  const lines = [
+    `Ask/Watch: ${report.askWatchId}`,
+    `Send/Speak: ${report.sendSpeakId}`,
+    `Current Directory: ${report.currentDirectory}`,
+    `Broker: ${report.brokerUrl}`
+  ];
+  if (report.projectRoot) {
+    lines.splice(3, 0, `Project Root: ${report.projectRoot}`);
+  }
+  if (report.envAgent) {
+    lines.splice(2, 0, `OPENSCOUT_AGENT: ${report.envAgent}`);
+  }
+  return lines.join(`
+`);
+}
+async function runWhoAmICommand(context, args) {
+  const options = parseContextRootCommandOptions("whoami", args, defaultScoutContextDirectory(context));
+  const report = await loadScoutWhoAmIReport(context, options.currentDirectory);
+  context.output.writeValue(report, renderScoutWhoAmIReport);
+}
+var init_whoami = __esm(async () => {
+  init_setup();
+  init_context();
+  init_options();
+  await init_service();
+});
+
 // ../../apps/desktop/src/cli/argv.ts
 function parseScoutArgv(argv) {
   let command = null;
@@ -102920,6 +103350,8 @@ async function loadScoutCommandHandler(name) {
       return (await init_enroll().then(() => exports_enroll)).runEnrollCommand;
     case "env":
       return (await init_env().then(() => exports_env)).runEnvCommand;
+    case "latest":
+      return (await init_latest().then(() => exports_latest)).runLatestCommand;
     case "mesh":
       return (await init_mesh().then(() => exports_mesh)).runMeshCommand;
     case "pair":
@@ -102946,6 +103378,8 @@ async function loadScoutCommandHandler(name) {
       return (await init_watch().then(() => exports_watch)).runWatchCommand;
     case "who":
       return (await init_who().then(() => exports_who)).runWhoCommand;
+    case "whoami":
+      return (await init_whoami().then(() => exports_whoami)).runWhoAmICommand;
   }
 }
 
@@ -102957,12 +103391,14 @@ var SCOUT_COMMANDS = [
   { name: "doctor", summary: "Show broker health and project inventory" },
   { name: "runtimes", summary: "Show harness catalog and readiness" },
   { name: "env", summary: "Show executable and agent identity context" },
+  { name: "whoami", summary: "Show your current Scout identity defaults" },
   { name: "send", summary: "Post a broker-backed message" },
   { name: "speak", summary: "Send and speak aloud via TTS" },
   { name: "ask", summary: "Ask an agent and wait for the answer" },
   { name: "card", summary: "Create a dedicated relay agent card" },
   { name: "watch", summary: "Stream broker messages" },
   { name: "who", summary: "List agents and last activity" },
+  { name: "latest", summary: "Show the latest Scout activity" },
   { name: "enroll", summary: "Generate enrollment prompt" },
   { name: "broadcast", summary: "Send to all routable agents" },
   { name: "up", summary: "Spawn a local agent for a project" },
@@ -103021,6 +103457,12 @@ function renderScoutHelp(version2 = "0.2.18") {
     "  scout hey @agent can you review this?",
     "  scout @agent.harness:codex use the Codex-backed one",
     "",
+    "Operator loop:",
+    "  scout whoami",
+    "  scout who",
+    "  scout latest",
+    "  scout server open",
+    "",
     "Addressing:",
     "  @name                              short form; requires exactly one live match",
     "  @name.harness:<codex|claude|...>   pin a specific harness (alias: runtime:)",