taskplane 0.1.15 → 0.1.17

package/extensions/taskplane/execution.ts

@@ -118,7 +118,8 @@ export function buildLaneEnvVars(
 	if (promptNorm.startsWith(repoRootNorm + "/")) {
 		relativePath = promptNorm.slice(repoRootNorm.length + 1);
 	} else {
-		// Fallback: use the path as-is (shouldn't happen in normal use)
+		// External task folder (workspace mode): prompt path is outside repo root.
+		// Use the absolute path as-is — task-runner accepts absolute TASK_AUTOSTART paths.
 		relativePath = promptPath;
 	}
 
@@ -300,44 +301,122 @@ export function readTaskStatusTail(
 }
 
 /**
- * Resolve the path to a task's .DONE file inside a worktree.
+ * Result of canonical task-folder path resolution.
+ *
+ * Encapsulates the resolved task folder, .DONE path, and STATUS.md path
+ * so callers don't need to re-derive them with inconsistent logic.
+ */
+export interface ResolvedTaskPaths {
+	/** Absolute path to the resolved task folder (may be in worktree or external) */
+	taskFolderResolved: string;
+	/** Absolute path to the .DONE file */
+	donePath: string;
+	/** Absolute path to the STATUS.md file */
+	statusPath: string;
+}
+
+/**
+ * Canonical task-folder path resolver.
  *
- * The task folder path from ParsedTask is absolute (main repo).
- * We need to translate it to the equivalent path in the worktree.
+ * Single source of truth for translating a task folder path (as stored in
+ * ParsedTask) into the correct filesystem paths for .DONE and STATUS.md
+ * probing. Handles two cases:
  *
- * @param taskFolder   - Absolute task folder path (from main repo)
+ * 1. **Task folder inside repoRoot** (monorepo / repo mode):
+ *    Strip the repoRoot prefix to get a relative path, then join with
+ *    worktreePath. This is the existing behavior — worktrees mirror the
+ *    repo structure so the relative path is the same.
+ *
+ * 2. **Task folder outside repoRoot** (workspace mode with external tasks root):
+ *    The task folder is not inside the execution repo. Use the absolute
+ *    task folder path directly — the .DONE and STATUS.md files live in
+ *    the canonical task folder, not in any worktree.
+ *
+ * Both branches include archive fallback: if the primary location doesn't
+ * exist, check `<parent>/archive/<taskDirName>/` for relocated task folders.
+ *
+ * @param taskFolder   - Absolute task folder path (from ParsedTask.taskFolder)
  * @param worktreePath - Absolute path to the lane worktree
  * @param repoRoot     - Absolute path to the main repository root
- * @returns Absolute path to the .DONE file in the worktree
+ * @returns Resolved paths for task folder, .DONE, and STATUS.md
  */
-export function resolveTaskDonePath(
+export function resolveCanonicalTaskPaths(
 	taskFolder: string,
 	worktreePath: string,
 	repoRoot: string,
-): string {
+): ResolvedTaskPaths {
 	const repoRootNorm = resolve(repoRoot).replace(/\\/g, "/");
 	const folderNorm = resolve(taskFolder).replace(/\\/g, "/");
 
-	let relativePath: string;
+	let resolvedFolder: string;
+
 	if (folderNorm.startsWith(repoRootNorm + "/")) {
-		relativePath = folderNorm.slice(repoRootNorm.length + 1);
+		// Case 1: Task folder is inside the repo root.
+		// Translate to equivalent path in the worktree.
+		const relativePath = folderNorm.slice(repoRootNorm.length + 1);
+		resolvedFolder = join(worktreePath, relativePath);
 	} else {
-		relativePath = taskFolder;
+		// Case 2: Task folder is outside the repo root (workspace mode).
+		// Use the absolute path directly — task state lives in the
+		// canonical task folder, not mirrored in any worktree.
+		resolvedFolder = resolve(taskFolder);
 	}
 
-	const primaryPath = join(worktreePath, relativePath, ".DONE");
-	if (existsSync(primaryPath)) return primaryPath;
+	// Check primary location
+	const primaryDone = join(resolvedFolder, ".DONE");
+	const primaryStatus = join(resolvedFolder, "STATUS.md");
+	if (existsSync(primaryDone) || existsSync(primaryStatus)) {
+		return {
+			taskFolderResolved: resolvedFolder,
+			donePath: primaryDone,
+			statusPath: primaryStatus,
+		};
+	}
 
-	// Fallback: worker may have archived the task folder during the
+	// Archive fallback: worker may have archived the task folder during the
 	// "Documentation & Delivery" step, moving it under `.../archive/TASK-ID/`.
-	// Check the archive sibling path.
-	const parts = relativePath.replace(/\\/g, "/").split("/");
-	const taskDirName = parts[parts.length - 1]; // e.g. "PM-011-template-seed-data-permissions"
-	const parentParts = parts.slice(0, -1);       // e.g. [..., "tasks"]
-	const archivePath = join(worktreePath, ...parentParts, "archive", taskDirName, ".DONE");
-	if (existsSync(archivePath)) return archivePath;
-
-	return primaryPath; // Return primary even if missing (caller checks existsSync)
+	const resolvedNorm = resolve(resolvedFolder).replace(/\\/g, "/");
+	const parts = resolvedNorm.split("/");
+	const taskDirName = parts[parts.length - 1];
+	const parentDir = parts.slice(0, -1).join("/");
+	const archiveFolder = join(parentDir, "archive", taskDirName);
+	const archiveDone = join(archiveFolder, ".DONE");
+	const archiveStatus = join(archiveFolder, "STATUS.md");
+
+	if (existsSync(archiveDone) || existsSync(archiveStatus)) {
+		return {
+			taskFolderResolved: archiveFolder,
+			donePath: archiveDone,
+			statusPath: archiveStatus,
+		};
+	}
+
+	// Return primary paths even if nothing exists yet (caller probes existsSync)
+	return {
+		taskFolderResolved: resolvedFolder,
+		donePath: primaryDone,
+		statusPath: primaryStatus,
+	};
+}
+
+/**
+ * Resolve the path to a task's .DONE file inside a worktree.
+ *
+ * Delegates to `resolveCanonicalTaskPaths` for consistent path resolution
+ * across repo mode (task folder inside repo) and workspace mode (external
+ * task folder).
+ *
+ * @param taskFolder   - Absolute task folder path (from main repo)
+ * @param worktreePath - Absolute path to the lane worktree
+ * @param repoRoot     - Absolute path to the main repository root
+ * @returns Absolute path to the .DONE file in the worktree
+ */
+export function resolveTaskDonePath(
+	taskFolder: string,
+	worktreePath: string,
+	repoRoot: string,
+): string {
+	return resolveCanonicalTaskPaths(taskFolder, worktreePath, repoRoot).donePath;
 }
 
 /**
@@ -467,8 +546,9 @@ export async function pollUntilTaskComplete(
 ): Promise<{ status: LaneTaskStatus; exitReason: string; doneFileFound: boolean }> {
 	const sessionName = lane.tmuxSessionName;
 	const laneId = lane.laneId;
-	const donePath = resolveTaskDonePath(task.task.taskFolder, lane.worktreePath, repoRoot);
-	const statusPath = join(dirname(donePath), "STATUS.md");
+	const resolved = resolveCanonicalTaskPaths(task.task.taskFolder, lane.worktreePath, repoRoot);
+	const donePath = resolved.donePath;
+	const statusPath = resolved.statusPath;
 	const laneLogPath = resolveLaneLogPath(lane, task);
 
 	execLog(laneId, task.taskId, "polling for completion", {
@@ -594,14 +674,72 @@ export async function pollUntilTaskComplete(
 	}
 }
 
+
+// ── Post-Task Commit ─────────────────────────────────────────────────
+
+/**
+ * Commit any uncommitted task artifacts to the lane branch after task completion.
+ *
+ * The task-runner creates `.DONE` and updates `STATUS.md` via `writeFileSync`,
+ * but these changes are never committed to git by the task-runner or the worker.
+ * Without this commit, these files are lost when the worktree is reset or removed,
+ * and they don't appear in the merge to the base branch.
+ *
+ * Best-effort: failures are logged but don't fail the task (the work is already done).
+ *
+ * @param lane   - Allocated lane containing the worktree path
+ * @param task   - The task that just completed
+ * @param laneId - Lane identifier for logging
+ */
+function commitTaskArtifacts(
+	lane: AllocatedLane,
+	task: AllocatedTask,
+	laneId: string,
+): void {
+	const worktreePath = lane.worktreePath;
+
+	// Check if there are any uncommitted changes in the worktree
+	const statusResult = runGit(["status", "--porcelain"], worktreePath);
+	if (!statusResult.ok || !statusResult.stdout.trim()) {
+		// Nothing to commit (worker already committed everything, or git error)
+		return;
+	}
+
+	// Stage all changes in the worktree
+	const addResult = runGit(["add", "-A"], worktreePath);
+	if (!addResult.ok) {
+		execLog(laneId, task.taskId, `post-task stage failed (non-fatal): ${addResult.stderr.slice(0, 200)}`);
+		return;
+	}
+
+	// Commit with task ID for traceability
+	const commitResult = runGit(
+		["commit", "-m", `checkpoint: ${task.taskId} task artifacts (.DONE, STATUS.md)`],
+		worktreePath,
+	);
+	if (!commitResult.ok) {
+		// "nothing to commit" is not an error — worker may have already committed
+		if (!commitResult.stderr.includes("nothing to commit")) {
+			execLog(laneId, task.taskId, `post-task commit failed (non-fatal): ${commitResult.stderr.slice(0, 200)}`);
+		}
+		return;
+	}
+
+	execLog(laneId, task.taskId, `committed task artifacts to lane branch`, {
+		commit: commitResult.stdout.trim().split("\n")[0],
+	});
+}
+
+
 /**
  * Execute all tasks in a lane sequentially.
  *
  * For each task in the lane (in order):
  * 1. Spawn a TMUX session with TASK_AUTOSTART pointing to the task's PROMPT.md
  * 2. Poll until the task completes (or fails)
- * 3. Record the outcome
- * 4. If the task failed, skip remaining tasks in the lane
+ * 3. Commit any uncommitted task artifacts (.DONE, STATUS.md) to the lane branch
+ * 4. Record the outcome
+ * 5. If the task failed, skip remaining tasks in the lane
  *
  * The lane reuses the same worktree and TMUX session name across tasks.
  * Each new task gets a fresh TMUX session (the previous one has exited).
@@ -680,6 +818,13 @@ export async function executeLane(
 				doneFileFound: pollResult.doneFileFound,
 			};
 
+			// After task succeeds, commit any uncommitted artifacts (.DONE, final
+			// STATUS.md update) to the lane branch so they survive the merge.
+			// The task-runner writes .DONE via writeFileSync but never commits it.
+			if (pollResult.status === "succeeded") {
+				commitTaskArtifacts(lane, task, laneId);
+			}
+
 			// If task failed or was paused, skip remaining tasks
 			if (pollResult.status === "failed" || pollResult.status === "stalled") {
 				shouldSkipRemaining = true;
@@ -788,30 +933,12 @@ export function parseWorktreeStatusMd(
 	worktreePath: string,
 	repoRoot: string,
 ): { parsed: ParsedWorktreeStatus | null; error: string | null } {
-	// Translate the task folder path from main repo to worktree
-	const repoRootNorm = resolve(repoRoot).replace(/\\/g, "/");
-	const folderNorm = resolve(taskFolder).replace(/\\/g, "/");
-
-	let relativePath: string;
-	if (folderNorm.startsWith(repoRootNorm + "/")) {
-		relativePath = folderNorm.slice(repoRootNorm.length + 1);
-	} else {
-		relativePath = taskFolder;
-	}
-
-	let statusPath = join(worktreePath, relativePath, "STATUS.md");
+	// Use canonical resolver for consistent path translation
+	const resolved = resolveCanonicalTaskPaths(taskFolder, worktreePath, repoRoot);
+	const statusPath = resolved.statusPath;
 
 	if (!existsSync(statusPath)) {
-		// Fallback: worker may have archived the task folder
-		const parts = relativePath.replace(/\\/g, "/").split("/");
-		const taskDirName = parts[parts.length - 1];
-		const parentParts = parts.slice(0, -1);
-		const archiveStatusPath = join(worktreePath, ...parentParts, "archive", taskDirName, "STATUS.md");
-		if (existsSync(archiveStatusPath)) {
-			statusPath = archiveStatusPath;
-		} else {
-			return { parsed: null, error: `STATUS.md not found at ${statusPath}` };
-		}
+		return { parsed: null, error: `STATUS.md not found at ${statusPath}` };
 	}
 
 	let content: string;