taskplane 0.1.15 → 0.1.16

package/extensions/taskplane/config.ts

@@ -1,14 +1,14 @@
-/**
- * Config loading from YAML
- * @module orch/config
- */
-import { readFileSync, existsSync } from "fs";
-import { join } from "path";
-import { parse as yamlParse } from "yaml";
-
-import { DEFAULT_ORCHESTRATOR_CONFIG, DEFAULT_TASK_RUNNER_CONFIG } from "./types.ts";
-import type { OrchestratorConfig, TaskArea, TaskRunnerConfig } from "./types.ts";
-
+/**
+ * Config loading from YAML
+ * @module orch/config
+ */
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { parse as yamlParse } from "yaml";
+
+import { DEFAULT_ORCHESTRATOR_CONFIG, DEFAULT_TASK_RUNNER_CONFIG } from "./types.ts";
+import type { OrchestratorConfig, TaskArea, TaskRunnerConfig } from "./types.ts";
+
 // ── Config Loading ───────────────────────────────────────────────────
 
 /**
@@ -84,11 +84,16 @@ export function loadTaskRunnerConfig(cwd: string): TaskRunnerConfig {
 		if (loaded?.task_areas) {
 			for (const [name, area] of Object.entries(loaded.task_areas)) {
 				const a = area as any;
-				taskAreas[name] = {
+				const ta: TaskArea = {
 					path: a?.path || "",
 					prefix: a?.prefix || "",
 					context: a?.context || "",
 				};
+				// Parse repo_id (snake_case YAML key) into repoId for routing
+				if (a?.repo_id && typeof a.repo_id === "string" && a.repo_id.trim()) {
+					ta.repoId = a.repo_id.trim();
+				}
+				taskAreas[name] = ta;
 			}
 		}
 		return {

package/extensions/taskplane/discovery.ts

@@ -1,12 +1,13 @@
-/**
- * Task discovery, PROMPT.md parsing, dependency resolution
- * @module orch/discovery
- */
-import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from "fs";
-import { join, dirname, basename, resolve } from "path";
-
-import type { DiscoveryError, DiscoveryResult, ParsedTask, TaskArea } from "./types.ts";
-
+/**
+ * Task discovery, PROMPT.md parsing, dependency resolution
+ * @module orch/discovery
+ */
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from "fs";
+import { join, dirname, basename, resolve } from "path";
+
+import { FATAL_DISCOVERY_CODES } from "./types.ts";
+import type { DiscoveryError, DiscoveryResult, ParsedTask, TaskArea, WorkspaceConfig } from "./types.ts";
+
 // ── PROMPT.md Parsing ────────────────────────────────────────────────
 
 /**
@@ -184,6 +185,54 @@ export function parsePromptForOrchestrator(
 		}
 	}
 
+	// ── Extract execution target (repo ID) ──────────────────────
+	// Repo ID validation: lowercase alphanumeric + hyphens, starting with alnum
+	const REPO_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+
+	let promptRepoId: string | undefined;
+
+	// Priority 1: Section-based "## Execution Target" with "Repo: <id>" line
+	// Capture everything from section header to the next heading or --- divider.
+	// We avoid \n$ (which in multiline mode matches blank lines) by using a two-pass
+	// approach: find the section start, then slice to the next section boundary.
+	const execTargetHeaderIdx = content.search(/^##\s+Execution Target\s*$/m);
+	let execTargetSectionBody: string | null = null;
+	if (execTargetHeaderIdx !== -1) {
+		const afterHeader = content.indexOf("\n", execTargetHeaderIdx);
+		if (afterHeader !== -1) {
+			const rest = content.slice(afterHeader + 1);
+			const nextSectionMatch = rest.search(/^##\s|^---/m);
+			execTargetSectionBody = nextSectionMatch !== -1
+				? rest.slice(0, nextSectionMatch)
+				: rest;
+		}
+	}
+	if (execTargetSectionBody !== null) {
+		// Match "Repo: api" or "**Repo:** api" or "Repo: api" with whitespace
+		const repoLineMatch = execTargetSectionBody.match(
+			/^\s*\*?\*?Repo:?\*?\*?\s+(\S+)/mi,
+		);
+		if (repoLineMatch) {
+			const candidate = repoLineMatch[1].trim().toLowerCase();
+			if (REPO_ID_PATTERN.test(candidate)) {
+				promptRepoId = candidate;
+			}
+		}
+	}
+
+	// Priority 2 (fallback): Inline "**Repo:** <id>" anywhere in content
+	if (!promptRepoId) {
+		const inlineRepoMatch = content.match(
+			/^\*\*Repo:\*\*\s+(\S+)/m,
+		);
+		if (inlineRepoMatch) {
+			const candidate = inlineRepoMatch[1].trim().toLowerCase();
+			if (REPO_ID_PATTERN.test(candidate)) {
+				promptRepoId = candidate;
+			}
+		}
+	}
+
 	// ── Extract file scope ───────────────────────────────────────
 	const fileScope: string[] = [];
 	const fileScopeMatch = content.match(
@@ -214,12 +263,13 @@ export function parsePromptForOrchestrator(
 			promptPath: resolve(promptPath),
 			areaName,
 			status: "pending",
+			...(promptRepoId ? { promptRepoId } : {}),
 		},
 		error: null,
 	};
 }
 
-
+
 // ── Area Scanning ────────────────────────────────────────────────────
 
 /**
@@ -291,7 +341,7 @@ export function scanAreaForTasks(
 	return { tasks, errors };
 }
 
-
+
 // ── Completed Task Set ───────────────────────────────────────────────
 
 /**
@@ -361,7 +411,7 @@ export function buildCompletedTaskSet(areaPaths: string[]): Set<string> {
 	return completed;
 }
 
-
+
 // ── Argument Resolution ──────────────────────────────────────────────
 
 /**
@@ -440,6 +490,8 @@ export interface DiscoveryOptions {
 	refreshDependencies?: boolean;
 	dependencySource?: "prompt" | "agent";
 	useDependencyCache?: boolean;
+	/** Workspace config for repo routing (null/undefined = repo mode, no routing). */
+	workspaceConfig?: WorkspaceConfig | null;
 }
 
 export interface DependencyCacheFile {
@@ -531,7 +583,7 @@ export function applyDependenciesFromCache(
 	return { applied };
 }
 
-
+
 // ── Task Registry ────────────────────────────────────────────────────
 
 /**
@@ -637,7 +689,7 @@ export function buildTaskRegistry(
 	return { pending, completed, errors };
 }
 
-
+
 // ── Cross-Area Dependency Resolution ─────────────────────────────────
 
 /** Candidate match for a dependency reference found in task areas. */
@@ -806,7 +858,93 @@ export function resolveDependencies(
 	return errors;
 }
 
-
+
+// ── Task-to-Repo Routing ─────────────────────────────────────────────
+
+/** Repo ID validation: lowercase alphanumeric + hyphens, starting with alnum */
+const ROUTING_REPO_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+
+/**
+ * Resolve the target repo for each discovered task using the routing
+ * precedence chain:
+ *
+ *   1. `task.promptRepoId` — declared in PROMPT.md metadata
+ *   2. `taskArea.repoId` — area-level config from task-runner.yaml
+ *   3. `workspaceConfig.routing.defaultRepo` — workspace-level default
+ *
+ * Only applied in workspace mode (when `workspaceConfig` is provided).
+ * In repo mode this function is never called.
+ *
+ * Returns an array of DiscoveryError for routing failures:
+ *   - TASK_REPO_UNRESOLVED: no source provided a repo ID
+ *   - TASK_REPO_UNKNOWN: resolved repo ID is not in workspace repos map
+ */
+export function resolveTaskRouting(
+	discovery: DiscoveryResult,
+	taskAreas: Record<string, TaskArea>,
+	workspaceConfig: WorkspaceConfig,
+): DiscoveryError[] {
+	const errors: DiscoveryError[] = [];
+	const validRepoIds = workspaceConfig.repos;
+
+	for (const task of discovery.pending.values()) {
+		// Precedence 1: prompt-declared repo
+		let resolvedId = task.promptRepoId;
+		let source = "prompt";
+
+		// Precedence 2: area-level repo
+		if (!resolvedId) {
+			const area = taskAreas[task.areaName];
+			if (area?.repoId) {
+				const candidate = area.repoId.trim().toLowerCase();
+				if (ROUTING_REPO_ID_PATTERN.test(candidate)) {
+					resolvedId = candidate;
+					source = "area";
+				}
+			}
+		}
+
+		// Precedence 3: workspace default repo
+		if (!resolvedId) {
+			resolvedId = workspaceConfig.routing.defaultRepo;
+			source = "default";
+		}
+
+		// Validate resolution
+		if (!resolvedId) {
+			errors.push({
+				code: "TASK_REPO_UNRESOLVED",
+				message:
+					`Task ${task.taskId} has no resolved repo. ` +
+					`Add a Repo: field to the PROMPT, set repo_id on area "${task.areaName}", ` +
+					`or set routing.default_repo in the workspace config.`,
+				taskId: task.taskId,
+				taskPath: task.promptPath,
+			});
+			continue;
+		}
+
+		if (!validRepoIds.has(resolvedId)) {
+			errors.push({
+				code: "TASK_REPO_UNKNOWN",
+				message:
+					`Task ${task.taskId} resolved to repo "${resolvedId}" (via ${source}), ` +
+					`but no repo with that ID exists in the workspace config. ` +
+					`Known repos: ${[...validRepoIds.keys()].join(", ")}`,
+				taskId: task.taskId,
+				taskPath: task.promptPath,
+			});
+			continue;
+		}
+
+		// Attach resolved repo to the task
+		task.resolvedRepoId = resolvedId;
+	}
+
+	return errors;
+}
+
+
 // ── Discovery Pipeline (Public) ──────────────────────────────────────
 
 /**
@@ -901,6 +1039,13 @@ export function runDiscovery(
 		}
 	}
 
+	// Step 6: Task-to-repo routing (workspace mode only)
+	const workspaceConfig = options.workspaceConfig;
+	if (workspaceConfig && workspaceConfig.mode === "workspace") {
+		const routingErrors = resolveTaskRouting(discovery, taskAreas, workspaceConfig);
+		discovery.errors.push(...routingErrors);
+	}
+
 	return discovery;
 }
 
@@ -939,8 +1084,12 @@ export function formatDiscoveryResults(result: DiscoveryResult): string {
 					task.dependencies.length > 0
 						? ` → depends on: ${task.dependencies.join(", ")}`
 						: "";
+				const repo =
+					task.resolvedRepoId
+						? ` → repo: ${task.resolvedRepoId}`
+						: "";
 				lines.push(
-					`    ${task.taskId} [${task.size}] ${task.taskName}${deps}`,
+					`    ${task.taskId} [${task.size}] ${task.taskName}${deps}${repo}`,
 				);
 			}
 		}
@@ -949,22 +1098,9 @@ export function formatDiscoveryResults(result: DiscoveryResult): string {
 
 	// Show errors
 	if (result.errors.length > 0) {
-		const fatalErrors = result.errors.filter(
-			(e) =>
-				e.code === "DUPLICATE_ID" ||
-				e.code === "DEP_UNRESOLVED" ||
-				e.code === "DEP_PENDING" ||
-				e.code === "DEP_AMBIGUOUS" ||
-				e.code === "PARSE_MISSING_ID",
-		);
-		const warnings = result.errors.filter(
-			(e) =>
-				e.code !== "DUPLICATE_ID" &&
-				e.code !== "DEP_UNRESOLVED" &&
-				e.code !== "DEP_PENDING" &&
-				e.code !== "DEP_AMBIGUOUS" &&
-				e.code !== "PARSE_MISSING_ID",
-		);
+		const fatalCodes = new Set<string>(FATAL_DISCOVERY_CODES);
+		const fatalErrors = result.errors.filter((e) => fatalCodes.has(e.code));
+		const warnings = result.errors.filter((e) => !fatalCodes.has(e.code));
 
 		if (fatalErrors.length > 0) {
 			lines.push("❌ Errors:");

package/extensions/taskplane/engine.ts

@@ -13,10 +13,10 @@ import { mergeWave } from "./merge.ts";
 import { ORCH_MESSAGES } from "./messages.ts";
 import { deleteBatchState, loadBatchHistory, persistRuntimeState, saveBatchHistory, seedPendingOutcomesForAllocatedLanes, syncTaskOutcomesFromMonitor, upsertTaskOutcome } from "./persistence.ts";
 import { listOrchSessions } from "./sessions.ts";
-import { generateBatchId } from "./types.ts";
-import type { AllocatedLane, BatchHistorySummary, BatchTaskSummary, BatchWaveSummary, DiscoveryResult, LaneExecutionResult, LaneTaskOutcome, MergeWaveResult, OrchBatchPhase, OrchBatchRuntimeState, OrchestratorConfig, TaskRunnerConfig, TokenCounts } from "./types.ts";
+import { FATAL_DISCOVERY_CODES, generateBatchId } from "./types.ts";
+import type { AllocatedLane, BatchHistorySummary, BatchTaskSummary, BatchWaveSummary, DiscoveryResult, LaneExecutionResult, LaneTaskOutcome, MergeWaveResult, OrchBatchPhase, OrchBatchRuntimeState, OrchestratorConfig, TaskRunnerConfig, TokenCounts, WorkspaceConfig } from "./types.ts";
 import { buildDependencyGraph, computeWaves, validateGraph } from "./waves.ts";
-import { deleteBranchBestEffort, formatPreflightResults, listWorktrees, removeAllWorktrees, removeWorktree, runPreflight, safeResetWorktree, sleepSync } from "./worktree.ts";
+import { deleteBranchBestEffort, forceCleanupWorktree, formatPreflightResults, listWorktrees, removeAllWorktrees, removeWorktree, runPreflight, safeResetWorktree, sleepSync } from "./worktree.ts";
 
 // ── /orch Execution Engine ───────────────────────────────────────────
 
@@ -32,6 +32,7 @@ import { deleteBranchBestEffort, formatPreflightResults, listWorktrees, removeAl
  * @param batchState  - Mutable batch state (updated throughout execution)
  * @param onNotify    - Callback for user-facing messages
  * @param onMonitorUpdate - Optional callback for dashboard updates
+ * @param workspaceConfig - Workspace configuration for repo routing (null = repo mode)
  */
 export async function executeOrchBatch(
 	args: string,
@@ -41,6 +42,7 @@ export async function executeOrchBatch(
 	batchState: OrchBatchRuntimeState,
 	onNotify: (message: string, level: "info" | "warning" | "error") => void,
 	onMonitorUpdate?: MonitorUpdateCallback,
+	workspaceConfig?: WorkspaceConfig | null,
 ): Promise<void> {
 	const repoRoot = cwd;
 
@@ -95,23 +97,27 @@ export async function executeOrchBatch(
 		refreshDependencies: false,
 		dependencySource: orchConfig.dependencies.source,
 		useDependencyCache: orchConfig.dependencies.cache,
+		workspaceConfig: workspaceConfig ?? null,
 	});
 	onNotify(formatDiscoveryResults(discovery), discovery.errors.length > 0 ? "warning" : "info");
 
 	// Check for fatal errors
-	const fatalErrors = discovery.errors.filter(
-		(e) =>
-			e.code === "DUPLICATE_ID" ||
-			e.code === "DEP_UNRESOLVED" ||
-			e.code === "DEP_PENDING" ||
-			e.code === "DEP_AMBIGUOUS" ||
-			e.code === "PARSE_MISSING_ID",
-	);
+	const fatalCodes = new Set<string>(FATAL_DISCOVERY_CODES);
+	const fatalErrors = discovery.errors.filter((e) => fatalCodes.has(e.code));
 	if (fatalErrors.length > 0) {
 		batchState.phase = "failed";
 		batchState.endedAt = Date.now();
 		batchState.errors.push("Discovery had fatal errors — cannot proceed");
 		onNotify("❌ Cannot execute due to discovery errors above.", "error");
+		const hasRoutingErrors = fatalErrors.some(
+			(e) => e.code === "TASK_REPO_UNRESOLVED" || e.code === "TASK_REPO_UNKNOWN",
+		);
+		if (hasRoutingErrors) {
+			onNotify(
+				"💡 Check PROMPT Repo: fields, area repo_id config, and routing.default_repo in workspace config.",
+				"info",
+			);
+		}
 		return;
 	}
 
@@ -500,10 +506,14 @@ export async function executeOrchBatch(
 							removeWorktree(wt, repoRoot);
 							execLog("batch", batchState.batchId, `removed unrecoverable worktree for lane ${wt.laneNumber}`);
 						} catch (removeErr: unknown) {
-							execLog("batch", batchState.batchId, `failed to remove unrecoverable worktree for lane ${wt.laneNumber}`, {
+							execLog("batch", batchState.batchId, `removeWorktree failed for lane ${wt.laneNumber}, attempting force cleanup`, {
 								error: removeErr instanceof Error ? removeErr.message : String(removeErr),
 								path: wt.path,
 							});
+							// Last resort: force-remove the directory and prune git worktree state.
+							// This handles cases where git has partially deregistered the worktree
+							// or undeletable files (e.g., Windows reserved names like "nul") block removal.
+							forceCleanupWorktree(wt, repoRoot, batchState.batchId);
 						}
 					} else {
 						execLog("batch", batchState.batchId, `worktree reset OK for lane ${wt.laneNumber}`);

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.
  *
- * The task folder path from ParsedTask is absolute (main repo).
- * We need to translate it to the equivalent path in the worktree.
+ * 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.
  *
- * @param taskFolder   - Absolute task folder path (from main repo)
+ * 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:
+ *
+ * 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", {
@@ -788,30 +868,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;