@moxxy/cli 0.14.5 → 0.14.6

package/dist/bin.js

@@ -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;
@@ -139148,6 +139156,21 @@ function buildBrief(task, events) {
   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) => {
@@ -139526,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"
@@ -139571,8 +139602,9 @@ 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), buildBrief(task, ctx.log.slice()));
+      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 {
     }
@@ -139665,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));
@@ -139678,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));
@@ -139729,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 } : {}
@@ -139745,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;
 }
@@ -139885,22 +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}/${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.
 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"] }. "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.`;
@@ -149574,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`);
@@ -153961,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;
@@ -156057,7 +156149,9 @@ function buildSeedTurn(args) {
 
 ${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}