@moxxy/cli 0.14.3 → 0.14.5

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, writeFileSync, rmSync, statSync, readdirSync, 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';
@@ -81553,10 +81553,10 @@ var init_output = __esm({
           transformers
         });
       }
-      clip(clip) {
+      clip(clip2) {
         this.operations.push({
           type: "clip",
-          clip
+          clip: clip2
         });
       }
       unclip() {
@@ -81590,40 +81590,40 @@ var init_output = __esm({
             const { text, transformers } = operation;
             let { x: x4, y: y2 } = operation;
             let lines = text.split("\n");
-            const clip = clips.at(-1);
-            if (clip) {
-              const clipHorizontally = typeof clip?.x1 === "number" && typeof clip?.x2 === "number";
-              const clipVertically = typeof clip?.y1 === "number" && typeof clip?.y2 === "number";
+            const clip2 = clips.at(-1);
+            if (clip2) {
+              const clipHorizontally = typeof clip2?.x1 === "number" && typeof clip2?.x2 === "number";
+              const clipVertically = typeof clip2?.y1 === "number" && typeof clip2?.y2 === "number";
               if (clipHorizontally) {
                 const width = widestLine(text);
-                if (x4 + width < clip.x1 || x4 > clip.x2) {
+                if (x4 + width < clip2.x1 || x4 > clip2.x2) {
                   continue;
                 }
               }
               if (clipVertically) {
                 const height = lines.length;
-                if (y2 + height < clip.y1 || y2 > clip.y2) {
+                if (y2 + height < clip2.y1 || y2 > clip2.y2) {
                   continue;
                 }
               }
               if (clipHorizontally) {
                 lines = lines.map((line) => {
-                  const from = x4 < clip.x1 ? clip.x1 - x4 : 0;
+                  const from = x4 < clip2.x1 ? clip2.x1 - x4 : 0;
                   const width = stringWidth(line);
-                  const to = x4 + width > clip.x2 ? clip.x2 - x4 : width;
+                  const to = x4 + width > clip2.x2 ? clip2.x2 - x4 : width;
                   return sliceAnsi2(line, from, to);
                 });
-                if (x4 < clip.x1) {
-                  x4 = clip.x1;
+                if (x4 < clip2.x1) {
+                  x4 = clip2.x1;
                 }
               }
               if (clipVertically) {
-                const from = y2 < clip.y1 ? clip.y1 - y2 : 0;
+                const from = y2 < clip2.y1 ? clip2.y1 - y2 : 0;
                 const height = lines.length;
-                const to = y2 + height > clip.y2 ? clip.y2 - y2 : height;
+                const to = y2 + height > clip2.y2 ? clip2.y2 - y2 : height;
                 lines = lines.slice(from, to);
-                if (y2 < clip.y1) {
-                  y2 = clip.y1;
+                if (y2 < clip2.y1) {
+                  y2 = clip2.y1;
                 }
               }
             }
@@ -136051,6 +136051,7 @@ var ARCHITECT_AGENT_ID = "architect";
 var COLLAB_SCAFFOLD_DIR = ".moxxy-collab";
 var CONTRACTS_FILENAME = "CONTRACTS.md";
 var ROSTER_FILENAME = "roster.json";
+var BRIEF_FILENAME = "BRIEF.md";
 function collabRunId(sessionId, turnId) {
   const tail = (s2) => s2.replace(/[^a-zA-Z0-9]/g, "").slice(-6) || "x";
   return `${tail(sessionId)}-${tail(turnId)}`;
@@ -138658,7 +138659,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) {
@@ -138671,7 +138672,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) {
@@ -139029,7 +139030,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");
         }
       }
@@ -139100,6 +139101,53 @@ function resolveCollabConfig(persisted, overrides) {
 function stripUndefined(obj) {
   return Object.fromEntries(Object.entries(obj).filter(([, v3]) => v3 !== void 0));
 }
+var MAX_MSG_CHARS = 600;
+var MAX_TOTAL_CHARS = 6e3;
+function clip(s2, n2) {
+  const t2 = s2.trim().replace(/\s+/g, " ");
+  return t2.length > n2 ? `${t2.slice(0, n2 - 1)}\u2026` : t2;
+}
+function digestTurns(events) {
+  const out = [];
+  for (const raw of events) {
+    const e3 = raw;
+    if (e3.type === "user_prompt" && typeof e3.text === "string" && e3.text.trim()) {
+      out.push({ role: "user", text: e3.text });
+    } else if (e3.type === "assistant_message" && e3.source === "model" && typeof e3.content === "string" && e3.content.trim()) {
+      out.push({ role: "assistant", text: e3.content });
+    }
+  }
+  return out;
+}
+function buildBrief(task, events) {
+  const turns = digestTurns(events);
+  const trimmed = turns.length > 0 && turns[turns.length - 1].role === "user" && turns[turns.length - 1].text.trim() === task.trim() ? turns.slice(0, -1) : turns;
+  const recent = trimmed.slice(-12);
+  const lines = [
+    "# Collaboration brief",
+    "",
+    "This is the shared context for the whole team. It is the user's goal and the",
+    "conversation that led to it \u2014 read it before planning so your work fits the",
+    "real intent, not just your narrow sub-task.",
+    "",
+    "## Goal",
+    "",
+    clip(task, 1500) || "(no goal text)"
+  ];
+  if (recent.length > 0) {
+    lines.push("", "## Conversation so far", "");
+    for (const t2 of recent) {
+      const who = t2.role === "user" ? "User" : "Assistant";
+      lines.push(`- **${who}:** ${clip(t2.text, MAX_MSG_CHARS)}`);
+    }
+  }
+  let brief = lines.join("\n");
+  if (brief.length > MAX_TOTAL_CHARS) {
+    brief = `${brief.slice(0, MAX_TOTAL_CHARS - 1)}\u2026`;
+  }
+  return `${brief}
+`;
+}
 var IDENTITY = ["-c", "user.name=moxxy-collab", "-c", "user.email=collab@moxxy.local"];
 function git(cwd2, args) {
   return new Promise((resolve13) => {
@@ -139275,13 +139323,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)
@@ -139290,6 +139349,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)
@@ -139423,6 +139503,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, {});
 }
@@ -139489,15 +139570,26 @@ async function* runCollaborative(ctx, deps) {
     };
     supervisor = (deps.createSupervisor ?? ((o2) => new PeerSupervisor(o2)))(supervisorOpts, hub);
     yield await ctx.emit(plugin4(ctx, "collab_started", { task, parallel, gitInstalled: gitInstalled2, gitRepo }));
+    try {
+      mkdirSync(join(cwd2, COLLAB_SCAFFOLD_DIR), { recursive: true });
+      writeFileSync(join(cwd2, COLLAB_SCAFFOLD_DIR, BRIEF_FILENAME), buildBrief(task, ctx.log.slice()));
+      yield await ctx.emit(plugin4(ctx, "collab_brief_written", { path: join(COLLAB_SCAFFOLD_DIR, BRIEF_FILENAME) }));
+    } catch {
+    }
     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);
@@ -139538,7 +139630,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);
@@ -139549,7 +139642,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);
@@ -139593,6 +139688,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) {
@@ -139643,30 +139748,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)
@@ -139730,7 +139867,11 @@ function emitAbort(ctx, reason) {
 }
 
 // ../mode-collaborative/dist/prompts.js
-var COLLAB_COMMON = `You are one agent on a TEAM of separate agents collaborating on one task in a shared codebase. You are a peer, not in charge \u2014 you cooperate.
+var COLLAB_COMMON = `You are one agent on a TEAM of separate agents collaborating on one task in a shared workspace. You are a peer, not in charge \u2014 you cooperate.
+
+Know the WHOLE picture before you act:
+- ${COLLAB_SCAFFOLD_DIR}/${BRIEF_FILENAME} is the shared brief \u2014 the user's overall goal and the conversation/intent behind it. Read it FIRST so your work serves the real goal, not just the literal words of your sub-task.
+- Before planning, recall() any relevant prior knowledge about this workspace/task. When you discover a durable fact (a decision, a gotcha, an interface, a convention), memory_save it so the team \u2014 and future work \u2014 keeps it.
 
 The team coordinates through a shared hub (use these tools):
 - collab_roster \u2014 who is on the team, their roles, sub-tasks, and status.
@@ -139749,11 +139890,12 @@ Cooperation rules:
 - When YOUR sub-task is fully complete and verified, call collab_done with a short summary. The run finishes when everyone is done.`;
 var COLLAB_PEER_PROMPT = `${COLLAB_COMMON}
 
-You are an IMPLEMENTER. Your sub-task is provided. Start by reading ${COLLAB_SCAFFOLD_DIR}/${CONTRACTS_FILENAME} and calling collab_contracts, collab_roster, and collab_board so you know the plan and who owns what. Claim your files, implement against the contracts, coordinate on intersections, then call collab_done.`;
+You are an IMPLEMENTER. Your sub-task is provided. Start by reading ${COLLAB_SCAFFOLD_DIR}/${BRIEF_FILENAME} (the goal + intent) and ${COLLAB_SCAFFOLD_DIR}/${CONTRACTS_FILENAME}, and calling collab_contracts, collab_roster, and collab_board so you know the plan and who owns what. Claim your files, implement against the contracts, coordinate on intersections, then call collab_done.`;
 var COLLAB_ARCHITECT_PROMPT = `${COLLAB_COMMON}
 
 You are the ARCHITECT \u2014 you run FIRST and set the team up for success. Your job, in order:
-1. Explore the codebase to understand the task and its boundaries.
+0. Read ${COLLAB_SCAFFOLD_DIR}/${BRIEF_FILENAME} \u2014 the user's goal and the conversation behind it \u2014 so you decompose toward what they actually want.
+1. Explore the workspace to understand the task and its boundaries.
 2. Decompose the task into INDEPENDENT sub-tasks with DISJOINT file ownership (minimize overlap so agents rarely touch the same files).
 3. Define the shared CONTRACTS \u2014 the interfaces, types, API shapes, and module boundaries where the implementers' work meets. Publish each with collab_contract_publish (give an owner + consumers).
 4. Write two files into the repo:
@@ -139788,6 +139930,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;
@@ -144390,12 +144534,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.
@@ -144603,25 +144744,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.
@@ -144866,13 +144995,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() {
@@ -155884,7 +156007,10 @@ async function runAgentCommand(argv) {
   const sessionId = process.env.MOXXY_SESSION_ID?.trim();
   const mode = process.env.MOXXY_MODE?.trim() || "collab-peer";
   const subtask = process.env.MOXXY_COLLAB_SUBTASK ?? "";
+  const parentTask = process.env.MOXXY_COLLAB_PARENT_TASK?.trim() ?? "";
+  const role = process.env.MOXXY_COLLAB_ROLE?.trim() ?? "";
   const model = process.env.MOXXY_MODEL?.trim();
+  const seededTurn = buildSeedTurn({ role, parentTask, subtask });
   const setup = await bootSessionWithConfig(argv, {
     skipKeyPrompt: true,
     tolerateNoProvider: true,
@@ -155906,13 +156032,37 @@ async function runAgentCommand(argv) {
   const runnerServer = await startRunnerServer(session);
   const turnDone = (async () => {
     try {
-      for await (const _2 of session.runTurn(subtask)) void _2;
+      for await (const _2 of session.runTurn(seededTurn)) 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;
 }
+function buildSeedTurn(args) {
+  const { role, parentTask, subtask } = args;
+  const pointer = "Shared team context is in `.moxxy-collab/BRIEF.md` (the user's overall goal + the conversation/intent) and `.moxxy-collab/CONTRACTS.md` (the agreed interfaces). Read them before you start so your work fits the real goal.";
+  if (role === "architect" || !parentTask || parentTask === subtask) {
+    return subtask ? `${subtask}
+
+${pointer}` : pointer;
+  }
+  return `Overall team goal: ${parentTask}
+
+Your sub-task: ${subtask}
+
+${pointer}`;
+}
 async function runUntilSignal2(runnerServer, session, turnDone) {
   let stopping = false;
   const shutdown = async (signal) => {