@moxxy/cli 0.14.6 → 0.14.8

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';
@@ -136060,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)}`;
@@ -136073,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);
 }
@@ -138250,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,7 +139109,7 @@ function resolveCollabConfig(persisted, overrides) {
   return {
     ...DEFAULT_COLLAB_CONFIG,
     ...stripUndefined(fromPrefs),
-    ...stripUndefined({})
+    ...stripUndefined(overrides ?? {})
   };
 }
 function stripUndefined(obj) {
@@ -139111,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;
@@ -139127,35 +139136,126 @@ 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");
 }
@@ -139192,6 +139292,16 @@ async function detectGit(cwd2) {
   const repo = installed ? await isGitRepo(cwd2) : false;
   return { installed, repo };
 }
+async function tryInitGitRepo(cwd2) {
+  let r2 = await git(cwd2, ["init", "-b", "main"]);
+  if (r2.code !== 0)
+    r2 = await git(cwd2, ["init"]);
+  if (r2.code !== 0 || !await isGitRepo(cwd2))
+    return false;
+  await git(cwd2, ["add", "-A"]);
+  const c2 = await git(cwd2, [...IDENTITY, "commit", "--allow-empty", "-m", "moxxy-collab: initial snapshot", "--no-verify"]);
+  return c2.code === 0 && (await headSha(cwd2)).length > 0;
+}
 async function headSha(cwd2) {
   return (await git(cwd2, ["rev-parse", "HEAD"])).stdout.trim();
 }
@@ -139297,6 +139407,19 @@ function peerReaderFor(worktrees, baseSha) {
     }
   };
 }
+function cwdPeerReader(cwd2) {
+  return {
+    async files() {
+      return await isGitRepo(cwd2) ? changedFiles(cwd2) : [];
+    },
+    async read(_agentId, path62) {
+      return readFile(resolveWithin(cwd2, path62), "utf8");
+    },
+    async diff() {
+      return "";
+    }
+  };
+}
 var FORCE_KILL_GRACE_MS = 4e3;
 var STDERR_RING = 40;
 var PeerSupervisor = class {
@@ -139320,6 +139443,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
     };
@@ -139535,7 +139659,7 @@ async function* runCollaborative(ctx, deps) {
     yield await ctx.emit(emitAbort(ctx, "aborted before collaboration start"));
     return;
   }
-  const cfg = deps.config ?? resolveCollabConfig();
+  const cfg = deps.config ?? resolveCollabConfig(void 0, deps.concurrencyOverride ? { concurrency: deps.concurrencyOverride } : void 0);
   const cwd2 = deps.cwd ?? process.cwd();
   const task = lastUserPromptText(ctx) ?? "";
   if (!task.trim()) {
@@ -139561,17 +139685,22 @@ async function* runCollaborative(ctx, deps) {
   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;
+    const { installed: gitInstalled2, repo: alreadyGitRepo } = await (deps.detectGit ?? detectGit)(cwd2);
+    let gitRepo = alreadyGitRepo;
+    if (!gitRepo && gitInstalled2 && cfg.concurrency !== "sequential") {
+      gitRepo = await tryInitGitRepo(cwd2).catch(() => false);
+    }
+    const execMode = resolveExecMode(cfg, gitRepo);
+    const usesGit = execMode === "git-parallel";
+    const runsParallel = execMode !== "sequential";
+    archiveParallel = runsParallel;
     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"
-      }));
+    yield await ctx.emit(plugin4(ctx, "collab_exec_mode", { mode: execMode, gitInstalled: gitInstalled2, gitRepo }));
+    if (execMode === "sequential") {
+      yield await ctx.emit(plugin4(ctx, "collab_fallback_sequential", { reason: "sequential mode \u2014 one agent at a time" }));
     }
     let baseSha = "";
-    if (parallel) {
+    if (usesGit) {
       const base2 = await resolveBase(cwd2, { snapshotDirty: true });
       baseSha = base2.baseSha;
     }
@@ -139585,7 +139714,9 @@ async function* runCollaborative(ctx, deps) {
       socketPath: hubSocketPath(runId),
       task,
       roster: [architectEntry],
-      peerReader: peerReaderFor(worktrees, baseSha)
+      // git: read each agent's worktree. non-git: every agent shares one tree, so
+      // peer-read is just "read the live shared workspace".
+      peerReader: usesGit ? peerReaderFor(worktrees, baseSha) : cwdPeerReader(cwd2)
     });
     registerActiveHub(String(ctx.sessionId), hub);
     unsubscribe = hub.subscribe((e3) => {
@@ -139600,12 +139731,26 @@ async function* runCollaborative(ctx, deps) {
       signal: ctx.signal
     };
     supervisor = (deps.createSupervisor ?? ((o2) => new PeerSupervisor(o2)))(supervisorOpts, hub);
-    yield await ctx.emit(plugin4(ctx, "collab_started", { task, parallel, gitInstalled: gitInstalled2, gitRepo }));
+    yield await ctx.emit(plugin4(ctx, "collab_started", { task, parallel: runsParallel, execMode, gitInstalled: gitInstalled2, gitRepo }));
     try {
-      briefText = buildBrief(task, ctx.log.slice());
+      const events = ctx.log.slice();
       mkdirSync(join(cwd2, COLLAB_SCAFFOLD_DIR), { recursive: true });
+      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) }));
+      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 });
@@ -139632,8 +139777,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: [
@@ -139647,19 +139796,38 @@ ${why}` : ""}`));
       }
     }
     yield await ctx.emit(plugin4(ctx, "collab_roster_confirmed", { roster }));
-    if (parallel) {
+    if (usesGit) {
       await commitAll(cwd2, "moxxy-collab: scaffold contracts");
       baseSha = await headSha(cwd2);
       mkdirSync(worktreeRoot(runId), { recursive: true });
     }
     const doneIds = [];
-    if (parallel) {
+    if (execMode === "git-parallel") {
       for (const entry of roster) {
         hub.state.addAgent(entry);
         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);
+      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);
+    } else if (execMode === "cwd-parallel") {
+      for (const entry of roster) {
+        hub.state.addAgent(entry);
+        if (entry.ownedPaths?.length) {
+          const res = hub.state.boardClaim(entry.id, entry.ownedPaths);
+          if (!res.ok) {
+            yield await ctx.emit(plugin4(ctx, "collab_ownership_overlap", { id: entry.id, paths: entry.ownedPaths, ownedBy: res.ownedBy }));
+          }
+        }
+        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 }));
       }
       await waitForAgents(hub, supervisor, roster.map((r2) => r2.id), ctx.signal, cfg.wallClockMs);
@@ -139672,7 +139840,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)
@@ -139687,7 +139856,7 @@ ${why}` : ""}`));
       return;
     }
     let mergeNote = "";
-    if (parallel && doneIds.length > 0) {
+    if (usesGit && doneIds.length > 0) {
       const result = await integrate({
         repoCwd: cwd2,
         runId,
@@ -139711,11 +139880,13 @@ ${why}` : ""}`));
     }
     const summaries = hub.state.doneSummaries();
     const summaryBlock = summaries.length ? summaries.map((s2) => `- **${s2.agentId}**: ${s2.summary}`).join("\n") : "(no agent reported a completion summary)";
+    const cwdNote = execMode === "cwd-parallel" ? "The team worked together directly in your workspace; please review the result." : "";
+    const tail = [mergeNote, cwdNote].filter(Boolean).join("\n\n");
     yield await ctx.emit(assistant(ctx, `Collaboration complete \u2014 ${doneIds.length}/${roster.length} agents finished.
 
-${summaryBlock}${mergeNote ? `
+${summaryBlock}${tail ? `
 
-${mergeNote}` : ""}`));
+${tail}` : ""}`));
     completed = true;
     yield await ctx.emit(plugin4(ctx, "collab_completed", { done: doneIds, total: roster.length }));
   } finally {
@@ -139816,7 +139987,8 @@ function readRoster(path62, maxAgents) {
         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;
@@ -139829,6 +140001,11 @@ function readRoster(path62, maxAgents) {
 function slug(s2) {
   return s2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
 }
+function resolveExecMode(cfg, gitRepo) {
+  if (cfg.concurrency === "sequential")
+    return "sequential";
+  return gitRepo ? "git-parallel" : "cwd-parallel";
+}
 function cleanRole(raw) {
   if (typeof raw !== "string")
     return "implementer";
@@ -139837,6 +140014,21 @@ function cleanRole(raw) {
     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;
 }
@@ -139962,7 +140154,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):
@@ -139971,12 +140163,13 @@ The team coordinates through a shared hub (use these tools):
 - collab_send / collab_broadcast \u2014 message a teammate by id, or the whole team.
 - collab_board / collab_add_task / collab_update \u2014 the shared task board (what's done / in progress / blocked).
 - collab_contracts \u2014 the agreed interfaces/boundaries you must build to.
-- collab_claim(paths) \u2014 claim files BEFORE editing them. If the claim is rejected, another agent owns them: message that owner and coordinate; do NOT edit files you don't own.
-- collab_release \u2014 release a claim when you're done with those files.
-- collab_peer_read / collab_peer_files / collab_peer_diff \u2014 read a teammate's ACTUAL in-progress work (get their real interface instead of guessing).
+- collab_claim(paths) \u2014 you may SHARE ONE LIVE WORKSPACE with the other agents (no isolation), so you MUST collab_claim a file BEFORE every edit and only edit files you currently own. If a claim is REJECTED another agent owns it: collab_send that owner, agree who edits, and do NOT touch it until you own it. Claim the NARROWEST set you need (single files, not whole dirs) so you don't block teammates. If you RENAME or MOVE a file, claim BOTH the old and the new path first.
+- collab_release \u2014 release a claim the moment you finish a file so others can proceed.
+- collab_peer_read / collab_peer_files / collab_peer_diff \u2014 read a teammate's ACTUAL in-progress work (get their real interface instead of guessing). Only rely on work a teammate has said is done \u2014 a file may be mid-write.
 
 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.
+- Shared/aggregator files (package.json, a lockfile, a barrel index, a shared types file) have ONE owner \u2014 never edit one you don't own; ask its owner via collab_send to make the change for you.
 - 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.`;
@@ -139986,16 +140179,25 @@ You are a TEAM MEMBER with a specific role (given below) and sub-task. Work as t
 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. 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".
+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". The team may run together in ONE shared workspace with only advisory file locks, so ownedPaths MUST be DISJOINT \u2014 give each agent its own specific files/leaf dirs with NO overlap. If two roles would both need one shared file (a router, a barrel index, package.json), give it to ONE owner and have the other coordinate via collab_send or a contract; never assign the same path to two agents. Every roster entry MUST declare ownedPaths.
 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 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).
+   - ${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;
@@ -140261,11 +140463,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
@@ -140280,8 +140492,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 = {}) {
@@ -140348,9 +140560,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({
@@ -140364,7 +140576,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")
@@ -156143,7 +156355,7 @@ 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. You may share ONE live workspace with the other agents (no isolation) \u2014 collab_claim before every edit, edit only what you own, and release when done.";
   if (role === "architect" || !parentTask || parentTask === subtask) {
     return subtask ? `${subtask}