@moxxy/cli 0.14.7 → 0.14.8

package/dist/bin.js

@@ -139109,7 +139109,7 @@ function resolveCollabConfig(persisted, overrides) {
   return {
     ...DEFAULT_COLLAB_CONFIG,
     ...stripUndefined(fromPrefs),
-    ...stripUndefined({})
+    ...stripUndefined(overrides ?? {})
   };
 }
 function stripUndefined(obj) {
@@ -139292,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();
 }
@@ -139397,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 {
@@ -139636,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()) {
@@ -139662,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;
     }
@@ -139686,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) => {
@@ -139701,7 +139731,7 @@ 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 {
       const events = ctx.log.slice();
       mkdirSync(join(cwd2, COLLAB_SCAFFOLD_DIR), { recursive: true });
@@ -139766,13 +139796,13 @@ ${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);
@@ -139787,6 +139817,24 @@ ${why}` : ""}`));
       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);
+      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 {
       for (const entry of roster) {
         if (ctx.signal.aborted)
@@ -139808,7 +139856,7 @@ ${why}` : ""}`));
       return;
     }
     let mergeNote = "";
-    if (parallel && doneIds.length > 0) {
+    if (usesGit && doneIds.length > 0) {
       const result = await integrate({
         repoCwd: cwd2,
         runId,
@@ -139832,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 {
@@ -139951,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";
@@ -140108,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.`;
@@ -140125,7 +140181,7 @@ 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 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.
@@ -156299,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` (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.";
+  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}