@moxxy/cli 0.14.4 → 0.14.6

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, rmSync, 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;
                 }
               }
             }
@@ -85713,17 +85713,25 @@ function handleCollabEvent(e3, ref, root) {
       if (typeof item.id === "string") {
         const existing = block.tasks.find((x4) => x4.id === item.id);
         const owner = typeof item.owner === "string" ? item.owner : null;
+        const paths = Array.isArray(item.paths) ? item.paths.filter((x4) => typeof x4 === "string") : void 0;
+        const detail = typeof item.detail === "string" ? item.detail : void 0;
         if (!existing) {
           block.tasks.push({
             id: item.id,
             title: String(item.title ?? ""),
             status: String(item.status ?? "open"),
-            owner
+            owner,
+            ...paths && paths.length > 0 ? { paths } : {},
+            ...detail ? { detail } : {}
           });
         } else {
           existing.title = String(item.title ?? existing.title);
           existing.status = String(item.status ?? existing.status);
           existing.owner = owner ?? existing.owner;
+          if (paths && paths.length > 0)
+            existing.paths = paths;
+          if (detail)
+            existing.detail = detail;
         }
       }
       break;
@@ -136051,6 +136059,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)}`;
@@ -139100,6 +139109,68 @@ 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}
+`;
+}
+function moxxyHome2() {
+  return process.env.MOXXY_HOME ?? join(homedir(), ".moxxy");
+}
+function collabRunsDir() {
+  return join(moxxyHome2(), "collab", "runs");
+}
+function writeRunRecord(rec) {
+  try {
+    const dir = collabRunsDir();
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, `${rec.runId}.json`), `${JSON.stringify(rec, null, 2)}
+`);
+  } catch {
+  }
+}
 var IDENTITY = ["-c", "user.name=moxxy-collab", "-c", "user.email=collab@moxxy.local"];
 function git(cwd2, args) {
   return new Promise((resolve13) => {
@@ -139478,14 +139549,22 @@ async function* runCollaborative(ctx, deps) {
     return;
   }
   const runId = collabRunId(String(ctx.sessionId), String(ctx.turnId));
+  const startedAtMs = Date.now();
   const worktrees = /* @__PURE__ */ new Map();
   let hub = null;
   let supervisor = null;
   let unsubscribe = null;
+  let archiveParallel = false;
+  let archiveGitRepo = false;
+  let briefText = "";
+  let mergeForArchive;
+  let completed = false;
   try {
     mkdirSync(collabRunDir(runId), { recursive: true });
     const { installed: gitInstalled2, repo: gitRepo } = await detectGit(cwd2);
     const parallel = cfg.concurrency === "parallel" && gitRepo;
+    archiveParallel = parallel;
+    archiveGitRepo = gitRepo;
     if (!parallel) {
       yield await ctx.emit(plugin4(ctx, "collab_fallback_sequential", {
         reason: !gitInstalled2 ? "git is not installed \u2014 running agents sequentially in your workspace" : !gitRepo ? "this folder is not a git repository \u2014 running agents sequentially in your workspace" : "sequential mode selected"
@@ -139522,6 +139601,13 @@ 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 {
+      briefText = buildBrief(task, ctx.log.slice());
+      mkdirSync(join(cwd2, COLLAB_SCAFFOLD_DIR), { recursive: true });
+      writeFileSync(join(cwd2, COLLAB_SCAFFOLD_DIR, BRIEF_FILENAME), briefText);
+      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, supervisor, ARCHITECT_AGENT_ID, ctx.signal, cfg.wallClockMs);
@@ -139611,6 +139697,12 @@ ${why}` : ""}`));
         board: hub.state.boardItems(),
         mergePolicy: cfg.mergePolicy
       });
+      mergeForArchive = {
+        merged: result.merged,
+        promoted: result.promoted,
+        conflicts: result.conflicts.length,
+        ...result.stagingBranch ? { stagingBranch: result.stagingBranch } : {}
+      };
       yield await ctx.emit(plugin4(ctx, "collab_merge", result));
       for (const c2 of result.conflicts) {
         yield await ctx.emit(plugin4(ctx, "collab_conflict", c2));
@@ -139624,10 +139716,54 @@ ${why}` : ""}`));
 ${summaryBlock}${mergeNote ? `
 
 ${mergeNote}` : ""}`));
+    completed = true;
     yield await ctx.emit(plugin4(ctx, "collab_completed", { done: doneIds, total: roster.length }));
   } finally {
     if (supervisor)
       await supervisor.shutdownAll("collaboration complete");
+    if (hub) {
+      try {
+        const agents = hub.state.rosterView().agents;
+        const implementers = agents.filter((a2) => a2.role !== "architect");
+        writeRunRecord({
+          runId,
+          task,
+          startedAtMs,
+          finishedAtMs: Date.now(),
+          outcome: completed ? "completed" : ctx.signal.aborted ? "aborted" : "failed",
+          parallel: archiveParallel,
+          gitRepo: archiveGitRepo,
+          agents: agents.map((a2) => ({
+            id: a2.id,
+            name: a2.name,
+            role: a2.role,
+            status: a2.status,
+            subtask: a2.subtask,
+            ...a2.doneSummary ? { doneSummary: a2.doneSummary } : {}
+          })),
+          doneCount: implementers.filter((a2) => a2.status === "done").length,
+          totalCount: implementers.length,
+          board: hub.state.boardItems().map((b3) => ({
+            id: b3.id,
+            title: b3.title,
+            status: b3.status,
+            ...b3.owner ? { owner: b3.owner } : {},
+            ...b3.paths ? { paths: b3.paths } : {}
+          })),
+          contracts: hub.state.contractList().map((c2) => ({
+            id: c2.id,
+            title: c2.title,
+            owner: c2.owner,
+            status: c2.status,
+            version: c2.version
+          })),
+          messageCount: hub.state.allMessages().length,
+          ...mergeForArchive ? { merge: mergeForArchive } : {},
+          ...briefText ? { brief: briefText } : {}
+        });
+      } catch {
+      }
+    }
     if (unsubscribe)
       unsubscribe();
     unregisterActiveHub(String(ctx.sessionId));
@@ -139675,7 +139811,9 @@ function readRoster(path62, maxAgents) {
       out.push({
         id,
         name: typeof r2.name === "string" ? r2.name : id,
-        role: "implementer",
+        // Carry the architect's proposed role (pm/designer/developer/qa/writer/…)
+        // so the team is cross-functional, not a pool of identical implementers.
+        role: cleanRole(r2.role),
         subtask: r2.subtask,
         ...Array.isArray(r2.ownedPaths) ? { ownedPaths: r2.ownedPaths.filter((p3) => typeof p3 === "string") } : {},
         ...typeof r2.model === "string" ? { model: r2.model } : {}
@@ -139691,6 +139829,14 @@ function readRoster(path62, maxAgents) {
 function slug(s2) {
   return s2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
 }
+function cleanRole(raw) {
+  if (typeof raw !== "string")
+    return "implementer";
+  const r2 = raw.toLowerCase().replace(/[^a-z0-9 -]/g, "").replace(/\s+/g, " ").trim().slice(0, 24);
+  if (!r2 || r2 === ARCHITECT_AGENT_ID)
+    return "implementer";
+  return r2;
+}
 function statusOf(hub, id) {
   return hub.state.rosterView().agents.find((a2) => a2.id === id)?.status;
 }
@@ -139813,7 +139959,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.
@@ -139827,21 +139977,22 @@ The team coordinates through a shared hub (use these tools):
 
 Cooperation rules:
 - Build strictly to the shared contracts. If you must change a shared boundary, use collab_contract_propose_change and wait for acks \u2014 never break a contract unilaterally.
-- The human may step in at any time: honor any directive you receive (it overrides your current plan), and if the team is paused, finish your current edit and wait.
+- The human may step in at any time. When you receive a HUMAN directive or a message from "human", treat it as authoritative (it overrides your current plan), and REPLY to them with collab_send to "human" \u2014 acknowledge it and say what you'll do (or ask a brief clarifying question). Don't go silent on the human. If the team is paused, finish your current edit and wait.
 - Keep teammates informed: broadcast meaningful progress and blockers.
 - 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 a TEAM MEMBER with a specific role (given below) and sub-task. Work as that role \u2014 a writer writes, a designer designs, a developer builds, a QA reviews, a PM sequences + verifies. 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, deliver your part 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.
-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).
+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. Assemble the RIGHT TEAM for THIS deliverable and decompose into INDEPENDENT sub-tasks with DISJOINT ownership (minimize overlap). Pick the roles the work actually needs \u2014 a coding task wants developers + a QA reviewer; a document/plan/design deliverable wants a writer, a researcher, a designer, an editor; a product effort may want a PM to sequence + verify. Don't default everyone to a generic "implementer".
+3. Define the shared CONTRACTS \u2014 the interfaces, types, API shapes, section outlines, or boundaries where the team's work meets. Publish each with collab_contract_publish (give an owner + consumers).
 4. Write two files into the repo:
-   - ${COLLAB_SCAFFOLD_DIR}/${CONTRACTS_FILENAME} \u2014 human-readable contracts/boundaries the implementers must follow.
-   - ${COLLAB_SCAFFOLD_DIR}/${ROSTER_FILENAME} \u2014 a JSON array proposing the implementer roster. Each entry: { "id": "kebab-slug", "name": "Role Name", "role": "implementer", "subtask": "what this agent builds", "ownedPaths": ["dir/", "file.ts"] }. Do NOT include yourself.
+   - ${COLLAB_SCAFFOLD_DIR}/${CONTRACTS_FILENAME} \u2014 human-readable contracts/boundaries the team must follow.
+   - ${COLLAB_SCAFFOLD_DIR}/${ROSTER_FILENAME} \u2014 a JSON array proposing the team. Each entry: { "id": "kebab-slug", "name": "Display Name", "role": "<function>", "subtask": "what this agent delivers", "ownedPaths": ["dir/", "file.md"] }. "role" is the agent's FUNCTION \u2014 e.g. "developer", "designer", "pm", "qa", "writer", "researcher", "editor" \u2014 choose what fits. Do NOT include yourself, and do NOT use "architect" (that's you).
 5. Broadcast a short kickoff summary, then call collab_done.
 
 After the implementers start, you stay available as the BROKER: answer interface questions, and when an implementer proposes a contract change, review it and (if sound) commit it with collab_contract_update so everyone re-syncs.`;
@@ -149515,13 +149666,13 @@ async function runWorkflow(workflow, deps, opts = {}) {
   const startedAt = (deps.now ?? Date.now)();
   const result = await executor.run(workflow, deps);
   if (opts.recordDir !== null) {
-    await writeRunRecord(workflow, result, startedAt, executor.name, deps, opts.recordDir ?? defaultRunRecordDir()).catch((err) => deps.logger?.warn?.("workflow: failed to write run record", {
+    await writeRunRecord2(workflow, result, startedAt, executor.name, deps, opts.recordDir ?? defaultRunRecordDir()).catch((err) => deps.logger?.warn?.("workflow: failed to write run record", {
       error: err instanceof Error ? err.message : String(err)
     }));
   }
   return result;
 }
-async function writeRunRecord(workflow, result, startedAt, executorName, deps, dir) {
+async function writeRunRecord2(workflow, result, startedAt, executorName, deps, dir) {
   await promises.mkdir(dir, { recursive: true });
   const stamp = new Date(startedAt).toISOString().replace(/[:.]/g, "-");
   const file = path3.join(dir, `${stamp}-${workflow.name}-${ulid().slice(-6)}.jsonl`);
@@ -153902,11 +154053,11 @@ function servicePlatform() {
   if (process.platform === "linux") return "linux";
   return "unsupported";
 }
-function moxxyHome2() {
+function moxxyHome3() {
   return process.env.MOXXY_HOME ?? path3__default.join(homedir(), ".moxxy");
 }
 function serviceLogPath(spec) {
-  return path3__default.join(moxxyHome2(), "services", `${spec.id}.log`);
+  return path3__default.join(moxxyHome3(), "services", `${spec.id}.log`);
 }
 function nodeBin() {
   return process.execPath;
@@ -155948,7 +156099,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,
@@ -155970,7 +156124,7 @@ 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 {
@@ -155987,6 +156141,22 @@ async function runAgentCommand(argv) {
   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;
+  }
+  const roleLine = role && role !== "implementer" ? `Your role on the team: ${role}.
+` : "";
+  return `${roleLine}Overall team goal: ${parentTask}
+
+Your sub-task: ${subtask}
+
+${pointer}`;
+}
 async function runUntilSignal2(runnerServer, session, turnDone) {
   let stopping = false;
   const shutdown = async (signal) => {