taskplane 0.26.1 → 0.28.0

package/README.md

@@ -71,14 +71,17 @@ pi install -l npm:taskplane
 ## Quickstart
 
 ### 1. Initialize a project (to scaffold settings)
+This step assumes you have installed Taskplane using one of the above options. 
+
 (NOTE: if 'my-project' is a monorepo, be sure to run git init first. Taskplane uses git worktrees to isolate agent coding until you're ready to merge back to your default branch.)
+
 ```bash
 cd my-project
 taskplane init
 ```
 You'll answer a few questions. You can usually just accept the defaults. 
 
-This creates config files in `.pi/`, agent prompts, two example tasks, and adds `.gitignore` entries for runtime artifacts. On first install, init bootstraps global preferences at `~/.pi/agent/taskplane/preferences.json` with thinking defaults set to `high` for worker & reviewer, and off for merger. Init auto-detects whether you're in a single repo or a multi-repo workspace. See the [install tutorial](docs/tutorials/install.md) for workspace mode and other scenarios.
+This creates: config files in `.pi/`, agent prompts, two example tasks, and adds `.gitignore` entries for runtime artifacts. On first install, init bootstraps global preferences at `~/.pi/agent/taskplane/preferences.json` with thinking defaults set to `high` for worker & reviewer, and off for merger. Init auto-detects whether you're in a monorepo or a polyrepo workspace. See the [install tutorial](docs/tutorials/install.md) for workspace mode and other scenarios.
 
 Already have a task folder (for example `docs/task-management`)? Use:
 

package/bin/taskplane.mjs

@@ -787,18 +787,24 @@ export async function collectInitAgentConfig({
 	return initAgentConfig;
 }
 
+/** Normalize a path string to forward slashes (for config file output). */
+function fwdSlash(p) {
+	return typeof p === "string" ? p.replace(/\\/g, "/") : p;
+}
+
 export function generateProjectConfig(vars, _initAgentConfig = null) {
+	const tasksRoot = fwdSlash(vars.tasks_root);
 	const projectConfig = {
 		configVersion: 1,
 		taskRunner: {
 			project: { name: vars.project_name, description: "" },
-			paths: { tasks: vars.tasks_root },
+			paths: { tasks: tasksRoot },
 			testing: { commands: buildTestingCommands(vars) },
 			taskAreas: {
 				[vars.default_area]: {
-					path: vars.tasks_root,
+					path: tasksRoot,
 					prefix: vars.default_prefix,
-					context: `${vars.tasks_root}/CONTEXT.md`,
+					context: `${tasksRoot}/CONTEXT.md`,
 				},
 			},
 		},
@@ -820,10 +826,11 @@ export function generateProjectConfig(vars, _initAgentConfig = null) {
 }
 
 function generateWorkspaceYaml(repoNames, defaultRepo, tasksRoot) {
+	const normalizedTasksRoot = fwdSlash(tasksRoot);
 	const reposBlock = repoNames
 		.map((name) => `  ${name}:\n    path: "${name}"`)
 		.join("\n");
-	return `repos:\n${reposBlock}\nrouting:\n  tasks_root: "${tasksRoot}"\n  default_repo: "${defaultRepo}"\n  task_packet_repo: "${defaultRepo}"\n`;
+	return `repos:\n${reposBlock}\nrouting:\n  tasks_root: "${normalizedTasksRoot}"\n  default_repo: "${defaultRepo}"\n  task_packet_repo: "${defaultRepo}"\n`;
 }
 
 function readWorkspaceJson(configRepoRoot) {
@@ -1923,7 +1930,7 @@ async function cmdInit(args) {
 				default_branch: "main",
 			})),
 			routing: {
-				tasks_root: vars.tasks_root,
+				tasks_root: fwdSlash(vars.tasks_root),
 				default_repo: configRepoName,
 				strict: false,
 			},

package/dashboard/public/app.js

@@ -699,21 +699,30 @@ function renderLanesTasks(batch, sessions) {
       const showPacketHome = !!packetHomeRepo && packetHomeRepo !== (tRepo || lane.repoId || "");
 
       // Progress cell
+      // TP-174: Prefer V2 snapshot progress (segment-scoped when available)
+      // over full STATUS.md counts when the task is actively running on this lane.
+      // TP-176: Succeeded tasks always show 100% regardless of sidecar/statusData (#491).
       let progressHtml = "";
-      if (sd) {
-        const fillClass = pctClass(sd.progress);
+      const v2p = ls && ls._v2Progress;
+      const useV2 = v2p && v2p.total > 0 && ls.taskId === task.taskId;
+      if (task.status === "succeeded") {
+        // #491 fix: succeeded tasks always show 100%
         progressHtml = `
           <div class="task-progress">
-            <div class="task-progress-bar">
-              <div class="task-progress-fill ${fillClass}" style="width:${sd.progress}%"></div>
-            </div>
-            <span class="task-progress-text">${sd.progress}% ${sd.checked}/${sd.total}</span>
+            <div class="task-progress-bar"><div class="task-progress-fill pct-hi" style="width:100%"></div></div>
+            <span class="task-progress-text">100%</span>
           </div>`;
-      } else if (task.status === "succeeded") {
+      } else if (sd || useV2) {
+        const displayChecked = useV2 ? v2p.checked : (sd ? sd.checked : 0);
+        const displayTotal = useV2 ? v2p.total : (sd ? sd.total : 0);
+        const displayProgress = displayTotal > 0 ? Math.round((displayChecked / displayTotal) * 100) : 0;
+        const fillClass = pctClass(displayProgress);
         progressHtml = `
           <div class="task-progress">
-            <div class="task-progress-bar"><div class="task-progress-fill pct-hi" style="width:100%"></div></div>
-            <span class="task-progress-text">100%</span>
+            <div class="task-progress-bar">
+              <div class="task-progress-fill ${fillClass}" style="width:${displayProgress}%"></div>
+            </div>
+            <span class="task-progress-text">${displayProgress}% ${displayChecked}/${displayTotal}</span>
           </div>`;
       } else if (task.status === "pending") {
         progressHtml = `
@@ -1881,6 +1890,127 @@ function renderV2Event(evt) {
   }
 }
 
+// ── Segment-Scoped STATUS.md Helpers (TP-176) ──────────────────────────────
+
+/**
+ * Resolve the active segment repoId for a given task.
+ * Uses runtimeLaneSnapshots (active segment) and falls back to
+ * taskSegmentProgress (batch state).
+ * Returns { repoId, segmentInfo } or null if single-segment / unresolvable.
+ */
+function resolveActiveSegmentForTask(taskId) {
+  if (!currentData) return null;
+  const batch = currentData.batch;
+  if (!batch) return null;
+  const task = (batch.tasks || []).find(t => t.taskId === taskId);
+  if (!task) return null;
+  const segmentIds = Array.isArray(task.segmentIds) ? task.segmentIds.filter(id => typeof id === "string") : [];
+  if (segmentIds.length <= 1) return null; // single-segment or no segments
+
+  // Try to get active segment from runtime lane snapshots
+  const v2Snapshots = currentData.runtimeLaneSnapshots || {};
+  for (const snap of Object.values(v2Snapshots)) {
+    if (snap && snap.taskId === taskId && snap.segmentId) {
+      const parsed = parseSegmentId(snap.segmentId);
+      if (parsed) {
+        const idx = segmentIds.indexOf(snap.segmentId);
+        return {
+          repoId: parsed.repoId,
+          segmentInfo: {
+            index: idx >= 0 ? idx + 1 : null,
+            total: segmentIds.length,
+            repoId: parsed.repoId,
+            segmentId: snap.segmentId,
+          },
+        };
+      }
+    }
+  }
+
+  // Fallback: use taskSegmentProgress (batch state)
+  const segmentStatusMap = buildSegmentStatusMap(batch);
+  const info = taskSegmentProgress(task, segmentStatusMap, null);
+  if (info && info.repoId) {
+    return { repoId: info.repoId, segmentInfo: info };
+  }
+  return null;
+}
+
+/**
+ * Filter STATUS.md content to show only the active segment's blocks.
+ * Within each `### Step N:` section, removes `#### Segment: <otherRepo>` blocks
+ * and keeps only the block matching `activeRepoId`.
+ * Non-step content (metadata, notes, reviews, etc.) is preserved.
+ *
+ * Returns the filtered markdown string, or the original if no segment markers found.
+ */
+function filterStatusMdForSegment(markdown, activeRepoId) {
+  if (!activeRepoId) return markdown;
+  const lines = markdown.split('\n');
+  const result = [];
+  let inStep = false;          // inside a ### Step section
+  let inSegmentBlock = false;  // inside a #### Segment: <repo> block
+  let segmentMatch = false;    // current segment block matches active repo
+  let foundAnySegmentHeader = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Detect step headers: ### Step N: ...
+    if (/^###\s+Step\s+\d+/.test(line)) {
+      inStep = true;
+      inSegmentBlock = false;
+      segmentMatch = false;
+      result.push(line);
+      continue;
+    }
+
+    // Detect non-step ### headers (e.g., ### Reviews, ### Notes)
+    if (/^###\s+/.test(line) && !/^###\s+Step\s+\d+/.test(line)) {
+      inStep = false;
+      inSegmentBlock = false;
+      segmentMatch = false;
+      result.push(line);
+      continue;
+    }
+
+    // Inside a step section, detect #### Segment: <repoId> headers
+    if (inStep && /^####\s+Segment:\s*/.test(line)) {
+      foundAnySegmentHeader = true;
+      const segRepo = line.replace(/^####\s+Segment:\s*/, '').trim();
+      inSegmentBlock = true;
+      segmentMatch = (segRepo === activeRepoId);
+      if (segmentMatch) {
+        result.push(line);
+      }
+      continue;
+    }
+
+    // Detect any other #### header (ends current segment block)
+    if (/^####\s+/.test(line)) {
+      inSegmentBlock = false;
+      segmentMatch = false;
+      result.push(line);
+      continue;
+    }
+
+    // If we're in a segment block, only include matching lines
+    if (inSegmentBlock) {
+      if (segmentMatch) {
+        result.push(line);
+      }
+      continue;
+    }
+
+    // Outside segment blocks: keep the line
+    result.push(line);
+  }
+
+  // If no segment headers were found, return original (fallback for single-segment)
+  if (!foundAnySegmentHeader) return markdown;
+  return result.join('\n');
+}
+
 // ── Open STATUS.md viewer ───────────────────────────────────────────────────
 
 function viewStatusMd(taskId) {
@@ -1897,7 +2027,15 @@ function viewStatusMd(taskId) {
   autoScrollOn = false;
   lastStatusMdText = '';
 
-  $terminalTitle.textContent = `STATUS.md — ${taskId}`;
+  // TP-176: Include segment context in title for multi-segment tasks
+  const segData = resolveActiveSegmentForTask(taskId);
+  if (segData && segData.segmentInfo) {
+    const label = segmentProgressText(segData.segmentInfo);
+    $terminalTitle.textContent = `STATUS.md — ${taskId} · ${label}`;
+  } else {
+    $terminalTitle.textContent = `STATUS.md — ${taskId}`;
+  }
+
   $autoScrollText.textContent = 'Track progress';
   $autoScrollCheckbox.checked = false;
   $terminalPanel.style.display = '';
@@ -1916,11 +2054,22 @@ function pollStatusMd() {
       return r.text();
     })
     .then(text => {
+      // TP-176: Apply segment-scoped filtering for multi-segment tasks.
+      // Re-resolve on each poll since the active segment may change.
+      const segData = resolveActiveSegmentForTask(viewerTarget);
+      let displayText = text;
+      if (segData && segData.repoId) {
+        displayText = filterStatusMdForSegment(text, segData.repoId);
+        // Update title with current segment context (may change between polls)
+        const label = segmentProgressText(segData.segmentInfo);
+        $terminalTitle.textContent = `STATUS.md \u2014 ${viewerTarget} \u00b7 ${label}`;
+      }
+
       // Diff-and-skip: no change, no DOM update
-      if (text === lastStatusMdText) return;
-      lastStatusMdText = text;
+      if (displayText === lastStatusMdText) return;
+      lastStatusMdText = displayText;
 
-      const { html, hasLastChecked } = renderStatusMd(text);
+      const { html, hasLastChecked } = renderStatusMd(displayText);
       $terminalBody.innerHTML = html;
 
       // Update tracking highlight

package/extensions/taskplane/abort.ts

@@ -85,7 +85,8 @@ export function selectAbortTargetSessions(
 			laneId: lane.laneId,
 			taskId: currentTask?.taskId || null,
 			worktreePath: lane.worktreePath,
-			taskFolder: currentTask?.task.taskFolder || null,
+			// TP-169: Guard against null task stubs from reconstructAllocatedLanes
+			taskFolder: currentTask?.task?.taskFolder || null,
 		});
 	}
 

package/extensions/taskplane/agent-host.ts

@@ -136,6 +136,23 @@ export interface AgentHostOptions {
 	packet?: PacketPaths | null;
 	/** Extra environment variables for the child process */
 	env?: Record<string, string>;
+	/**
+	 * Callback invoked when agent_end fires, before stdin is closed.
+	 * Receives the last assistant message text.
+	 * Return a string to send as a new prompt (re-prompt the agent),
+	 * or null to close the session normally.
+	 *
+	 * @since TP-172
+	 */
+	onPrematureExit?: (assistantMessage: string) => Promise<string | null>;
+	/**
+	 * Maximum number of exit interceptions before forcing session close.
+	 * Prevents infinite loops where the callback always returns a new prompt.
+	 * Default: 2
+	 *
+	 * @since TP-172
+	 */
+	maxExitInterceptions?: number;
 }
 
 /**
@@ -235,6 +252,7 @@ export function spawnAgent(
 	const cliPath = resolvePiCliPath();
 	const closeDelayMs = opts.closeDelayMs ?? 100;
 	const timeoutMs = opts.timeoutMs ?? 0;
+	const maxExitInterceptions = opts.maxExitInterceptions ?? 3;
 
 	// Build Pi CLI arguments
 	const piArgs: string[] = [cliPath, "--mode", "rpc", "--no-session"];
@@ -275,6 +293,12 @@ export function spawnAgent(
 	let contextUsage: AgentHostResult["contextUsage"] = null;
 	let stderrBuffer = "";
 	const STDERR_MAX = 2048;
+	/** Last assistant message text captured from message_end events (TP-172) */
+	let lastAssistantMessage = "";
+	/** Number of times exit interception has occurred (TP-172) */
+	let exitInterceptionCount = 0;
+	/** Whether the current turn had any tool calls (TP-172: text-only gate) */
+	let currentTurnHadToolCalls = false;
 
 	// Timeout
 	let timeoutHandle: ReturnType<typeof setTimeout> | null = null;
@@ -538,6 +562,8 @@ export function spawnAgent(
 							const content = extractAssistantText(event.message);
 							if (content) {
 								emitEvent("assistant_message", { text: truncatePayload(content, MAX_CONV_PAYLOAD_CHARS) });
+								// TP-172: Track last assistant message for exit interception
+								lastAssistantMessage = content;
 							}
 						}
 						// Request session stats immediately on first assistant message,
@@ -560,6 +586,7 @@ export function spawnAgent(
 					}
 					case "tool_execution_start": {
 						toolCalls++;
+						currentTurnHadToolCalls = true;
 						const toolName = event.toolName || "tool";
 						const argPreview = typeof event.args === "string" ? event.args.slice(0, 300) :
 							(event.args && typeof Object.values(event.args)[0] === "string" ? String(Object.values(event.args)[0]).slice(0, 300) : "");
@@ -602,7 +629,79 @@ export function spawnAgent(
 					}
 					case "agent_end": {
 						agentEnded = true;
-						closeStdin();
+						// TP-172: Exit interception — intercept any exit when callback
+						// is provided and under limit. The callback (lane-runner) decides
+						// whether the worker made progress. We don't gate on tool calls
+						// because workers commonly use tools (reads/greps) then exit
+						// with a text declaration ("Now let me fix this:") without
+						// actually making the edit.
+						const shouldIntercept = opts.onPrematureExit
+							&& exitInterceptionCount < maxExitInterceptions;
+						if (shouldIntercept) {
+							exitInterceptionCount++;
+							const INTERCEPTION_TIMEOUT_MS = 120_000; // 2 minute safety timeout
+							// Wrap in Promise.resolve().then() to catch synchronous throws
+							const interceptPromise = Promise.resolve().then(() =>
+								opts.onPrematureExit!(lastAssistantMessage));
+							const timeoutPromise = new Promise<null>((res) =>
+								setTimeout(() => res(null), INTERCEPTION_TIMEOUT_MS));
+							Promise.race([interceptPromise, timeoutPromise])
+								.then(
+									(newPrompt: string | null) => {
+										if (newPrompt && !stdinClosed && proc.stdin && !proc.stdin.destroyed) {
+											// Re-prompt the agent with supervisor guidance
+											agentEnded = false; // Reset for the new turn
+											currentTurnHadToolCalls = false; // Reset for new turn
+											proc.stdin.write(JSON.stringify({ type: "prompt", message: newPrompt }) + "\n");
+											emitEvent("exit_intercepted", {
+												interceptionCount: exitInterceptionCount,
+												assistantMessage: truncatePayload(lastAssistantMessage, 500),
+												supervisorConsulted: true,
+												action: "reprompt",
+												newPromptPreview: truncatePayload(newPrompt, MAX_CONV_PAYLOAD_CHARS),
+											});
+										} else {
+											// Callback returned null or stdin already closed — close session
+											const reason = stdinClosed ? "stdin_closed"
+												: newPrompt === null ? "callback_returned_null"
+												: "unknown";
+											emitEvent("exit_intercepted", {
+												interceptionCount: exitInterceptionCount,
+												assistantMessage: truncatePayload(lastAssistantMessage, 500),
+												supervisorConsulted: true,
+												action: "close",
+												reason,
+											});
+											closeStdin();
+										}
+									},
+									(err: unknown) => {
+										// Callback rejected — emit single diagnostic event and close
+										const msg = err instanceof Error ? err.message : String(err);
+										emitEvent("exit_intercepted", {
+											interceptionCount: exitInterceptionCount,
+											assistantMessage: truncatePayload(lastAssistantMessage, 500),
+											supervisorConsulted: false,
+											action: "close",
+											reason: "callback_error",
+											error: msg,
+										});
+										closeStdin();
+									},
+								);
+						} else {
+							// No callback, had tool calls, or interception limit reached — close normally
+							if (opts.onPrematureExit && exitInterceptionCount >= maxExitInterceptions) {
+								emitEvent("exit_intercepted", {
+									interceptionCount: exitInterceptionCount,
+									assistantMessage: truncatePayload(lastAssistantMessage, 500),
+									supervisorConsulted: false,
+									action: "close",
+									reason: "max_interceptions_reached",
+								});
+							}
+							closeStdin();
+						}
 						break;
 					}
 				}