taskplane 0.5.7 → 0.5.9

package/extensions/taskplane/engine.ts

@@ -2,8 +2,8 @@
  * Main batch execution engine
  * @module orch/engine
  */
-import { existsSync, readFileSync, readdirSync, unlinkSync } from "fs";
-import { dirname, join, resolve } from "path";
+import { readFileSync, readdirSync, unlinkSync } from "fs";
+import { join, resolve } from "path";
 
 import { formatDiscoveryResults, runDiscovery } from "./discovery.ts";
 import { execLog, executeWave, tmuxKillSession } from "./execution.ts";
@@ -364,16 +364,6 @@ export async function executeOrchBatch(
 			}
 		}
 
-		// ── Workspace mode: commit task artifacts to task-area repos ─
-		// In workspace mode, workers write .DONE and STATUS.md to the
-		// canonical task folder (e.g., shared-libs/task-management/...) via
-		// absolute paths, not to the lane worktree. These changes land as
-		// uncommitted modifications in the task-area repo's working tree.
-		// Commit them before the merge step so they appear in the orch branch.
-		if (workspaceConfig && waveResult.succeededTaskIds.length > 0) {
-			commitWorkspaceTaskArtifacts(discoveryRef, workspaceRoot ?? repoRoot, waveIdx + 1, batchState.batchId);
-		}
-
 		// ── Wave Merge ───────────────────────────────────────────
 		// Only merge if there are succeeded tasks in this wave
 		let mergeResult: MergeWaveResult | null = null;
@@ -882,78 +872,5 @@ export async function executeOrchBatch(
 }
 
 
-// ── Workspace Task Artifact Commit ───────────────────────────────────
-
-/**
- * In workspace mode, commit task artifacts (.DONE, STATUS.md) that workers
- * wrote to the canonical task folder in the task-area repo.
- *
- * Workers write to absolute paths (e.g., shared-libs/task-management/.../TP-002/.DONE)
- * which land as uncommitted changes in the task-area repo's working tree.
- * This function finds all task-area repos with dirty task files and commits them
- * so they appear in the lane branches and merge correctly.
- *
- * Best-effort: failures are logged but don't block the batch.
- */
-function commitWorkspaceTaskArtifacts(
-	discovery: DiscoveryResult | null,
-	workspaceRoot: string,
-	waveIndex: number,
-	batchId: string,
-): void {
-	if (!discovery) return;
-
-	// Collect unique repo roots that contain task folders
-	const repoRootsWithTasks = new Set<string>();
-	for (const [, task] of discovery.pending) {
-		const taskFolder = resolve(task.taskFolder);
-		// Walk up to find the git repo root for this task folder
-		const gitResult = runGit(["rev-parse", "--show-toplevel"], dirname(taskFolder));
-		if (gitResult.ok) {
-			repoRootsWithTasks.add(gitResult.stdout.trim().replace(/\\/g, "/"));
-		}
-	}
-
-	for (const taskRepoRoot of repoRootsWithTasks) {
-		// Check for uncommitted changes
-		const statusResult = runGit(["status", "--porcelain", "--", "task-management/"], taskRepoRoot);
-		if (!statusResult.ok) {
-			// Try without path filter (task area might have different name)
-			const statusAll = runGit(["status", "--porcelain"], taskRepoRoot);
-			if (!statusAll.ok || !statusAll.stdout.trim()) continue;
-		}
-		if (statusResult.ok && !statusResult.stdout.trim()) continue;
-
-		// Stage task artifacts (only .DONE and STATUS.md files)
-		const lines = (statusResult.stdout || "").split("\n").filter(l => l.trim());
-		let hasTaskArtifacts = false;
-		for (const line of lines) {
-			const file = line.slice(3).trim();
-			if (file.endsWith(".DONE") || file.endsWith("STATUS.md")) {
-				const addResult = runGit(["add", file], taskRepoRoot);
-				if (addResult.ok) hasTaskArtifacts = true;
-			}
-		}
-
-		if (!hasTaskArtifacts) continue;
-
-		// Commit
-		const commitResult = runGit(
-			["commit", "-m", `checkpoint: wave ${waveIndex} task artifacts (.DONE, STATUS.md)`],
-			taskRepoRoot,
-		);
-		if (commitResult.ok) {
-			execLog("batch", batchId, `committed workspace task artifacts`, {
-				repoRoot: taskRepoRoot,
-				wave: waveIndex,
-			});
-		} else if (!commitResult.stderr.includes("nothing to commit")) {
-			execLog("batch", batchId, `workspace task artifact commit failed (non-fatal): ${commitResult.stderr.slice(0, 200)}`, {
-				repoRoot: taskRepoRoot,
-			});
-		}
-	}
-}
-
 // ── Dashboard Widget (Step 6) ────────────────────────────────────────
 

package/extensions/taskplane/extension.ts

@@ -1163,46 +1163,74 @@ export default function (pi: ExtensionAPI) {
 			);
 
 			// ── Step 3: Execute integration mode ─────────────────
-			const integrationResult = executeIntegration(parsed.mode, resolution as IntegrationContext, {
-				runGit: (gitArgs: string[]) => runGit(gitArgs, repoRoot),
-				runCommand: (cmd: string, cmdArgs: string[]) => {
-					try {
-						const stdout = execFileSync(cmd, cmdArgs, {
-							encoding: "utf-8",
-							timeout: 60_000,
-							cwd: repoRoot,
-							stdio: ["pipe", "pipe", "pipe"],
-						}).trim();
-						return { ok: true, stdout, stderr: "" };
-					} catch (err: unknown) {
-						const e = err as { stdout?: string; stderr?: string; message?: string };
-						return {
-							ok: false,
-							stdout: (e.stdout ?? "").toString().trim(),
-							stderr: (e.stderr ?? e.message ?? "unknown error").toString().trim(),
-						};
+			// In workspace mode, integrate in every repo that has the orch branch.
+			const resolvedOrchBranch = (resolution as IntegrationContext).orchBranch;
+			const wsConfig = execCtx!.workspaceConfig;
+			const reposToIntegrate: { id: string; root: string }[] = [];
+
+			if (wsConfig) {
+				for (const [repoId, repoConf] of wsConfig.repos) {
+					// Check if orch branch exists in this repo
+					const branchCheck = runGit(["rev-parse", "--verify", `refs/heads/${resolvedOrchBranch}`], repoConf.path);
+					if (branchCheck.ok) {
+						reposToIntegrate.push({ id: repoId, root: repoConf.path });
 					}
-				},
-				deleteBatchState: () => deleteBatchState(repoRoot),
-			});
-
-			if (!integrationResult.success) {
-				ctx.ui.notify(integrationResult.error!, "error");
-				return;
+				}
+			} else {
+				reposToIntegrate.push({ id: "(default)", root: repoRoot });
 			}
 
-			// Override commit count with pre-computed value for local integrations
-			if (integrationResult.integratedLocally) {
-				integrationResult.commitCount = commitsAhead;
+			let totalCommits = 0;
+			let allSucceeded = true;
+			const repoMessages: string[] = [];
+
+			for (const repo of reposToIntegrate) {
+				const integrationResult = executeIntegration(parsed.mode, resolution as IntegrationContext, {
+					runGit: (gitArgs: string[]) => runGit(gitArgs, repo.root),
+					runCommand: (cmd: string, cmdArgs: string[]) => {
+						try {
+							const stdout = execFileSync(cmd, cmdArgs, {
+								encoding: "utf-8",
+								timeout: 60_000,
+								cwd: repo.root,
+								stdio: ["pipe", "pipe", "pipe"],
+							}).trim();
+							return { ok: true, stdout, stderr: "" };
+						} catch (err: unknown) {
+							const e = err as { stdout?: string; stderr?: string; message?: string };
+							return {
+								ok: false,
+								stdout: (e.stdout ?? "").toString().trim(),
+								stderr: (e.stderr ?? e.message ?? "unknown error").toString().trim(),
+							};
+						}
+					},
+					deleteBatchState: () => { /* handled once after all repos */ },
+				});
+
+				if (!integrationResult.success) {
+					ctx.ui.notify(`❌ Integration failed in ${repo.id}:\n${integrationResult.error}`, "error");
+					allSucceeded = false;
+					break;
+				}
+
+				// Count commits for this repo
+				const countResult = runGit(["rev-list", "--count", `HEAD...${resolvedOrchBranch}`], repo.root);
+				const repoCommits = countResult.ok ? parseInt(countResult.stdout) || 0 : 0;
+				totalCommits += repoCommits;
+				repoMessages.push(`  ${repo.id}: ${integrationResult.message}`);
 			}
 
-			ctx.ui.notify(
-				integrationResult.message +
-				(integrationResult.integratedLocally
-					? `\n${integrationResult.commitCount} commit(s) applied.`
-					: ""),
-				"info",
-			);
+			if (!allSucceeded) return;
+
+			// Clean up batch state after all repos integrated
+			try { deleteBatchState(repoRoot); } catch { /* best effort */ }
+
+			const summary = wsConfig
+				? `✅ Integrated ${resolvedOrchBranch} across ${reposToIntegrate.length} repo(s).\n${repoMessages.join("\n")}\n${totalCommits} total commit(s) applied.`
+				: `${repoMessages[0] || "✅ Integrated."}\n${commitsAhead} commit(s) applied.`;
+
+			ctx.ui.notify(summary, "info");
 		},
 	});
 

package/extensions/taskplane/merge.ts

@@ -2,9 +2,9 @@
  * Merge orchestration, merge agents, merge worktree
  * @module orch/merge
  */
-import { readFileSync, writeFileSync, existsSync, unlinkSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, unlinkSync, copyFileSync, mkdirSync } from "fs";
 import { spawnSync } from "child_process";
-import { join } from "path";
+import { join, dirname } from "path";
 
 import { buildLaneEnvVars, buildTmuxSpawnArgs, execLog, tmuxHasSession, tmuxKillSession, toTmuxPath } from "./execution.ts";
 import { resolveOperatorId } from "./naming.ts";
@@ -755,6 +755,55 @@ export function mergeWave(
 		}
 	}
 
+	// ── Stage workspace task artifacts into merge worktree ──────────
+	// In workspace mode, workers write .DONE and STATUS.md to the canonical
+	// task folder (e.g., shared-libs/task-management/...) which is the repo's
+	// checked-out working tree (develop). These files need to be on the orch
+	// branch, not develop. Copy them into the merge worktree (which is on the
+	// orch branch's temp) and commit, so they're included in the update-ref.
+	if (mergeWorkDir) {
+		const statusResult = spawnSync("git", ["status", "--porcelain"], { cwd: repoRoot, encoding: "utf-8" });
+		if (statusResult.status === 0 && statusResult.stdout) {
+			const lines = statusResult.stdout.split("\n").filter((l: string) => l.trim());
+			const artifactFiles = lines
+				.map((l: string) => l.slice(3).trim())
+				.filter((f: string) => f.endsWith(".DONE") || f.endsWith("STATUS.md"));
+
+			if (artifactFiles.length > 0) {
+				let staged = 0;
+				for (const file of artifactFiles) {
+					const srcPath = join(repoRoot, file);
+					const destPath = join(mergeWorkDir, file);
+					try {
+						if (existsSync(srcPath)) {
+							mkdirSync(dirname(destPath), { recursive: true });
+							copyFileSync(srcPath, destPath);
+							spawnSync("git", ["add", file], { cwd: mergeWorkDir });
+							staged++;
+						}
+					} catch { /* best effort */ }
+				}
+				if (staged > 0) {
+					spawnSync("git", ["commit", "-m", `checkpoint: wave ${waveIndex} task artifacts (.DONE, STATUS.md)`], { cwd: mergeWorkDir });
+					execLog("merge", `W${waveIndex}`, `committed ${staged} task artifact(s) to merge worktree`);
+
+					// Restore the repo's working tree — remove the artifacts from develop's working tree
+					// so they don't cause conflicts on /orch-integrate
+					for (const file of artifactFiles) {
+						spawnSync("git", ["checkout", "--", file], { cwd: repoRoot });
+					}
+					// Also remove any untracked .DONE files
+					for (const file of artifactFiles) {
+						if (file.endsWith(".DONE")) {
+							const srcPath = join(repoRoot, file);
+							try { if (existsSync(srcPath)) unlinkSync(srcPath); } catch { /* best effort */ }
+						}
+					}
+				}
+			}
+		}
+	}
+
 	// ── Update target branch ref and clean up merge worktree ────────
 	const anySuccess = laneResults.some(
 		r => r.result?.status === "SUCCESS" || r.result?.status === "CONFLICT_RESOLVED",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskplane",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "AI agent orchestration for pi — parallel task execution with checkpoint discipline",
   "keywords": [
     "pi-package",