@moxxy/cli 0.14.5 → 0.14.7

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, writeFileSync, rmSync, statSync, readdirSync, readFileSync, unlinkSync, chmodSync, watch, createReadStream } from 'fs';
+import fs32__default, { existsSync, promises, readFileSync, ReadStream, mkdirSync, writeFileSync, rmSync, statSync, readdirSync, 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';
@@ -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;
@@ -136052,6 +136060,7 @@ var COLLAB_SCAFFOLD_DIR = ".moxxy-collab";
 var CONTRACTS_FILENAME = "CONTRACTS.md";
 var ROSTER_FILENAME = "roster.json";
 var BRIEF_FILENAME = "BRIEF.md";
+var CONVERSATION_FILENAME = "CONVERSATION.md";
 function collabRunId(sessionId, turnId) {
   const tail = (s2) => s2.replace(/[^a-zA-Z0-9]/g, "").slice(-6) || "x";
   return `${tail(sessionId)}-${tail(turnId)}`;
@@ -136065,6 +136074,9 @@ function hubSocketPath(runId) {
 function peerSocketPath(runId, agentId) {
   return join(collabRunDir(runId), `p-${agentId}.sock`);
 }
+function charterFilePath(runId, agentId) {
+  return join(collabRunDir(runId), `charter-${agentId}.md`);
+}
 function worktreeRoot(runId) {
   return join(tmpdir(), "moxxy-collab", runId);
 }
@@ -138242,7 +138254,9 @@ var COLLAB_ENV = {
   Role: "MOXXY_COLLAB_ROLE",
   Subtask: "MOXXY_COLLAB_SUBTASK",
   ParentTask: "MOXXY_COLLAB_PARENT_TASK",
-  RunnerSocket: "MOXXY_RUNNER_SOCKET"
+  RunnerSocket: "MOXXY_RUNNER_SOCKET",
+  /** Path (never the body) of this agent's architect-authored role charter. */
+  CharterFile: "MOXXY_COLLAB_CHARTER_FILE"
 };
 var clientPromise = null;
 function getProcessHubClient() {
@@ -139103,6 +139117,9 @@ function stripUndefined(obj) {
 }
 var MAX_MSG_CHARS = 600;
 var MAX_TOTAL_CHARS = 6e3;
+var CONVERSATION_MSG_CHARS = 1200;
+var CONVERSATION_TOTAL_CHARS = 48e3;
+var SUMMARY_GUARD_CHARS = 4e3;
 function clip(s2, n2) {
   const t2 = s2.trim().replace(/\s+/g, " ");
   return t2.length > n2 ? `${t2.slice(0, n2 - 1)}\u2026` : t2;
@@ -139119,35 +139136,141 @@ function digestTurns(events) {
   }
   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);
+function withoutGoalTail(turns, task) {
+  const last = turns[turns.length - 1];
+  return turns.length > 0 && last.role === "user" && last.text.trim() === task.trim() ? turns.slice(0, -1) : turns;
+}
+function buildBrief(task, summary) {
   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.",
+    "This is the team's shared brief \u2014 the goal and the key requirements,",
+    "constraints, and decisions distilled from the user's conversation. The full",
+    "transcript is NOT in your context; if you need a specific detail this summary",
+    "omits, read or grep `.moxxy-collab/CONVERSATION.md` (do not load it wholesale).",
+    "",
+    "## Goal",
+    "",
+    clip(task, 1500) || "(no goal text)",
+    "",
+    "## Summary",
+    "",
+    clip(summary, SUMMARY_GUARD_CHARS) || "(no summary available)"
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function heuristicSummary(task, events) {
+  const recent = withoutGoalTail(digestTurns(events), task).slice(-12);
+  if (recent.length === 0)
+    return "(no prior conversation to summarize)";
+  const lines = ["(heuristic summary \u2014 LLM summarizer unavailable; recent turns:)"];
+  for (const t2 of recent) {
+    lines.push(`- **${t2.role === "user" ? "User" : "Assistant"}:** ${clip(t2.text, MAX_MSG_CHARS)}`);
+  }
+  let body = lines.join("\n");
+  if (body.length > MAX_TOTAL_CHARS)
+    body = `${body.slice(0, MAX_TOTAL_CHARS - 1)}\u2026`;
+  return body;
+}
+function buildConversation(task, events) {
+  const turns = digestTurns(events);
+  const lines = [
+    "# Full conversation (recall-only)",
+    "",
+    "Not loaded into any agent by default. Read or grep this only when you need a",
+    "specific detail the brief summary omits.",
     "",
     "## Goal",
     "",
-    clip(task, 1500) || "(no goal text)"
+    clip(task, 1500) || "(no goal text)",
+    "",
+    "## Conversation",
+    ""
   ];
-  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)}`);
+  if (turns.length === 0) {
+    lines.push("(no prior conversation)");
+  } else {
+    for (const t2 of turns) {
+      lines.push(`- **${t2.role === "user" ? "User" : "Assistant"}:** ${clip(t2.text, CONVERSATION_MSG_CHARS)}`);
     }
   }
-  let brief = lines.join("\n");
-  if (brief.length > MAX_TOTAL_CHARS) {
-    brief = `${brief.slice(0, MAX_TOTAL_CHARS - 1)}\u2026`;
-  }
-  return `${brief}
+  let body = lines.join("\n");
+  if (body.length > CONVERSATION_TOTAL_CHARS)
+    body = `${body.slice(0, CONVERSATION_TOTAL_CHARS - 1)}\u2026`;
+  return `${body}
 `;
 }
+
+// ../mode-collaborative/dist/summarize.js
+var MAX_SUMMARIZE_INPUT_CHARS = 48e3;
+var SUMMARY_MAX_TOKENS = 700;
+var COLLAB_SUMMARY_SYSTEM = `You write a SHORT shared brief for a team of AI agents about to build ONE deliverable together. From the user's conversation, extract ONLY:
+1. The overall goal, in one or two sentences.
+2. The concrete requirements and constraints.
+3. Any decisions already made, and the reason.
+4. Explicit do-nots / out-of-scope.
+Use terse bullet points. Do NOT restate the raw conversation, do NOT invent details, omit chit-chat and pleasantries. Output ONLY the brief text \u2014 no preamble, no sign-off. Keep it well under 400 words.`;
+async function summarizeConversation(args) {
+  const { task, events, provider, model, signal } = args;
+  if (!provider || !model)
+    return null;
+  const turns = digestTurns(events);
+  if (turns.length === 0)
+    return null;
+  const joined = turns.map((t2) => `[${t2.role}] ${t2.text}`).join("\n");
+  const input = joined.length > MAX_SUMMARIZE_INPUT_CHARS ? `${joined.slice(0, MAX_SUMMARIZE_INPUT_CHARS / 2)}
+[... transcript truncated ...]
+${joined.slice(-MAX_SUMMARIZE_INPUT_CHARS / 2)}` : joined;
+  try {
+    let out = "";
+    for await (const event of provider.stream({
+      model,
+      system: COLLAB_SUMMARY_SYSTEM,
+      messages: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: `Task headline: ${task}
+
+The user's conversation that produced this task:
+
+${input}`
+            }
+          ]
+        }
+      ],
+      maxTokens: SUMMARY_MAX_TOKENS,
+      ...signal ? { signal } : {}
+    })) {
+      if (event.type === "text_delta")
+        out += event.delta;
+      if (event.type === "error")
+        return null;
+    }
+    const trimmed = out.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  } catch {
+    return null;
+  }
+}
+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) => {
@@ -139297,6 +139420,7 @@ var PeerSupervisor = class {
       [COLLAB_ENV.Subtask]: args.entry.subtask,
       [COLLAB_ENV.ParentTask]: this.opts.parentTask,
       [COLLAB_ENV.RunnerSocket]: socket,
+      ...args.charterFile ? { [COLLAB_ENV.CharterFile]: args.charterFile } : {},
       MOXXY_SESSION_ID: `${this.opts.coordinatorSessionId}::${args.entry.id}`,
       MOXXY_MODE: args.mode
     };
@@ -139526,14 +139650,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"
@@ -139571,9 +139703,24 @@ 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 {
+      const events = ctx.log.slice();
       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) }));
+      writeFileSync(join(cwd2, COLLAB_SCAFFOLD_DIR, CONVERSATION_FILENAME), buildConversation(task, events));
+      const llmSummary = await summarizeConversation({
+        task,
+        events,
+        provider: ctx.provider,
+        model: ctx.model,
+        signal: ctx.signal
+      }).catch(() => null);
+      const summary = llmSummary ?? heuristicSummary(task, events);
+      briefText = buildBrief(task, summary);
+      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),
+        conversationPath: join(COLLAB_SCAFFOLD_DIR, CONVERSATION_FILENAME),
+        summarized: Boolean(llmSummary)
+      }));
     } catch {
     }
     supervisor.spawn({ entry: architectEntry, cwd: cwd2, mode: COLLAB_ARCHITECT_MODE_NAME });
@@ -139600,8 +139747,12 @@ ${why}` : ""}`));
     if (cfg.requireRosterApproval && ctx.approval) {
       const decision = await ctx.approval.confirm({
         title: `Team of ${roster.length} agent${roster.length === 1 ? "" : "s"} \u2014 review before launch`,
-        body: roster.map((r2, i2) => `${i2 + 1}. [${r2.id}] ${r2.name} \u2014 ${r2.role}
-    ${r2.subtask}`).join("\n\n"),
+        body: roster.map((r2, i2) => {
+          const charterLine = r2.charter ? `
+    charter: ${r2.charter.replace(/\s+/g, " ").slice(0, 140)}${r2.charter.length > 140 ? "\u2026" : ""}` : "";
+          return `${i2 + 1}. [${r2.id}] ${r2.name} \u2014 ${r2.role}
+    ${r2.subtask}${charterLine}`;
+        }).join("\n\n"),
         kind: "collab.roster",
         defaultOptionId: "launch",
         options: [
@@ -139627,7 +139778,8 @@ ${why}` : ""}`));
         const wt3 = worktreePath(runId, entry.id);
         await addWorktree({ repoCwd: cwd2, path: wt3, branch: collabBranch(runId, entry.id), baseSha });
         worktrees.set(entry.id, wt3);
-        supervisor.spawn({ entry, cwd: wt3, mode: COLLAB_PEER_MODE_NAME });
+        const charterFile = writeCharterFile(runId, entry);
+        supervisor.spawn({ entry, cwd: wt3, mode: COLLAB_PEER_MODE_NAME, ...charterFile ? { charterFile } : {} });
         yield await ctx.emit(plugin4(ctx, "collab_agent_spawned", { id: entry.id, role: entry.role }));
       }
       await waitForAgents(hub, supervisor, roster.map((r2) => r2.id), ctx.signal, cfg.wallClockMs);
@@ -139640,7 +139792,8 @@ ${why}` : ""}`));
         if (ctx.signal.aborted)
           break;
         hub.state.addAgent(entry);
-        supervisor.spawn({ entry, cwd: cwd2, mode: COLLAB_PEER_MODE_NAME });
+        const charterFile = writeCharterFile(runId, entry);
+        supervisor.spawn({ entry, cwd: cwd2, mode: COLLAB_PEER_MODE_NAME, ...charterFile ? { charterFile } : {} });
         yield await ctx.emit(plugin4(ctx, "collab_agent_spawned", { id: entry.id, role: entry.role }));
         const ok = await waitForAgent(hub, supervisor, entry.id, ctx.signal, cfg.wallClockMs);
         if (!ok)
@@ -139665,6 +139818,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));
@@ -139678,10 +139837,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));
@@ -139729,10 +139932,13 @@ 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 } : {}
+        ...typeof r2.model === "string" ? { model: r2.model } : {},
+        ...typeof r2.charter === "string" && r2.charter.trim() ? { charter: cleanCharter(r2.charter) } : {}
       });
       if (out.length >= maxAgents)
         break;
@@ -139745,6 +139951,29 @@ 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 cleanCharter(raw) {
+  return raw.replace(/\u0000/g, "").trim().slice(0, 2e3);
+}
+function writeCharterFile(runId, entry) {
+  if (!entry.charter)
+    return void 0;
+  const p3 = charterFilePath(runId, entry.id);
+  try {
+    writeFileSync(p3, `${entry.charter}
+`);
+    return p3;
+  } catch {
+    return void 0;
+  }
+}
 function statusOf(hub, id) {
   return hub.state.rosterView().agents.find((a2) => a2.id === id)?.status;
 }
@@ -139870,7 +140099,7 @@ function emitAbort(ctx, reason) {
 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.
+- ${COLLAB_SCAFFOLD_DIR}/${BRIEF_FILENAME} is the shared brief \u2014 a concise summary of the user's goal and the key requirements/constraints/decisions. Read it FIRST so your work serves the real goal, not just the literal words of your sub-task. The full conversation is NOT in your context; if you need a specific detail the brief omits, read or grep ${COLLAB_SCAFFOLD_DIR}/${CONVERSATION_FILENAME} \u2014 do NOT load it wholesale.
 - 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):
@@ -139885,25 +140114,34 @@ 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}/${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.`;
+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:
-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.
+0. Read ${COLLAB_SCAFFOLD_DIR}/${BRIEF_FILENAME} \u2014 the goal + key-requirements summary \u2014 so you decompose toward what the user actually wants. If you need a detail it omits, grep ${COLLAB_SCAFFOLD_DIR}/${CONVERSATION_FILENAME}.
 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).
+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"], "charter": "..." }. "role" is the agent's FUNCTION \u2014 e.g. "developer", "designer", "pm", "qa", "writer", "researcher", "editor" \u2014 choose what fits. For EACH agent write a tailored "charter": a short system-prompt-style brief (roughly 4-8 sentences, plain prose in the second person \u2014 "You are \u2026", no markdown headings) giving THIS agent, for THIS task: (a) its persona/expertise, (b) its concrete responsibilities and scope, (c) the quality bar it must hit, (d) how it works with the rest of the team, (e) its definition of done. Make each charter specific to the deliverable \u2014 this is how you create proper, task-suited roles instead of generic workers. 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.`;
+function peerPromptWithCharter(charter) {
+  if (!charter || !charter.trim())
+    return COLLAB_PEER_PROMPT;
+  return `${COLLAB_PEER_PROMPT}
+
+## Your charter
+
+${charter.trim()}`;
+}
 var COLLAB_DONE_TOOL = "collab_done";
 var DEFAULT_MAX_ITERATIONS = 60;
 var MAX_NOOP_ITERATIONS = 3;
@@ -140169,11 +140407,21 @@ var collabArchitectMode = defineMode({
   badge: { label: "ARCHITECT", tone: "attention" },
   run: (ctx) => runCollabAgentLoop(ctx, { systemPrompt: COLLAB_ARCHITECT_PROMPT })
 });
+function peerSystemPrompt(env3) {
+  const path62 = env3[COLLAB_ENV.CharterFile]?.trim();
+  if (!path62)
+    return COLLAB_PEER_PROMPT;
+  try {
+    return peerPromptWithCharter(readFileSync(path62, "utf8"));
+  } catch {
+    return COLLAB_PEER_PROMPT;
+  }
+}
 var collabPeerMode = defineMode({
   name: COLLAB_PEER_MODE_NAME,
-  description: "Collaboration peer (internal): an implementer building to the shared contracts.",
+  description: "Collaboration peer (internal): a team member building to the shared contracts.",
   badge: { label: "TEAM", tone: "attention" },
-  run: (ctx) => runCollabAgentLoop(ctx, { systemPrompt: COLLAB_PEER_PROMPT })
+  run: (ctx) => runCollabAgentLoop(ctx, { systemPrompt: peerSystemPrompt(ctx.env) })
 });
 
 // ../mode-collaborative/dist/index.js
@@ -140188,8 +140436,8 @@ var collaborativeModePlugin = definePlugin({
   version: "0.0.0",
   modes: [collaborativeMode, collabArchitectMode, collabPeerMode]
 });
-var MAX_SUMMARIZE_INPUT_CHARS = 48e3;
-var SUMMARY_MAX_TOKENS = 1024;
+var MAX_SUMMARIZE_INPUT_CHARS2 = 48e3;
+var SUMMARY_MAX_TOKENS2 = 1024;
 var FALLBACK_DIGEST_CHARS = 6e3;
 var SUMMARY_SYSTEM_PROMPT = "You compress conversation history for an AI agent so it can keep working with less context. You are given a line-per-event digest of earlier turns. Write a dense, factual brief the agent can rely on: the task and its current state, key decisions and their reasons, important file paths / identifiers / values, tool outcomes (including failures), and any unresolved questions or TODOs. Do not editorialize, do not invent details, output ONLY the summary text.";
 function createSummarizeCompactor(opts = {}) {
@@ -140256,9 +140504,9 @@ async function providerSummary(text, ctx) {
   const model = ctx.model ?? provider.models[0]?.id;
   if (!model)
     return null;
-  const input = text.length > MAX_SUMMARIZE_INPUT_CHARS ? `${text.slice(0, MAX_SUMMARIZE_INPUT_CHARS / 2)}
+  const input = text.length > MAX_SUMMARIZE_INPUT_CHARS2 ? `${text.slice(0, MAX_SUMMARIZE_INPUT_CHARS2 / 2)}
 [... digest truncated ...]
-${text.slice(-MAX_SUMMARIZE_INPUT_CHARS / 2)}` : text;
+${text.slice(-MAX_SUMMARIZE_INPUT_CHARS2 / 2)}` : text;
   try {
     let out = "";
     for await (const event of provider.stream({
@@ -140272,7 +140520,7 @@ ${text.slice(-MAX_SUMMARIZE_INPUT_CHARS / 2)}` : text;
 ${input}` }]
         }
       ],
-      maxTokens: SUMMARY_MAX_TOKENS,
+      maxTokens: SUMMARY_MAX_TOKENS2,
       ...ctx.signal ? { signal: ctx.signal } : {}
     })) {
       if (event.type === "text_delta")
@@ -149574,13 +149822,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`);
@@ -153961,11 +154209,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;
@@ -156051,13 +156299,15 @@ async function runAgentCommand(argv) {
 }
 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.";
+  const pointer = "Shared team context is in `.moxxy-collab/BRIEF.md` (a concise summary of the user's goal + key requirements) and `.moxxy-collab/CONTRACTS.md` (the agreed interfaces). Read them before you start so your work fits the real goal. If you need a detail the brief omits, read or grep `.moxxy-collab/CONVERSATION.md` (the full transcript) \u2014 do not load it wholesale.";
   if (role === "architect" || !parentTask || parentTask === subtask) {
     return subtask ? `${subtask}
 
 ${pointer}` : pointer;
   }
-  return `Overall team goal: ${parentTask}
+  const roleLine = role && role !== "implementer" ? `Your role on the team: ${role}.
+` : "";
+  return `${roleLine}Overall team goal: ${parentTask}
 
 Your sub-task: ${subtask}