@moxxy/cli 0.14.2 → 0.14.4

package/dist/bin.js

@@ -2,7 +2,7 @@
 import { createRequire } from 'node:module';
 import { z as z$1, createMutex, defineTunnelProvider, definePlugin, defineProvider, defineTool, MoxxyError, asTurnId, defineMode, asPluginId, defineCommand, defineChannel, defineWorkflowExecutor, toFriendlyError, estimateTextTokens, classifyHttpStatus, createStuckLoopDetector, runCompactionIfNeeded, runElisionIfNeeded, collectProviderStream, usageEventFields, isContextOverflowError, emitRequestsAndDetectStuck, executeToolUses, buildSystemPromptWithSkills, projectMessages, defineCompactor, defineCacheStrategy, denyByDefaultResolver, createAllowListResolver, zodToJsonSchema, fileDiffSummary, runSingleShotTurn, defineSurface, runManualCompaction, isFileDiffDisplay, renderFrontmatter, defineEmbedder, migrateModeName, skillFrontmatterSchema, asSkillId, startChannelWith, parseFrontmatterFile, createDeferredPermissionResolver, getInstallHint, defineTranscriber, summarizeTokensByModel, countNodes, moxxyPackageSchema, encodeLoginPrompt, classifyNetworkError, addModelTotals, createJsonFileStore, ISOLATION_RANK, MOXXY_PCM16_24KHZ_MIME, fileDiffVerb, parseFrontmatter, createCallbackResolver, autoAllowResolver, asSessionId, asToolCallId, defineViewRenderer, DEFAULT_VIEW_TAGS, isSafeViewUrl, evaluateToolRule, summarizeSessionTokensFromEvents, toDiffRows, diffGutterNo, computeElisionState, toolResultStubbed, toolResultStub, toolResultBytes, conversationalStubbed, conversationalStub, asEventId } from '@moxxy/sdk';
 import * as fs32 from 'fs';
-import fs32__default, { existsSync, promises, ReadStream, mkdirSync, statSync, readdirSync, writeFileSync, readFileSync, unlinkSync, chmodSync, watch, createReadStream } from 'fs';
+import fs32__default, { existsSync, promises, ReadStream, mkdirSync, rmSync, statSync, readdirSync, writeFileSync, readFileSync, unlinkSync, chmodSync, watch, createReadStream } from 'fs';
 import * as path3 from 'path';
 import path3__default, { join, dirname, resolve, relative, isAbsolute, basename } from 'path';
 import { isCliTunnelAvailable, writeFileAtomic, spawnCliTunnel, moxxyPath, moxxyHome, bearerTokenMatches, resolveChannelToken, rotateChannelToken, readRequestBody, MOXXY_WS_SUBPROTOCOL, bearerGuard, tokenFromWsProtocolHeader, writeFileAtomicSync } from '@moxxy/sdk/server';
@@ -3666,6 +3666,107 @@ var init_session = __esm({
     };
   }
 });
+
+// ../core/dist/setup-agent.js
+function resolvePermissions(p3) {
+  if (p3 === "deny")
+    return denyByDefaultResolver;
+  if (p3 === void 0 || p3 === "auto")
+    return autoAllowResolver;
+  return p3;
+}
+function finalText(events) {
+  for (let i2 = events.length - 1; i2 >= 0; i2 -= 1) {
+    const e3 = events[i2];
+    if (e3.type === "assistant_message")
+      return e3.content;
+  }
+  return "";
+}
+function mergePresets(presets) {
+  const plugins = [];
+  const seen = /* @__PURE__ */ new Set();
+  const tools = [];
+  let provider;
+  let cwd2;
+  let permissions;
+  let session;
+  for (const p3 of presets) {
+    for (const pl of p3.plugins ?? []) {
+      if (seen.has(pl.name))
+        continue;
+      seen.add(pl.name);
+      plugins.push(pl);
+    }
+    if (p3.tools)
+      tools.push(...p3.tools);
+    if (!provider && p3.provider)
+      provider = p3.provider;
+    cwd2 ??= p3.cwd;
+    permissions ??= p3.permissions;
+    if (p3.session)
+      session = { ...session, ...p3.session };
+  }
+  return { plugins, tools, provider, cwd: cwd2, permissions, session };
+}
+function setupAgent(input = {}) {
+  const opts = Array.isArray(input) ? mergePresets(input) : input;
+  const session = new Session({
+    cwd: opts.cwd ?? process.cwd(),
+    permissionResolver: resolvePermissions(opts.permissions),
+    ...opts.session
+  });
+  for (const plugin5 of opts.plugins ?? [])
+    session.pluginHost.registerStatic(plugin5);
+  for (const tool of opts.tools ?? [])
+    session.tools.register(tool);
+  if (opts.provider)
+    session.providers.setActive(opts.provider.name, opts.provider.config);
+  const agent = {
+    session,
+    async *stream(prompt, runOpts) {
+      yield* runTurn(session, prompt, runOpts);
+    },
+    async ask(prompt, runOpts) {
+      return finalText(await collectTurn(session, prompt, runOpts));
+    },
+    collect(prompt, runOpts) {
+      return collectTurn(session, prompt, runOpts);
+    },
+    async discover() {
+      await session.pluginHost.discoverAndLoad();
+      return agent;
+    },
+    use(plugin5) {
+      session.pluginHost.registerStatic(plugin5);
+      return agent;
+    },
+    addTool(tool) {
+      session.tools.register(tool);
+      return agent;
+    },
+    removeTool(name) {
+      session.tools.unregister(name);
+      return agent;
+    },
+    setProvider(name, config) {
+      session.providers.setActive(name, config);
+      return agent;
+    },
+    setMode(name) {
+      session.modes.setActive(name);
+      return agent;
+    }
+  };
+  return agent;
+}
+var init_setup_agent = __esm({
+  "../core/dist/setup-agent.js"() {
+    init_session();
+    init_run_turn();
+    init_resolvers();
+  }
+});
 function preferencesPath() {
   return path3.join(os5.homedir(), ".moxxy", "preferences.json");
 }
@@ -4149,6 +4250,45 @@ async function restoreEvents(sessionId, dir = defaultSessionsDir(), logger = cre
   }
   return events;
 }
+async function readEventPage(sessionId, opts, dir = defaultSessionsDir()) {
+  const logPath = path3.join(dir, `${sessionId}.jsonl`);
+  let raw;
+  try {
+    raw = await promises.readFile(logPath, "utf8");
+  } catch {
+    return { events: [], prevCursor: null };
+  }
+  const all = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim())
+      continue;
+    try {
+      all.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return pageEvents(all, opts.before, opts.limit);
+}
+function pageEvents(events, before, limit2) {
+  const cap = Math.max(0, Math.floor(limit2));
+  if (cap === 0 || events.length === 0) {
+    return { events: [], prevCursor: events.length === 0 ? null : before };
+  }
+  let end = events.length;
+  if (before !== null) {
+    end = 0;
+    for (let i2 = 0; i2 < events.length; i2 += 1) {
+      if (events[i2].seq < before)
+        end = i2 + 1;
+      else
+        break;
+    }
+  }
+  const start = Math.max(0, end - cap);
+  const page = events.slice(start, end);
+  const prevCursor = start <= 0 ? null : page[0].seq;
+  return { events: page, prevCursor };
+}
 async function deleteSession(sessionId, dir = defaultSessionsDir()) {
   await promises.rm(path3.join(dir, `${sessionId}.jsonl`), { force: true });
   await promises.rm(metaPath(dir, sessionId), { force: true });
@@ -8414,16 +8554,19 @@ __export(dist_exports, {
   mergeUsageStats: () => mergeUsageStats,
   newSessionId: () => newSessionId,
   newTurnId: () => newTurnId,
+  pageEvents: () => pageEvents,
   parseFrontmatter: () => parseFrontmatter,
   parseSkillFile: () => parseSkillFile,
   parseView: () => parseView,
   permissionPolicySchema: () => permissionPolicySchema,
   preferencesPath: () => preferencesPath,
   readPackageMoxxyRequirements: () => readPackageMoxxyRequirements,
+  readSessionEventPage: () => readEventPage,
   readSessionIndex: () => readIndex,
   restoreSessionEvents: () => restoreEvents,
   runTurn: () => runTurn,
   savePreferences: () => savePreferences,
+  setupAgent: () => setupAgent,
   silentLogger: () => silentLogger,
   synthesizeSkill: () => synthesizeSkill,
   toposortPluginManifests: () => toposortPluginManifests,
@@ -8434,6 +8577,7 @@ var init_dist = __esm({
   "../core/dist/index.js"() {
     init_session();
     init_run_turn();
+    init_setup_agent();
     init_subagents();
     init_preferences();
     init_usage_stats();
@@ -136266,7 +136410,7 @@ async function reclaimStaleSocket(socketPath) {
 
 // ../runner/dist/server.js
 init_dist();
-var RUNNER_PROTOCOL_VERSION = 9;
+var RUNNER_PROTOCOL_VERSION = 10;
 var MIN_COMPATIBLE_PROTOCOL_VERSION = 1;
 var RunnerMethod = {
   /** client->server: handshake; returns the initial info snapshot. */
@@ -136285,6 +136429,13 @@ var RunnerMethod = {
    * attached clients so every mirror clears in lockstep.
    */
   SessionReset: "session.reset",
+  /**
+   * client->server: page the runner's authoritative event history (v10).
+   * `{ before, limit }` → `{ events, prevCursor }`, newest-first. Backs the
+   * desktop dual-history retirement; a v10 client gates it on the server's
+   * reported version and falls back to its NDJSON store against an older runner.
+   */
+  SessionLoadHistory: "session.loadHistory",
   /** client->server: declare which resolvers this client will answer. */
   SetResolver: "setResolver",
   /** client->server: switch the active mode. */
@@ -136410,6 +136561,11 @@ var modeSetActiveParamsSchema = z.object({ name: z.string() });
 var sessionSetReasoningParamsSchema = z.object({
   effort: z.enum(["off", "low", "medium", "high"])
 });
+var MAX_HISTORY_PAGE_LIMIT = 2e3;
+var sessionLoadHistoryParamsSchema = z.object({
+  before: z.number().int().nonnegative().nullable(),
+  limit: z.number().int().positive().max(MAX_HISTORY_PAGE_LIMIT)
+});
 var providerSetActiveParamsSchema = z.object({
   name: z.string(),
   config: z.record(z.unknown()).optional()
@@ -136734,6 +136890,7 @@ async function handleSurfaceClose(ctx, raw) {
 }
 
 // ../runner/dist/handlers/session-handlers.js
+init_dist();
 function handleModeSetActive(ctx, raw) {
   const { name } = modeSetActiveParamsSchema.parse(raw);
   ctx.session.modes.setActive(name);
@@ -136745,6 +136902,14 @@ function handleSessionSetReasoning(ctx, raw) {
   ctx.broadcastInfo();
   return {};
 }
+async function handleSessionLoadHistory(ctx, raw) {
+  const { before, limit: limit2 } = sessionLoadHistoryParamsSchema.parse(raw);
+  const log = ctx.session.log;
+  if (log.baseSeq === 0) {
+    return pageEvents(log.toJSON(), before, limit2);
+  }
+  return readEventPage(String(ctx.session.id), { before, limit: limit2 }, ctx.sessionsDir);
+}
 async function handlePermissionAddAllow(ctx, raw) {
   const { name, reason } = permissionAddAllowParamsSchema.parse(raw);
   await ctx.session.permissions.addAllow({ name, ...reason ? { reason } : {} });
@@ -136863,6 +137028,7 @@ var RunnerServer = class {
     peer.handle(RunnerMethod.RunTurn, (raw) => this.handleRunTurn(client, raw));
     peer.handle(RunnerMethod.Abort, (raw) => this.handleAbort(client, raw));
     peer.handle(RunnerMethod.SessionReset, () => this.handleSessionReset());
+    peer.handle(RunnerMethod.SessionLoadHistory, (raw) => handleSessionLoadHistory(ctx, raw));
     peer.handle(RunnerMethod.SetResolver, (raw) => this.handleSetResolver(client, raw));
     peer.handle(RunnerMethod.ModeSetActive, (raw) => handleModeSetActive(ctx, raw));
     peer.handle(RunnerMethod.SessionSetReasoning, (raw) => handleSessionSetReasoning(ctx, raw));
@@ -136946,6 +137112,7 @@ var RunnerServer = class {
       } finally {
         this.turnControllers.delete(turnId);
         client.turns.delete(turnId);
+        await this.sealUnsealedStreamedText(turnId);
         this.broadcast(RunnerNotification.TurnComplete, {
           turnId,
           ...error2 ? { error: error2 } : {}
@@ -136990,6 +137157,59 @@ var RunnerServer = class {
     this.session.log.clear();
     return {};
   }
+  /**
+   * If this turn streamed assistant text (`assistant_chunk`) that no
+   * `assistant_message` ever sealed, append a REAL `assistant_message` to the
+   * authoritative log so it persists + replays like any other reply. It
+   * accumulates chunk deltas and seals whatever text remains at turn end — so a
+   * cleanly sealed reply (the normal path) leaves an empty remainder and this is
+   * a no-op.
+   *
+   * The accumulator resets on BOTH per-iteration boundaries — an
+   * `assistant_message` (a reply was sealed) AND a `provider_request` (a fresh
+   * provider iteration begins). Resetting on `provider_request` is what scopes
+   * the seal to the FINAL iteration: a retryable provider error can abandon a
+   * partially-streamed iteration WITHOUT sealing it (the mode loop emits the
+   * error and `continue`s), and a later iteration then streams fresh text and
+   * may itself end unsealed (a fatal error / abort / max-iterations). Without
+   * the `provider_request` reset, the abandoned attempt's chunks would be
+   * concatenated INTO the sealed reply ("ABANDONED-final" instead of "final"),
+   * durably corrupting authoritative/replayed history. (This is a deliberate
+   * improvement over the desktop renderer's old turn-complete synthesis, which
+   * accumulated across iterations and had exactly that defect — and which this
+   * seal retires.)
+   *
+   * The append flows through `session.log` → persistence + the broadcast stream,
+   * so mirrors ingest it as a normal event and never need to synthesize their
+   * own.
+   */
+  async sealUnsealedStreamedText(turnId) {
+    const events = this.session.log.byTurn(turnId);
+    if (events.length === 0)
+      return;
+    let unsealed = "";
+    for (const event of events) {
+      if (event.type === "assistant_message" || event.type === "provider_request")
+        unsealed = "";
+      else if (event.type === "assistant_chunk")
+        unsealed += event.delta;
+    }
+    if (!unsealed.trim())
+      return;
+    try {
+      await this.session.log.append({
+        type: "assistant_message",
+        sessionId: this.session.id,
+        turnId,
+        source: "model",
+        content: unsealed,
+        // The turn ended without the provider sealing the message (error/abort
+        // after partial text); record it as a normal completed reply.
+        stopReason: "end_turn"
+      });
+    } catch {
+    }
+  }
   handleSetResolver(client, raw) {
     const params = setResolverParamsSchema.parse(raw);
     if (params.permission !== void 0)
@@ -137602,6 +137822,26 @@ var RemoteSession = class {
   async reset() {
     await this.peer.request(RunnerMethod.SessionReset, {});
   }
+  /**
+   * Page the runner's AUTHORITATIVE event history (protocol v10). Backs the
+   * desktop's dual-history retirement — the renderer reads transcript history
+   * from the runner instead of its own NDJSON chat store. Newest-first paging:
+   * pass `before: null` for the newest page, then feed each result's
+   * `prevCursor` back as `before` to walk older pages until `prevCursor` is
+   * `null` (start of history).
+   *
+   * GATED on the server reporting protocol v10+. Against an OLDER runner this
+   * throws a clear, actionable error (not a raw method-not-found) — the desktop
+   * CATCHES it and falls back to its existing NDJSON path, so no transcript
+   * ever goes blank when the runner predates this method.
+   */
+  async loadHistory(before, limit2) {
+    this.requireServerProtocol(10, "Loading session history from the runner");
+    return this.peer.request(RunnerMethod.SessionLoadHistory, {
+      before,
+      limit: limit2
+    });
+  }
   getInfo() {
     return this.requireInfo();
   }
@@ -138418,7 +138658,7 @@ var CollaborationState = class {
       return;
     agent.status = status;
     this.emitFn({ kind: "agent_status", agentId, status, ...detail ? { detail } : {} });
-    if (status === "crashed" || status === "killed")
+    if (status === "crashed" || status === "killed" || status === "failed")
       this.releaseAllFor(agentId);
   }
   markDone(agentId, summary, artifacts) {
@@ -138431,7 +138671,7 @@ var CollaborationState = class {
     this.emitFn({ kind: "agent_done", agentId, summary, ...artifacts ? { artifacts } : {} });
   }
   allDone() {
-    const live = this.agentOrder.map((id) => this.agents.get(id)).filter((a2) => a2.status !== "crashed" && a2.status !== "killed");
+    const live = this.agentOrder.map((id) => this.agents.get(id)).filter((a2) => a2.status !== "crashed" && a2.status !== "killed" && a2.status !== "failed");
     return live.length > 0 && live.every((a2) => a2.status === "done");
   }
   roleOf(agentId) {
@@ -138789,7 +139029,7 @@ async function createCollaborationHub(opts) {
       connections.delete(peer);
       if (agentId) {
         const agent = state.rosterView().agents.find((a2) => a2.id === agentId);
-        if (agent && agent.status !== "done" && agent.status !== "killed") {
+        if (agent && agent.status !== "done" && agent.status !== "failed" && agent.status !== "killed") {
           state.setStatus(agentId, "crashed");
         }
       }
@@ -139035,13 +139275,24 @@ var PeerSupervisor = class {
     child.on("exit", () => {
       proc.exited = true;
     });
+    child.on("error", (err) => {
+      proc.exited = true;
+      proc.stderr.push(`spawn error: ${err.message}`);
+    });
     return { socket };
   }
+  /** True once the child has exited or its spawn failed. */
+  hasExited(agentId) {
+    const proc = this.peers.get(agentId);
+    return proc ? proc.exited : false;
+  }
   /** Last stderr lines from a peer — used to diagnose a crash. */
   stderrOf(agentId) {
     return this.peers.get(agentId)?.stderr ?? [];
   }
-  /** Best-effort: abort a single peer's in-flight turn via its runner, then kill. */
+  /** Stop a single peer and AWAIT its real exit (with a force-kill fallback), so
+   *  callers — e.g. the sequential fallback — can rely on the workspace being
+   *  free before the next agent starts. */
   async stop(agentId) {
     const proc = this.peers.get(agentId);
     if (!proc || proc.exited)
@@ -139050,6 +139301,27 @@ var PeerSupervisor = class {
       proc.child.kill("SIGTERM");
     } catch {
     }
+    await new Promise((resolve13) => {
+      if (proc.exited)
+        return resolve13();
+      let settled = false;
+      const done = () => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        resolve13();
+      };
+      proc.child.once("exit", done);
+      const timer = setTimeout(() => {
+        try {
+          proc.child.kill("SIGKILL");
+        } catch {
+        }
+        done();
+      }, FORCE_KILL_GRACE_MS);
+      timer.unref?.();
+    });
   }
   async shutdownAll(_reason) {
     if (this.shuttingDown)
@@ -139183,6 +139455,7 @@ function releaseCollabLock(sessionId) {
 
 // ../mode-collaborative/dist/collab-loop.js
 var POLL_MS = 500;
+var BOOT_DEADLINE_MS = 9e4;
 function runCollaborativeMode(ctx) {
   return runCollaborative(ctx, {});
 }
@@ -139251,13 +139524,18 @@ async function* runCollaborative(ctx, deps) {
     yield await ctx.emit(plugin4(ctx, "collab_started", { task, parallel, gitInstalled: gitInstalled2, gitRepo }));
     supervisor.spawn({ entry: architectEntry, cwd: cwd2, mode: COLLAB_ARCHITECT_MODE_NAME });
     yield await ctx.emit(plugin4(ctx, "collab_agent_spawned", { id: ARCHITECT_AGENT_ID, role: "architect" }));
-    const architectOk = await waitForAgent(hub, ARCHITECT_AGENT_ID, ctx.signal, cfg.wallClockMs);
+    const architectOk = await waitForAgent(hub, supervisor, ARCHITECT_AGENT_ID, ctx.signal, cfg.wallClockMs);
     if (ctx.signal.aborted) {
       yield await ctx.emit(emitAbort(ctx, "aborted during design"));
       return;
     }
     if (!architectOk) {
-      yield await ctx.emit(assistant(ctx, "The architect did not finish the design. Stopping the collaboration."));
+      const why = supervisor.stderrOf(ARCHITECT_AGENT_ID).slice(-4).join("\n");
+      yield await ctx.emit(plugin4(ctx, "collab_agent_failed", { id: ARCHITECT_AGENT_ID, status: statusOf(hub, ARCHITECT_AGENT_ID), stderr: supervisor.stderrOf(ARCHITECT_AGENT_ID).slice(-6) }));
+      yield await ctx.emit(assistant(ctx, `The architect did not finish the design \u2014 stopping the collaboration.${why ? `
+
+Last diagnostics:
+${why}` : ""}`));
       return;
     }
     let roster = readRoster(join(cwd2, COLLAB_SCAFFOLD_DIR, ROSTER_FILENAME), cfg.maxAgents);
@@ -139298,7 +139576,8 @@ async function* runCollaborative(ctx, deps) {
         supervisor.spawn({ entry, cwd: wt3, mode: COLLAB_PEER_MODE_NAME });
         yield await ctx.emit(plugin4(ctx, "collab_agent_spawned", { id: entry.id, role: entry.role }));
       }
-      await waitForAgents(hub, roster.map((r2) => r2.id), ctx.signal, cfg.wallClockMs);
+      await waitForAgents(hub, supervisor, roster.map((r2) => r2.id), ctx.signal, cfg.wallClockMs);
+      yield* surfaceFailures(ctx, hub, supervisor, roster.map((r2) => r2.id));
       for (const r2 of roster)
         if (statusOf(hub, r2.id) === "done")
           doneIds.push(r2.id);
@@ -139309,7 +139588,9 @@ async function* runCollaborative(ctx, deps) {
         hub.state.addAgent(entry);
         supervisor.spawn({ entry, cwd: cwd2, mode: COLLAB_PEER_MODE_NAME });
         yield await ctx.emit(plugin4(ctx, "collab_agent_spawned", { id: entry.id, role: entry.role }));
-        const ok = await waitForAgent(hub, entry.id, ctx.signal, cfg.wallClockMs);
+        const ok = await waitForAgent(hub, supervisor, entry.id, ctx.signal, cfg.wallClockMs);
+        if (!ok)
+          yield* surfaceFailures(ctx, hub, supervisor, [entry.id]);
         await supervisor.stop(entry.id);
         if (ok && statusOf(hub, entry.id) === "done")
           doneIds.push(entry.id);
@@ -139353,6 +139634,16 @@ ${mergeNote}` : ""}`));
     if (hub)
       await hub.close();
     releaseCollabLock(String(ctx.sessionId));
+    for (const wt3 of worktrees.values()) {
+      await removeWorktree(cwd2, wt3).catch(() => void 0);
+    }
+    try {
+      rmSync(collabRunDir(runId), { recursive: true, force: true });
+      rmSync(worktreeRoot(runId), { recursive: true, force: true });
+    } catch {
+    }
+    if (worktrees.size > 0)
+      await git(cwd2, ["worktree", "prune"]).catch(() => void 0);
   }
 }
 function lastUserPromptText(ctx) {
@@ -139403,30 +139694,62 @@ function slug(s2) {
 function statusOf(hub, id) {
   return hub.state.rosterView().agents.find((a2) => a2.id === id)?.status;
 }
-async function waitForAgent(hub, id, signal, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
+function agentSettled(hub, supervisor, id, connected, bootDeadlineAt) {
+  const status = statusOf(hub, id);
+  if (status && status !== "pending")
+    connected.add(id);
+  if (status === "done")
+    return "done";
+  if (status === "failed" || status === "crashed" || status === "killed")
+    return "failed";
+  if (supervisor?.hasExited(id))
+    return "failed";
+  if (!connected.has(id) && Date.now() > bootDeadlineAt)
+    return "failed";
+  return void 0;
+}
+async function waitForAgent(hub, supervisor, id, signal, wallClockMs) {
+  const wallDeadline = Date.now() + wallClockMs;
+  const bootDeadlineAt = Date.now() + BOOT_DEADLINE_MS;
+  const connected = /* @__PURE__ */ new Set();
   for (; ; ) {
-    const status = statusOf(hub, id);
-    if (status === "done")
+    const settled = agentSettled(hub, supervisor, id, connected, bootDeadlineAt);
+    if (settled === "done")
       return true;
-    if (status === "crashed" || status === "killed")
+    if (settled === "failed")
       return false;
-    if (signal.aborted || Date.now() > deadline)
+    if (signal.aborted || Date.now() > wallDeadline)
       return false;
     await sleep5(POLL_MS, signal);
   }
 }
-async function waitForAgents(hub, ids, signal, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  const terminal = (s2) => s2 === "done" || s2 === "crashed" || s2 === "killed";
+async function waitForAgents(hub, supervisor, ids, signal, wallClockMs) {
+  const wallDeadline = Date.now() + wallClockMs;
+  const bootDeadlineAt = Date.now() + BOOT_DEADLINE_MS;
+  const connected = /* @__PURE__ */ new Set();
   for (; ; ) {
-    if (ids.every((id) => terminal(statusOf(hub, id))))
+    if (ids.every((id) => agentSettled(hub, supervisor, id, connected, bootDeadlineAt) !== void 0))
       return;
-    if (signal.aborted || Date.now() > deadline)
+    if (signal.aborted || Date.now() > wallDeadline)
       return;
     await sleep5(POLL_MS, signal);
   }
 }
+async function* surfaceFailures(ctx, hub, supervisor, ids) {
+  for (const id of ids) {
+    const status = statusOf(hub, id);
+    if (status === "done")
+      continue;
+    if (status !== "failed" && status !== "crashed" && status !== "killed") {
+      hub.state.setStatus(id, "crashed", "did not reach a terminal status");
+    }
+    yield await ctx.emit(plugin4(ctx, "collab_agent_failed", {
+      id,
+      status: statusOf(hub, id),
+      stderr: supervisor.stderrOf(id).slice(-6)
+    }));
+  }
+}
 function sleep5(ms, signal) {
   return new Promise((resolve13) => {
     if (signal.aborted)
@@ -139548,6 +139871,8 @@ async function* runCollabAgentLoop(ctx, opts) {
     permissions: autoApprove
   };
   const hub = await getProcessHubClient();
+  if (hub)
+    await hub.setStatus("working").catch(() => void 0);
   const detector = createStuckLoopDetector();
   const maxIterations = ctx.maxIterations ?? DEFAULT_MAX_ITERATIONS;
   let noop3 = 0;
@@ -144150,12 +144475,9 @@ var REMOTE_ALLOWED_COMMANDS = /* @__PURE__ */ new Set([
   // Voice input (capability-probed; transcribe fails coded without a transcriber).
   "session.hasTranscriber",
   "session.transcribe",
-  // Per-workspace transcript log (the mobile ChatStoreBridge persists through
-  // these; they're scoped to a workspace's NDJSON log, not host config).
-  "chat.append",
-  "chat.loadSegment",
-  "chat.clearLog",
-  "chat.migrate",
+  // Read a workspace's transcript history from the runner's authoritative log
+  // (a paired phone may read history, scoped to a workspace, not host config).
+  "chat.loadHistory",
   // Workflows: READ + run an existing one only. Authoring (`workflows.save`,
   // `workflows.validateDraft`, `workflows.setEnabled`) is host-only — a paired
   // phone must not rewrite or re-enable the host's workflows.
@@ -144363,25 +144685,13 @@ var ipcInputSchemas = {
   "mobileGateway.status": z.undefined(),
   "mobileGateway.rotateToken": z.undefined(),
   "mobileGateway.setEnabled": z.object({ enabled: z.boolean() }).strict(),
-  "chat.append": z.object({
-    workspaceId: z.string().min(1).max(256),
-    events: z.array(z.unknown()).max(1e4)
-  }),
-  "chat.loadSegment": z.object({
+  // `before` is a runner `seq` cursor; the page is RAW events. The runner itself
+  // re-validates and caps at its own MAX_HISTORY_PAGE_LIMIT (2000), so bound the
+  // renderer's raw-window request to that ceiling.
+  "chat.loadHistory": z.object({
     workspaceId: z.string().min(1).max(256),
     before: z.number().int().nonnegative().nullable(),
-    limit: z.number().int().positive().max(1e3)
-  }),
-  "chat.clearLog": z.object({ workspaceId: z.string().min(1).max(256) }),
-  // chat.migrate writes the supplied events straight into per-workspace NDJSON
-  // logs on disk, so it's a filesystem-touching command: bound both the number
-  // of workspaces and the events per workspace, and lock the workspaceId to a
-  // non-empty bounded slug so it can't traverse out of the log directory.
-  "chat.migrate": z.object({
-    workspaces: z.array(z.object({
-      workspaceId: z.string().min(1).max(256),
-      events: z.array(z.unknown()).max(1e4)
-    })).max(100)
+    limit: z.number().int().positive().max(2e3)
   }),
   // Vault writes are security-sensitive: lock the key name to a safe slug
   // (letters/digits + . _ / - , no traversal) and bound the secret size.
@@ -144626,13 +144936,7 @@ var MobileSessionHost = class {
     this.bus.handle("ask.respond", async ({ requestId, response }) => {
       this.answerAsk(requestId, response);
     });
-    this.bus.handle("chat.loadSegment", async () => ({ events: [], prevCursor: null }));
-    this.bus.handle("chat.append", async () => {
-    });
-    this.bus.handle("chat.clearLog", async () => {
-    });
-    this.bus.handle("chat.migrate", async () => {
-    });
+    this.bus.handle("chat.loadHistory", async () => ({ events: [], prevCursor: null }));
   }
   /** Stream session events to clients + install the ask resolvers. */
   wire() {
@@ -145703,8 +146007,8 @@ function runProcess(cmd, args, opts) {
 }
 
 // ../plugin-browser/dist/browser-surface.js
-var FRAME_INTERVAL_MS = 450;
-var FAIL_GRACE = 4;
+var FRAME_INTERVAL_MS = 300;
+var FAIL_GRACE = 6;
 function buildBrowserSurface(deps) {
   return defineSurface({
     kind: "browser",
@@ -145831,9 +146135,10 @@ function buildBrowserSurface(deps) {
           } else if (msg.type === "move" && typeof msg.fx === "number" && typeof msg.fy === "number") {
             await browserSidecarCall("mousemove", { x: msg.fx * vw, y: msg.fy * vh }, deps).catch(() => void 0);
             void tick();
-          } else if (msg.type === "pick" && typeof msg.fx === "number" && typeof msg.fy === "number") {
-            const element = await browserSidecarCall("pick", { x: msg.fx * vw, y: msg.fy * vh }, deps).catch(() => null);
-            emit2({ type: "picked", element });
+          } else if (msg.type === "capture" && typeof msg.fx === "number" && typeof msg.fy === "number" && typeof msg.fw === "number" && typeof msg.fh === "number") {
+            const shot = await browserSidecarCall("capture", { x: msg.fx * vw, y: msg.fy * vh, width: msg.fw * vw, height: msg.fh * vh }, deps).catch(() => null);
+            if (shot)
+              emit2({ type: "captured", base64: shot.base64, mediaType: shot.mediaType });
           } else if (msg.type === "zoom" && typeof msg.factor === "number") {
             await browserSidecarCall("zoom", { factor: msg.factor }, deps).catch(() => void 0);
             bump();
@@ -155668,6 +155973,16 @@ async function runAgentCommand(argv) {
       for await (const _2 of session.runTurn(subtask)) void _2;
     } catch {
     }
+    try {
+      const hub = await getProcessHubClient();
+      if (hub) {
+        const mine = (await hub.roster()).agents.find((a2) => a2.id === hub.agentId);
+        if (mine && mine.status !== "done") {
+          await hub.setStatus("failed", "turn ended without calling collab_done");
+        }
+      }
+    } catch {
+    }
   })();
   await runUntilSignal2(runnerServer, session, turnDone);
   return 0;