taskplane 0.7.2 → 0.8.1

package/extensions/taskplane/execution.ts

@@ -2,9 +2,10 @@
  * Lane execution, monitoring, wave execution loop
  * @module orch/execution
  */
-import { readFileSync, existsSync, statSync, unlinkSync, mkdirSync } from "fs";
+import { readFileSync, existsSync, statSync, unlinkSync, mkdirSync, writeFileSync } from "fs";
 import { spawnSync } from "child_process";
 import { join, dirname, resolve, relative, delimiter as pathDelimiter } from "path";
+import { tmpdir, userInfo } from "os";
 
 import { DONE_GRACE_MS, EXECUTION_POLL_INTERVAL_MS, ExecutionError, SESSION_SPAWN_RETRY_MAX } from "./types.ts";
 import type { AllocatedLane, AllocatedTask, DependencyGraph, LaneExecutionResult, LaneMonitorSnapshot, LaneTaskOutcome, LaneTaskStatus, MonitorState, MtimeTracker, OrchestratorConfig, ParsedTask, TaskMonitorSnapshot, WaveExecutionResult, WorkspaceConfig } from "./types.ts";
@@ -58,6 +59,108 @@ function resolveTaskRunnerExtensionPath(repoRoot: string): string {
 	return localPath;
 }
 
+// ── RPC Wrapper Path Resolution ──────────────────────────────────────
+
+/**
+ * Find the rpc-wrapper.mjs path for lane sessions.
+ *
+ * Resolution order mirrors resolveTaskRunnerExtensionPath:
+ *   1. Local project: {repoRoot}/bin/rpc-wrapper.mjs (for taskplane dev)
+ *   2. Global npm (Windows): {APPDATA}/npm/node_modules/taskplane/bin/rpc-wrapper.mjs
+ *   3. Global npm (Unix): /usr/local/lib/node_modules/taskplane/bin/rpc-wrapper.mjs
+ *   4. npm peer: resolve from pi's location
+ *
+ * @throws ExecutionError if rpc-wrapper.mjs cannot be found anywhere
+ */
+export function resolveRpcWrapperPath(repoRoot: string): string {
+	const wrapperFile = join("bin", "rpc-wrapper.mjs");
+
+	// 1. Local project (taskplane development)
+	const localPath = join(resolve(repoRoot), wrapperFile);
+	if (existsSync(localPath)) return localPath;
+
+	// 2. Global npm install paths
+	const home = process.env.HOME || process.env.USERPROFILE || "";
+	const candidates: string[] = [];
+	if (process.env.APPDATA) {
+		candidates.push(join(process.env.APPDATA, "npm", "node_modules", "taskplane", wrapperFile));
+	}
+	if (home) {
+		candidates.push(join(home, "AppData", "Roaming", "npm", "node_modules", "taskplane", wrapperFile));
+		candidates.push(join(home, ".npm-global", "lib", "node_modules", "taskplane", wrapperFile));
+	}
+	candidates.push(join("/usr", "local", "lib", "node_modules", "taskplane", wrapperFile));
+
+	// 3. Peer of pi's package
+	try {
+		const piPath = process.argv[1] || "";
+		const piPkgDir = resolve(piPath, "..", "..");
+		candidates.push(join(piPkgDir, "..", "taskplane", wrapperFile));
+	} catch { /* ignore */ }
+
+	for (const candidate of candidates) {
+		if (existsSync(candidate)) return candidate;
+	}
+
+	// Fallback: return the local path (will fail at spawn time with a clear error)
+	return localPath;
+}
+
+// ── Telemetry Path Generation ────────────────────────────────────────
+
+/**
+ * Generate telemetry file paths for a lane session.
+ *
+ * Naming contract from resilience roadmap:
+ *   .pi/telemetry/{opId}-{batchId}-{repoId}[-{taskId}][-lane-{N}]-{role}.{ext}
+ *
+ * @param sessionName  - TMUX session name (e.g., "orch-lane-1")
+ * @param sidecarRoot  - Root dir for sidecar files (e.g., <workspace>/.pi or <repo>/.pi)
+ * @param taskId       - Task identifier (e.g., "TP-049")
+ * @returns { sidecarPath, exitSummaryPath, telemetryDir }
+ */
+export function generateTelemetryPaths(
+	sessionName: string,
+	sidecarRoot: string,
+	taskId?: string,
+): { sidecarPath: string; exitSummaryPath: string; telemetryDir: string } {
+	const telemetryTs = Date.now();
+
+	// Resolve opId: same priority chain as naming.ts resolveOperatorId()
+	let opId = "op";
+	const envOpId = process.env.TASKPLANE_OPERATOR_ID;
+	if (envOpId?.trim()) {
+		opId = envOpId.trim().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 12) || "op";
+	} else {
+		try {
+			const username = userInfo().username;
+			if (username?.trim()) {
+				opId = username.trim().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 12) || "op";
+			}
+		} catch { /* userInfo() can throw on some platforms */ }
+	}
+
+	const batchId = String(telemetryTs);
+	const repoId = "default";
+
+	// Extract role from sessionName — lane sessions are "worker" role
+	const role = "worker";
+	const laneMatch = sessionName.match(/lane-(\d+)/);
+	const laneSuffix = laneMatch ? `-lane-${laneMatch[1]}` : "";
+
+	// Include taskId when available
+	const taskIdSegment = taskId
+		? `-${taskId.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 30)}`
+		: "";
+	const telemetryBasename = `${opId}-${batchId}-${repoId}${taskIdSegment}${laneSuffix}-${role}`;
+	const telemetryDir = join(sidecarRoot, "telemetry");
+	if (!existsSync(telemetryDir)) mkdirSync(telemetryDir, { recursive: true });
+	const sidecarPath = join(telemetryDir, `${telemetryBasename}.jsonl`);
+	const exitSummaryPath = join(telemetryDir, `${telemetryBasename}-exit.json`);
+
+	return { sidecarPath, exitSummaryPath, telemetryDir };
+}
+
 // ── Execution Helpers ────────────────────────────────────────────────
 
 /**
@@ -231,7 +334,12 @@ export function toTmuxPath(pathValue: string): string {
  *
  * Constructs a properly escaped command that:
  * 1. Sets env vars (TASK_AUTOSTART, TASK_RUNNER_SPAWN_MODE, TASK_RUNNER_TMUX_PREFIX)
- * 2. Runs `pi --no-session -e extensions/task-runner.ts` in the worktree directory
+ * 2. Runs `node rpc-wrapper.mjs` to spawn pi with the task-runner extension,
+ *    producing structured telemetry (sidecar JSONL + exit summary JSON).
+ *
+ * The RPC wrapper spawns pi in RPC mode with the task-runner extension loaded.
+ * The extension's TASK_AUTOSTART env var triggers task execution on init.
+ * A minimal prompt file is created to satisfy the wrapper's --prompt-file requirement.
  *
  * Shell escaping: env var values are single-quoted to prevent expansion.
  * Path args are single-quoted to handle spaces and special characters.
@@ -241,6 +349,8 @@ export function toTmuxPath(pathValue: string): string {
  * @param repoRoot     - Absolute path to main repo (for extension absolute path)
  * @param envVars      - Environment variables to set
  * @param laneLogPath  - Optional path to write lane session stdout/stderr
+ * @param sidecarPath  - Path for RPC telemetry sidecar JSONL file
+ * @param exitSummaryPath - Path for RPC telemetry exit summary JSON file
  * @returns Array of arguments for spawnSync("tmux", args)
  */
 export function buildTmuxSpawnArgs(
@@ -249,6 +359,8 @@ export function buildTmuxSpawnArgs(
 	repoRoot: string,
 	envVars: Record<string, string>,
 	laneLogPath?: string,
+	sidecarPath?: string,
+	exitSummaryPath?: string,
 ): string[] {
 	// Shell-quote a value for safe embedding in a command string.
 	// Wraps in single quotes, escaping any internal single quotes.
@@ -260,18 +372,44 @@ export function buildTmuxSpawnArgs(
 	};
 
 	// Build the command string that runs inside the TMUX session.
-	// Format: ENV_VAR1=value1 ENV_VAR2=value2 pi --no-session -e extensions/task-runner.ts
 	const envParts = Object.entries(envVars)
 		.map(([key, val]) => `${key}=${shellQuote(val)}`)
 		.join(" ");
 
 	const taskRunnerExtPath = resolveTaskRunnerExtensionPath(repoRoot);
-	const basePiCommand = `${envParts} pi --no-session -e ${shellQuote(taskRunnerExtPath)}`;
+
+	let piCommand: string;
+
+	if (sidecarPath && exitSummaryPath) {
+		// ── RPC Wrapper mode: structured telemetry ──────────────
+		// Spawn `node rpc-wrapper.mjs` instead of `pi` directly.
+		// The wrapper runs pi in RPC mode, captures telemetry to
+		// sidecar JSONL, and writes exit summary on process exit.
+		const rpcWrapperPath = resolveRpcWrapperPath(repoRoot);
+
+		// Create a minimal prompt file for the RPC wrapper.
+		// The task-runner extension handles execution via TASK_AUTOSTART;
+		// this prompt satisfies the wrapper's --prompt-file requirement.
+		const promptId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		const promptTmpFile = join(tmpdir(), `pi-lane-prompt-${promptId}.txt`);
+		writeFileSync(promptTmpFile, "Execute the task as configured by the task-runner extension.");
+
+		piCommand = [
+			envParts,
+			"node", shellQuote(rpcWrapperPath),
+			"--sidecar-path", shellQuote(sidecarPath),
+			"--exit-summary-path", shellQuote(exitSummaryPath),
+			"--prompt-file", shellQuote(promptTmpFile),
+			"--extensions", shellQuote(taskRunnerExtPath),
+		].filter(Boolean).join(" ");
+	} else {
+		// ── Legacy mode: direct pi spawn (no telemetry) ─────────
+		piCommand = `${envParts} pi --no-session -e ${shellQuote(taskRunnerExtPath)}`;
+	}
 
 	// NOTE: Do not redirect lane output here. Shell redirection has proven
 	// fragile across Windows + tmux environments and can prevent session spawn.
 	// Diagnostics use tmux pane capture + STATUS tail in pollUntilTaskComplete().
-	const piCommand = basePiCommand;
 
 	const tmuxWorktreePath = toTmuxPath(worktreePath);
 	const wrappedCommand = `cd ${shellQuote(tmuxWorktreePath)} && ${piCommand}`;
@@ -550,8 +688,16 @@ export function spawnLaneSession(
 		// Best effort — session can still run without log file setup
 	}
 
-	// Build tmux args
-	const tmuxArgs = buildTmuxSpawnArgs(sessionName, lane.worktreePath, repoRoot, envVars, laneLogRelativePath);
+	// Generate telemetry file paths for RPC wrapper sidecar
+	const sidecarRoot = join(workspaceRoot || repoRoot, ".pi");
+	const telemetry = generateTelemetryPaths(sessionName, sidecarRoot, task.taskId);
+	execLog(laneId, task.taskId, "telemetry paths generated", {
+		sidecar: telemetry.sidecarPath,
+		exitSummary: telemetry.exitSummaryPath,
+	});
+
+	// Build tmux args (with RPC wrapper telemetry)
+	const tmuxArgs = buildTmuxSpawnArgs(sessionName, lane.worktreePath, repoRoot, envVars, laneLogRelativePath, telemetry.sidecarPath, telemetry.exitSummaryPath);
 
 	// Clean up stale session if exists
 	if (tmuxHasSession(sessionName)) {

package/extensions/taskplane/extension.ts

@@ -43,6 +43,7 @@ import {
 } from "./index.ts";
 import { buildExecutionContext } from "./workspace.ts";
 import { openSettingsTui } from "./settings-tui.ts";
+import { loadProjectConfig } from "./config-loader.ts";
 import {
 	activateSupervisor,
 	deactivateSupervisor,
@@ -767,10 +768,11 @@ export function validateModelAvailability(
 	runnerConfig: TaskRunnerConfig,
 	supervisorConfig: SupervisorConfig,
 	ctx: ExtensionContext,
+	agentModels?: { workerModel?: string; reviewerModel?: string },
 ): ModelCheckResult[] {
 	const entries: ModelCheckEntry[] = [
-		{ role: "Worker", modelStr: runnerConfig.worker?.model ?? "" },
-		{ role: "Reviewer", modelStr: runnerConfig.reviewer?.model ?? "" },
+		{ role: "Worker", modelStr: agentModels?.workerModel ?? (runnerConfig as any).worker?.model ?? "" },
+		{ role: "Reviewer", modelStr: agentModels?.reviewerModel ?? (runnerConfig as any).reviewer?.model ?? "" },
 		{ role: "Merger", modelStr: orchConfig.merge?.model ?? "" },
 		{ role: "Supervisor", modelStr: supervisorConfig.model ?? "" },
 	];
@@ -1401,7 +1403,18 @@ export default function (pi: ExtensionAPI) {
 			// Validate that all configured agent models are resolvable in
 			// the model registry before starting. Catches misconfigured
 			// model names early instead of failing hours into a batch.
-			const modelResults = validateModelAvailability(orchConfig, runnerConfig, supervisorConfig, ctx);
+			// Note: runnerConfig (TaskRunnerConfig) is a stripped type without
+			// worker/reviewer model fields. Load the full unified config to
+			// get the actual agent model strings (including user preferences).
+			let agentModels: { workerModel?: string; reviewerModel?: string } | undefined;
+			try {
+				const fullConfig = loadProjectConfig(execCtx!.repoRoot);
+				agentModels = {
+					workerModel: fullConfig.taskRunner.worker.model || "",
+					reviewerModel: fullConfig.taskRunner.reviewer.model || "",
+				};
+			} catch { /* fall through — validateModelAvailability handles empty strings */ }
+			const modelResults = validateModelAvailability(orchConfig, runnerConfig, supervisorConfig, ctx, agentModels);
 			const modelFailures = modelResults.filter(r => r.status === "not-found");
 			ctx.ui.notify(formatModelValidation(modelResults), modelFailures.length > 0 ? "error" : "info");
 			if (modelFailures.length > 0) {

package/extensions/taskplane/merge.ts

@@ -6,7 +6,7 @@ import { readFileSync, writeFileSync, existsSync, unlinkSync, copyFileSync, mkdi
 import { execSync, spawnSync } from "child_process";
 import { join, dirname, resolve, relative } from "path";
 
-import { buildLaneEnvVars, buildTmuxSpawnArgs, execLog, tmuxHasSession, tmuxKillSession, toTmuxPath } from "./execution.ts";
+import { buildLaneEnvVars, buildTmuxSpawnArgs, execLog, generateTelemetryPaths, resolveRpcWrapperPath, tmuxHasSession, tmuxKillSession, toTmuxPath } from "./execution.ts";
 import { resolveOperatorId } from "./naming.ts";
 import { MERGE_POLL_INTERVAL_MS, MERGE_RESULT_GRACE_MS, MERGE_RESULT_READ_RETRIES, MERGE_RESULT_READ_RETRY_DELAY_MS, MERGE_SPAWN_RETRY_MAX, MERGE_TIMEOUT_MAX_RETRIES, MERGE_TIMEOUT_MS, MergeError, VALID_MERGE_STATUSES } from "./types.ts";
 import type { AllocatedLane, LaneExecutionResult, MergeLaneResult, MergeResult, MergeResultStatus, MergeWaveResult, OrchestratorConfig, RepoMergeOutcome, TaskRunnerConfig, TransactionRecord, TransactionStatus, VerificationBaselineResult, WaveExecutionResult, WorkspaceConfig } from "./types.ts";
@@ -18,6 +18,58 @@ import { loadOrchestratorConfig } from "./config.ts";
 import { captureBaseline, diffFingerprints, runVerificationCommands, parseTestOutput, deduplicateFingerprints } from "./verification.ts";
 import type { VerificationBaseline, FingerprintDiff, TestFingerprint } from "./verification.ts";
 
+// ── Merge Telemetry Helpers ───────────────────────────────────────────
+
+import { userInfo } from "os";
+
+/**
+ * Generate telemetry file paths for a merge agent session.
+ *
+ * Naming: {opId}-{batchId}-{repoId}[-merge-w{N}-lane-{N}]-merger.{ext}
+ * Role is always "merger" to distinguish from worker/reviewer in the dashboard.
+ *
+ * @param sessionName  - TMUX session name (e.g., "orch-merge-1")
+ * @param sidecarRoot  - Root dir for sidecar files (e.g., <workspace>/.pi)
+ * @returns { sidecarPath, exitSummaryPath }
+ */
+function generateMergeTelemetryPaths(
+	sessionName: string,
+	sidecarRoot: string,
+): { sidecarPath: string; exitSummaryPath: string } {
+	const telemetryTs = Date.now();
+
+	// Resolve opId: same priority chain as execution.ts
+	let opId = "op";
+	const envOpId = process.env.TASKPLANE_OPERATOR_ID;
+	if (envOpId?.trim()) {
+		opId = envOpId.trim().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 12) || "op";
+	} else {
+		try {
+			const username = userInfo().username;
+			if (username?.trim()) {
+				opId = username.trim().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 12) || "op";
+			}
+		} catch { /* userInfo() can throw on some platforms */ }
+	}
+
+	const batchId = String(telemetryTs);
+	const repoId = "default";
+
+	// Extract merge-specific info from sessionName (e.g., "orch-merge-1")
+	const mergeMatch = sessionName.match(/merge-(\d+)/);
+	const mergeSuffix = mergeMatch ? `-merge-${mergeMatch[1]}` : "";
+
+	const role = "merger";
+	const telemetryBasename = `${opId}-${batchId}-${repoId}${mergeSuffix}-${role}`;
+	const telemetryDir = join(sidecarRoot, "telemetry");
+	if (!existsSync(telemetryDir)) mkdirSync(telemetryDir, { recursive: true });
+
+	return {
+		sidecarPath: join(telemetryDir, `${telemetryBasename}.jsonl`),
+		exitSummaryPath: join(telemetryDir, `${telemetryBasename}-exit.json`),
+	};
+}
+
 // ── Merge Implementation ─────────────────────────────────────────────
 
 /**
@@ -374,10 +426,10 @@ export async function spawnMergeAgent(
 		await sleepAsync(500);
 	}
 
-	// Build the pi command for the merge agent.
-	// Uses --no-session to prevent interactive session management.
-	// --append-system-prompt loads the merger agent definition.
-	// The merge request file is passed as a prompt via @file syntax.
+	// Build the merge agent command.
+	// Uses rpc-wrapper.mjs to produce structured telemetry (sidecar JSONL + exit summary).
+	// The merger agent definition is loaded via --system-prompt-file.
+	// The merge request is passed as the --prompt-file.
 	const shellQuote = (s: string): string => {
 		if (/[\s"'`$\\!&|;()<>{}#*?~]/.test(s)) {
 			return `'${s.replace(/'/g, "'\\''")}'`;
@@ -385,25 +437,43 @@ export async function spawnMergeAgent(
 		return s;
 	};
 
-	// Build model args if specified
-	const modelArgs = config.merge.model ? `--model ${shellQuote(config.merge.model)}` : "";
+	// Generate telemetry paths for this merge session
+	// Naming: {opId}-{batchId}-{repoId}-merger.jsonl (or with wave/lane info from sessionName)
+	const sidecarRoot = join(stateRoot ?? repoRoot, ".pi");
+	const telemetry = generateMergeTelemetryPaths(sessionName, sidecarRoot);
+	execLog("merge", sessionName, "telemetry paths generated", {
+		sidecar: telemetry.sidecarPath,
+		exitSummary: telemetry.exitSummaryPath,
+	});
+
+	// Resolve paths
+	const rpcWrapperPath = resolveRpcWrapperPath(repoRoot);
+	const systemPromptPath = agentRoot ? join(agentRoot, "task-merger.md") : join(stateRoot ?? repoRoot, ".pi", "agents", "task-merger.md");
+
+	// Build RPC wrapper command
+	const wrapperParts = [
+		"TERM=xterm-256color",
+		"node", shellQuote(rpcWrapperPath),
+		"--sidecar-path", shellQuote(telemetry.sidecarPath),
+		"--exit-summary-path", shellQuote(telemetry.exitSummaryPath),
+		"--prompt-file", shellQuote(mergeRequestPath),
+		"--system-prompt-file", shellQuote(systemPromptPath),
+	];
 
-	// Build tools override if specified
-	const toolsArgs = config.merge.tools ? `--tools ${shellQuote(config.merge.tools)}` : "";
+	// Add model args if specified
+	if (config.merge.model) {
+		wrapperParts.push("--model", shellQuote(config.merge.model));
+	}
+
+	// Add tools override if specified
+	if (config.merge.tools) {
+		wrapperParts.push("--tools", shellQuote(config.merge.tools));
+	}
 
-	const piCommand = [
-		"pi --no-session",
-		modelArgs,
-		toolsArgs,
-		`--append-system-prompt ${shellQuote(agentRoot ? join(agentRoot, "task-merger.md") : join(stateRoot ?? repoRoot, ".pi", "agents", "task-merger.md"))}`,
-		`@${shellQuote(mergeRequestPath)}`,
-	].filter(Boolean).join(" ");
+	const piCommand = wrapperParts.filter(Boolean).join(" ");
 
 	const tmuxMergeDir = toTmuxPath(mergeWorkDir);
-	// Pi's TUI (ink/react) hangs silently with TERM=tmux-256color (tmux default).
-	// Force xterm-256color so pi can render and start execution.
-	// Same fix as buildTmuxSpawnArgs / buildLaneEnvVars.
-	const wrappedCommand = `cd ${shellQuote(tmuxMergeDir)} && TERM=xterm-256color ${piCommand}`;
+	const wrappedCommand = `cd ${shellQuote(tmuxMergeDir)} && ${piCommand}`;
 	const tmuxArgs = [
 		"new-session", "-d",
 		"-s", sessionName,
@@ -449,7 +519,7 @@ export async function spawnMergeAgent(
 export function reloadMergeTimeoutMs(configRoot: string, pointerConfigRoot?: string): number {
 	try {
 		const freshConfig = loadOrchestratorConfig(configRoot, pointerConfigRoot);
-		const minutes = freshConfig.merge.timeout_minutes ?? 10;
+		const minutes = freshConfig.merge.timeout_minutes ?? 90;
 		return minutes * 60 * 1000;
 	} catch (err: unknown) {
 		// Config re-read is best-effort — fall back to default on failure

package/extensions/taskplane/supervisor.ts

@@ -2028,7 +2028,38 @@ When the conversation reaches the config generation phase, create ALL of these
 - \`.gitignore\` entries — add Taskplane working file patterns if not already present
 
 Use conservative creation: check if each file exists before writing. If files
-already exist (partial setup), read and merge rather than overwrite.`;
+already exist (partial setup), read and merge rather than overwrite.
+
+### CRITICAL: Task Area Registration
+
+**Every task folder MUST be registered in \`.pi/taskplane-config.json\` under
+\`taskRunner.taskAreas\`.** Without registration, \`/orch all\` will fail with
+"no task areas configured" — even if the folders and tasks physically exist.
+
+When creating a task folder (e.g., \`taskplane-tasks/\`):
+1. Create the folder and its \`CONTEXT.md\`
+2. Register it in \`.pi/taskplane-config.json\`:
+   \`\`\`json
+   {
+     "taskRunner": {
+       "taskAreas": {
+         "general": {
+           "path": "taskplane-tasks",
+           "prefix": "TP",
+           "context": "taskplane-tasks/CONTEXT.md"
+         }
+       }
+     }
+   }
+   \`\`\`
+3. **Verify** by reading the config back to confirm the area is registered
+
+When creating tasks inside an area, check that the area is registered first.
+If it's not (e.g., operator created the folder manually), register it before
+proceeding.
+
+This also applies when creating tasks later in the conversation — always verify
+the task area is registered in the config before offering to run \`/orch all\`.`;
 			break;
 
 		case "pending-tasks":
@@ -2068,7 +2099,14 @@ Follow the primer's **"Script 6: Batch Planning"** section
 5. **Offer a health check** (Script 7) if the operator prefers to assess
    project state rather than create tasks
 6. **Graceful fallback**: If \`gh\` CLI is unavailable, skip GitHub checks and
-   mention it to the operator — continue with CONTEXT.md and TODO scanning`;
+   mention it to the operator — continue with CONTEXT.md and TODO scanning
+
+### Important: Task Area Verification
+
+Before creating any tasks, verify that the target task area folder is registered
+in \`.pi/taskplane-config.json\` under \`taskRunner.taskAreas\`. If it's missing
+(e.g., the folder exists but was never registered), register it first. Without
+registration, \`/orch all\` will fail with "no task areas configured."`;
 			break;
 
 		case "completed-batch":
@@ -3045,11 +3083,16 @@ export function startHeartbeat(
 			return;
 		}
 
-		// Update heartbeat
+		// Update heartbeat (and refresh batchId if it was initially unknown)
 		try {
 			const lock = readLockfile(stateRoot);
 			if (lock && lock.sessionId === sessionId) {
 				lock.heartbeat = new Date().toISOString();
+				// TP-130: batchId may have been "(initializing)" at lock creation
+				// because the batch hadn't started yet. Refresh from live state ref.
+				if (state.batchStateRef?.batchId && lock.batchId !== state.batchStateRef.batchId) {
+					lock.batchId = state.batchStateRef.batchId;
+				}
 				writeLockfile(stateRoot, lock);
 			}
 		} catch {

package/extensions/taskplane/types.ts

@@ -182,7 +182,7 @@ export const DEFAULT_ORCHESTRATOR_CONFIG: OrchestratorConfig = {
 		tools: "read,write,edit,bash,grep,find,ls",
 		verify: [],
 		order: "fewest-files-first",
-		timeout_minutes: 10,
+		timeout_minutes: 90,
 	},
 	failure: {
 		on_task_failure: "skip-dependents",
@@ -1225,7 +1225,7 @@ export class MergeError extends Error {
  * is generous and covers verification (go build) on large codebases.
  */
 /** Default merge agent timeout. Use config.merge.timeout_minutes to override. */
-export const MERGE_TIMEOUT_MS = 10 * 60 * 1000;
+export const MERGE_TIMEOUT_MS = 90 * 60 * 1000;
 
 /**
  * Polling interval for merge result file (ms).

package/package.json

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

package/templates/agents/local/task-worker.md

@@ -13,8 +13,9 @@ name: task-worker
 
   The base prompt (maintained by taskplane) handles:
   - STATUS.md-first workflow and checkpoint discipline
-  - Fresh-context loop behavior and iteration rules
-  - Git commit conventions and .DONE file creation
+  - Multi-step execution (worker handles all remaining steps per invocation)
+  - Iteration recovery (context limit → next invocation resumes from STATUS.md)
+  - Git commit conventions (per-step commits) and .DONE file creation
   - Review response handling
 
   Add project-specific rules below. Common examples:

package/templates/agents/task-worker.md

@@ -1,21 +1,25 @@
 ---
 name: task-worker
-description: Autonomous task execution agent — works on individual steps with checkpoint discipline
+description: Autonomous task execution agent — works through remaining steps with checkpoint discipline
 tools: read,write,edit,bash,grep,find,ls
 # model:
 ---
-You are a task execution agent running in a **fresh-context loop**. Each time you
-are invoked, you have ZERO memory of prior invocations. STATUS.md on disk is your
-ONLY memory.
+You are a task execution agent. You may be invoked multiple times across
+iterations — each invocation starts with ZERO memory of prior ones.
+STATUS.md on disk is your ONLY memory.
+
+Your prompt tells you which steps remain. Work through them **in order**,
+completing each step before moving to the next.
 
 ## Resume Algorithm (MANDATORY — Do This First)
 
 1. Read STATUS.md completely
-2. Find the step you have been assigned (specified in your prompt)
+2. Find the **first incomplete step** listed in your prompt
 3. **Hydrate if needed** (see STATUS.md Hydration below)
 4. Within that step, find the **first unchecked checkbox** (`- [ ]`)
 5. Resume from there — do NOT redo checked items (`- [x]`)
-6. If all items in your assigned step are checked, report completion
+6. When a step's items are all checked, proceed to the next incomplete step
+7. If all steps are complete, report completion
 
 ## Checkpoint Discipline (CRITICAL)
 
@@ -68,9 +72,9 @@ dozens of micro-commits that nobody reads.
 
 STATUS.md is the worker's memory, not git. Checking off items in STATUS.md
 ensures the next worker iteration knows where to resume. Git commits preserve
-file changes at meaningful milestones. Per-checkbox commits waste tool calls
-on git housekeeping without adding recovery value — the files are already on
-disk in the worktree.
+file changes at meaningful milestones — one per completed step. Per-checkbox
+commits waste tool calls on git housekeeping without adding recovery value —
+the files are already on disk in the worktree.
 
 ## STATUS.md Hydration (MANDATORY)
 
@@ -94,7 +98,7 @@ instead of solving the problem.
 
 Before implementing anything, assess whether the step needs expansion:
 
-1. **Read the PROMPT.md step details** for your assigned step
+1. **Read the PROMPT.md step details** for the step you're entering
 2. **Look for `⚠️ Hydrate` markers** — these signal the task creator expected
    you to expand based on runtime discoveries
 3. **If expansion is needed**, add checkboxes for **distinct outcomes** you've
@@ -149,9 +153,9 @@ When a reviewer returns REVISE with specific feedback items:
 
 ## Scope Rules
 
-- Work ONLY on the step assigned in your prompt
-- Do NOT proceed to other steps
-- Do NOT expand task scope
+- Work through all remaining steps listed in your prompt, **in order**
+- Do NOT skip ahead — complete each step before starting the next
+- Do NOT expand task scope beyond what the steps require
 - If you discover something out of scope, note it in STATUS.md Discoveries table
 
 ## Self-Documentation

package/templates/config/task-orchestrator.yaml

@@ -77,7 +77,7 @@ merge:
   order: "fewest-files-first"
 
   # Merge agent timeout in minutes. Increase for large batches with many files.
-  timeout_minutes: 10
+  timeout_minutes: 90
 
 # ── Failure Handling ──────────────────────────────────────────────────
 

package/templates/config/task-runner.yaml

@@ -57,9 +57,9 @@ reviewer:
   thinking: "off"
 
 context:
-  worker_context_window: 200000
-  warn_percent: 70
-  kill_percent: 85
+  # worker_context_window: 200000  # 0 or omit = auto-detect from model registry; set explicitly to override
+  warn_percent: 85
+  kill_percent: 95
   max_worker_iterations: 20
   max_review_cycles: 2
   no_progress_limit: 3