pi-orchestrator-config 4.3.14 → 4.4.0

package/README.md

@@ -263,14 +263,16 @@ model contract. It does not filter discovery results or claim that the endpoint
 
 `review_loop_enforcement` controls automatic review-agent dispatch and commit enforcement.
 
-- `true` automatically dispatches 6 agents in parallel (5 reviewers + `test-automator`) after code changes and requires a clean review before commits.
+- `true` automatically dispatches 6 agents in parallel (5 reviewers + `test-runner`) after code changes and requires a clean review before commits.
 - `false` disables automatic review-agent and test-agent dispatch. Manual reviews and test runs are optional. No review state, cycle, or result is required before commit.
 
 When `review_loop_enforcement` is enabled, the loop stops once all reviewers approve with 0 findings and tests pass
-(`tests_passed: true` in `pi-config-review-state.jsonl`), OR after `review_loop_max_cycles` total cycles (default `3`,
+(`tests_passed: true` in `pi-config-review-state.jsonl`). `tests_passed` is set only by a detected
+successful test command; completion of async `test-runner` or `test-automator` agents does not set it.
+OR after `review_loop_max_cycles` total cycles (default `3`,
 valid integers `1`-`10`; env: digit string `"1"`-`"10"` only (after trim)) — whichever comes first. Each cycle
 always completes fix/explain (5a) before the cap check; the cap only blocks re-dispatch
-(step 2 / all 6 agents, including test-automator), not responding to findings.
+(step 2 / all 6 agents, including test-runner), not responding to findings.
 At cap, report **Not fixed** (explained why not → outstanding) vs **Fixed**
 (verification blocked by the cap — cannot re-dispatch to confirm clean). Invalid values (including non-digit
 forms like `"10.0"` / `"1e1"`) fall through to the next resolution layer / default `3`. Disable the review loop via

package/agents/test-runner.md

@@ -32,7 +32,7 @@ You are a specialized test execution agent. Run tests and provide concise failur
 Failed Test 1: test_name (file:line)
 Expected: [brief description]
 Actual: [brief description]
-Fix location: path/to/file.rb:line
+Fix location: path/to/file:line
 Suggested approach: [one line]
 
 Returning control for fixes.

package/extensions/orchestrator/async-agents.ts

@@ -16,7 +16,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { AgentConfig, AgentDiscoveryResult } from "./agents.js";
 import { resolveAgentModelProvider } from "./resolve-agent-model.js";
 import { getPiInvocation, getProjectTmpDir, parseProcStartTime, djb2Hash } from "./utils.js";
-import { addReviewerPending, recordReviewerResult, countFindings, readReviewState, markTestsPassed, markTestsFailed } from "./pi-config-review-state.js";
+import { addReviewerPending, recordReviewerResult, countFindings, readReviewState } from "./pi-config-review-state.js";
 import {
   getMainBranch,
 } from "./git-helpers.js";
@@ -337,9 +337,6 @@ export function registerAsyncAgents(
                     const findings = countFindings(typeof data.output === "string" ? data.output : "");
                     try { recordReviewerResult(jobCwd(job), job.agent, findings < 0 ? 1 : findings); } catch (e: any) { zombieSideEffectsOk = false; log.error(`recordReviewerResult failed for ${job.agent}: ${e?.message}`); }
                   }
-                  if (job.agent === "test-automator" || job.agent === "test-runner") {
-                    try { job.status === "complete" ? markTestsPassed(jobCwd(job)) : markTestsFailed(jobCwd(job)); } catch (e: any) { zombieSideEffectsOk = false; log.error(`markTests failed for ${job.agent}: ${e?.message}`); }
-                  }
                   if (zombieSideEffectsOk) job.sideEffectsApplied = true;
                   try { fs.unlinkSync(resultFilePath); } catch {}
                 } catch {
@@ -405,9 +402,6 @@ export function registerAsyncAgents(
               const findings = countFindings(typeof job.output === "string" ? job.output : "");
               try { recordReviewerResult(jobCwd(job), job.agent, findings < 0 ? 1 : findings); } catch (e: any) { sideEffectsOk = false; log.error(`reconcile: recordReviewerResult failed for ${job.agent}: ${e?.message}`); }
             }
-            if (job.agent === "test-automator" || job.agent === "test-runner") {
-              try { job.status === "complete" ? markTestsPassed(jobCwd(job)) : markTestsFailed(jobCwd(job)); } catch (e: any) { sideEffectsOk = false; log.error(`reconcile: markTests failed for ${job.agent}: ${e?.message}`); }
-            }
             if (sideEffectsOk) job.sideEffectsApplied = true;
           }
           // Delivery: retry for groups where all members are done
@@ -548,18 +542,6 @@ export function registerAsyncAgents(
       } catch (e: any) { j.sideEffectsApplied = false; log.error(`recordReviewerResult failed for ${j.agent}: ${e?.message}`); continue; }
     }
 
-    // Track test agent completions for grouped test-automator/test-runner
-    for (const j of groupJobs) {
-      if (j.agent !== "test-automator" && j.agent !== "test-runner") continue;
-      try {
-        if (j.status === "complete") {
-          markTestsPassed(jobCwd(j));
-        } else if (j.status === "failed") {
-          markTestsFailed(jobCwd(j));
-        }
-      } catch (e: any) { j.sideEffectsApplied = false; log.error(`markTests failed for ${j.agent}: ${e?.message}`); continue; }
-    }
-
     // Mark side-effects applied per-job (only if not already marked false by a failed side-effect above)
     for (const j of groupJobs) {
       if (j.sideEffectsApplied !== false) j.sideEffectsApplied = true;
@@ -738,17 +720,6 @@ export function registerAsyncAgents(
         }
       }
 
-      // Track test agent completion for review state test tracking
-      if (job.agent === "test-automator" || job.agent === "test-runner") {
-        try {
-          if (data.success) {
-            markTestsPassed(jobCwd(job));
-          } else {
-            markTestsFailed(jobCwd(job));
-          }
-        } catch (e: any) { processResultSideEffectsOk = false; log.error(`markTests(Passed|Failed) failed for ${job.agent}: ${e?.message}`); }
-      }
-
       if (processResultSideEffectsOk) job.sideEffectsApplied = true;
 
       // Always delete result file after ingestion — data is in memory (job.output).

package/extensions/orchestrator/enforcement-helpers.ts

@@ -812,7 +812,7 @@ function bodyAlreadySigned(text: string): boolean {
 
 /** Unresolved model placeholders are stale template footers, not signatures. */
 function replaceUnresolvedModelFooters(payload: string): string {
-  const unresolvedFooter = /(?:\n|\\n){2}---(?:\n|\\n)\*Assisted-by: PI \((?:\$PI_MODEL|\$\{PI_MODEL\})\)\*/g;
+  const unresolvedFooter = /(?:\n|\\n){2}---(?:\n|\\n)\*Assisted-by: PI \((?:\$PI_MODEL|\$\{PI_MODEL(?::-unknown)?\})\)\*/g;
   const replaced = payload.replace(unresolvedFooter, "");
   if (replaced !== payload)
     enfLog.debug("injectGhBodySignature replaced unresolved PI_MODEL footer");
@@ -939,7 +939,9 @@ export function injectGhBodySignature(command: string, signature: string): strin
 
 /**
  * Detect common test runner commands — require command-start position
- * (after &&, |, ;, or line start) to avoid false positives from install/grep/cat commands.
+ * (after &&, |, ;, a newline, or line start) to avoid false positives from install/grep/cat commands.
+ * `pre-commit` counts only when its `run` subcommand is executed; setup and information
+ * commands must not mark tests as passed.
  * NOTE: For compound commands (e.g., pytest && other_cmd), if the non-test part fails,
  * isError=true marks tests as failed even though pytest passed. This is the conservative/safe
  * direction — re-run the test command standalone to mark tests_passed.
@@ -947,11 +949,14 @@ export function injectGhBodySignature(command: string, signature: string): strin
  * match — we exclude tox with explicit -e to avoid marking lint/docs runs as test passes.
  */
 export function isTestRunnerCommand(command: string): boolean {
-  return /(?:^|[;&|]\s*)(?:uv\s+run\s+(?:--\S+(?:\s+\S+)?\s+)*)?(?:pytest|vitest|jest|mocha)\b/.test(command)
+  const result = /(?:^|[;&|]\s*)(?:uv\s+run\s+(?:--\S+(?:\s+\S+)?\s+)*)?(?:pytest|vitest|jest|mocha)\b/.test(command)
     || /(?:^|[;&|]\s*)(?:uv\s+run\s+(?:--\S+(?:\s+\S+)?\s+)*)?tox\b(?!\s*-e)(?!\s+--(?:help|version|list))/.test(command)
     || /(?:^|[;&|]\s*)go\s+test\b/.test(command)
     || /(?:^|[;&|]\s*)npm\s+test\b/.test(command)
-    || /(?:^|[;&|]\s*)npx\s+tsx\s+--test\b/.test(command);
+    || /(?:^|[;&|]\s*)npx\s+tsx\s+--test\b/.test(command)
+    || /(?:^|[;&|\n]\s*)pre-commit\s+run\b/.test(command);
+  enfLog.debug("isTestRunnerCommand", result);
+  return result;
 }
 
 /** True for release bump branches: chore/bump-version-<digit>... */

package/extensions/orchestrator/pi-config-review-state.ts

@@ -289,7 +289,7 @@ export function markTestsPassed(cwd: string): void {
 }
 
 /** Mark that tests have failed. No-op when review status is not being tracked.
- *  Called when a detected test command exits non-zero, or test-automator/test-runner agent fails.
+ *  Called when a detected test command exits non-zero.
  *  Resets to false on any file edit via markNeedsReview(). */
 export function markTestsFailed(cwd: string): void {
   withStateLock(cwd, (state) => {

package/extensions/orchestrator/task-lifecycle.ts

@@ -50,7 +50,11 @@ export async function autoCompleteTask(taskId: string, cwd: string, sessionId?:
   try {
     const task = store.get(taskId);
     if (!task) return false;
-    if (task.status !== "completed") { store.update(taskId, { status: "completed" }); return true; }
+    if (task.status !== "completed") {
+      store.update(taskId, { status: "completed" });
+      (await import("../pitasks/index.js")).setTaskTelemetryActive(taskId, false);
+      return true;
+    }
     return false;
   } catch (e: any) {
     log.debug("autoCompleteTask failed for task", taskId, e?.message?.slice(0, 100));
@@ -89,7 +93,11 @@ export async function autoMarkInProgress(taskId: string, cwd: string, sessionId?
   try {
     const task = store.get(taskId);
     if (!task) return false;
-    if (task.status === "pending") { store.update(taskId, { status: "in_progress" }); return true; }
+    if (task.status === "pending") {
+      store.update(taskId, { status: "in_progress" });
+      (await import("../pitasks/index.js")).setTaskTelemetryActive(taskId);
+      return true;
+    }
     return false;
   } catch (e: any) {
     log.debug("autoMarkInProgress failed for task", taskId, e?.message?.slice(0, 100));

package/extensions/pidiff/pidiff-ui/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pidiff-ui",
   "private": true,
-  "version": "4.3.14",
+  "version": "4.4.0",
   "type": "module",
   "scripts": {
     "dev": "vite",

package/extensions/pitasks/index.ts

@@ -32,7 +32,12 @@ const log = createLogger("pitasks");
 
 // Module-level refs — survive closure replacement on /reload
 let currentUiCtx: any = null;
+let currentStore: TaskStore | null = null;
 let currentWidget: TaskWidget | null = null;
+export function setTaskTelemetryActive(taskId: string, active = true): void {
+	log.debug("task_telemetry_active", { taskId, active });
+	currentWidget?.setActiveTask(taskId, active);
+}
 
 /** Exported store instance — set during extension init. */
 export let taskStore: TaskStore;
@@ -54,7 +59,10 @@ export function listTasks(): any[] {
 
 /** Update a task — for use by other extensions. */
 export function updateTask(id: string, fields: any): any {
-	return taskStore.update(id, fields);
+	log.debug("task_updated", { taskId: id, fieldNames: Object.keys(fields) });
+	const result = taskStore.update(id, fields);
+	if (result.changedFields.includes("status")) setTaskTelemetryActive(id, fields.status === "in_progress");
+	return result;
 }
 
 /** Delete a task — for use by other extensions. */
@@ -66,58 +74,93 @@ export function deleteTask(id: string): boolean {
 
 /** Create a task on a specific session's store. Used by coms for sender-side task creation. */
 export function createTaskForSession(sessionId: string, subject: string, description: string, createdBy?: any, metadata?: Record<string, any>, targetCwd?: string, activeForm?: string): any {
+	log.debug("session_task_created", { sessionId });
 	const base = targetCwd || process.cwd();
 	const storePath = join(base, ".pi", "tasks", `tasks-${sessionId.replace(/[/\\]/g, "_")}.json`);
 	const store = new TaskStore(storePath);
-	return store.create(subject, description, createdBy || { type: "local", origin: "system", session: "", project: "" }, activeForm, metadata);
+	try {
+		return store.create(subject, description, createdBy || { type: "local", origin: "system", session: "", project: "" }, activeForm, metadata);
+	} finally {
+		store.close();
+	}
 }
 
 /** Create multiple tasks on a specific session's store. Used by coms for bulk task creation. */
 export function createTasksForSession(sessionId: string, tasks: Array<{ subject: string; description: string; createdBy: any; blockedBy?: string[]; activeForm?: string; metadata?: Record<string, any> }>, targetCwd?: string): any[] {
+	log.debug("session_tasks_created", { sessionId, count: tasks.length });
 	const base = targetCwd || process.cwd();
 	const storePath = join(base, ".pi", "tasks", `tasks-${sessionId.replace(/[/\\]/g, "_")}.json`);
 	const store = new TaskStore(storePath);
-	return store.createTasks(tasks);
+	try {
+		return store.createTasks(tasks);
+	} finally {
+		store.close();
+	}
 }
 
 /** Get a task from a specific session's store. */
 export function getTaskForSession(sessionId: string, taskId: string, targetCwd?: string): any {
+	log.debug("session_task_read", { sessionId, taskId });
 	const base = targetCwd || process.cwd();
 	const storePath = join(base, ".pi", "tasks", `tasks-${sessionId.replace(/[/\\]/g, "_")}.json`);
 	const store = new TaskStore(storePath);
-	return store.get(taskId);
+	try {
+		return store.get(taskId);
+	} finally {
+		store.close();
+	}
 }
 
 /** List tasks from a specific session's store. */
 export function listTasksForSession(sessionId: string, targetCwd?: string): any[] {
+	log.debug("session_tasks_listed", { sessionId });
 	const base = targetCwd || process.cwd();
 	const storePath = join(base, ".pi", "tasks", `tasks-${sessionId.replace(/[/\\]/g, "_")}.json`);
 	const store = new TaskStore(storePath);
-	return store.list();
+	try {
+		return store.list();
+	} finally {
+		store.close();
+	}
 }
 
 /** Update a task on a specific session's store. */
 export function updateTaskForSession(sessionId: string, taskId: string, fields: any, targetCwd?: string): any {
+	log.debug("session_task_updated", { sessionId, taskId, fieldNames: Object.keys(fields) });
 	const base = targetCwd || process.cwd();
 	const storePath = join(base, ".pi", "tasks", `tasks-${sessionId.replace(/[/\\]/g, "_")}.json`);
 	const store = new TaskStore(storePath);
-	return store.update(taskId, fields);
+	try {
+		return store.update(taskId, fields);
+	} finally {
+		store.close();
+	}
 }
 
 /** Update multiple tasks on a specific session's store. Used by coms for bulk updates. */
 export function updateTasksForSession(sessionId: string, updates: Array<{ id: string; fields: Record<string, any> }>, targetCwd?: string): any[] {
+	log.debug("session_tasks_updated", { sessionId, count: updates.length });
 	const base = targetCwd || process.cwd();
 	const storePath = join(base, ".pi", "tasks", `tasks-${sessionId.replace(/[/\\]/g, "_")}.json`);
 	const store = new TaskStore(storePath);
-	return store.updateTasks(updates);
+	try {
+		return store.updateTasks(updates);
+	} finally {
+		store.close();
+	}
 }
 
 /** Delete a task from a specific session's store. */
 export function deleteTaskForSession(sessionId: string, taskId: string, targetCwd?: string): boolean {
+	log.debug("session_task_deleted", { sessionId, taskId });
 	const base = targetCwd || process.cwd();
 	const storePath = join(base, ".pi", "tasks", `tasks-${sessionId.replace(/[/\\]/g, "_")}.json`);
 	const store = new TaskStore(storePath);
-	return store.delete(taskId);
+	try {
+		return store.delete(taskId);
+	} finally {
+		store.close();
+	}
 }
 
 export default function (pi: ExtensionAPI) {
@@ -139,9 +182,15 @@ export default function (pi: ExtensionAPI) {
 		return join(process.cwd(), ".pi", "tasks", "tasks.json");
 	}
 
+	const resumedActiveTaskIds = currentWidget?.getActiveTaskIds() ?? [];
+	currentStore?.setOnChange(() => {});
+	currentStore?.close();
+	currentWidget?.dispose();
 	let store = new TaskStore(resolveStorePath());
 	taskStore = store;
+	currentStore = store;
 	const widget = new TaskWidget(store);
+	for (const taskId of resumedActiveTaskIds) widget.setActiveTask(taskId);
 	currentWidget = widget;
 	const instanceId = Math.random().toString(36).slice(2, 8);
 	(globalThis as any).__pitasks_active_instance = instanceId;
@@ -154,8 +203,11 @@ export default function (pi: ExtensionAPI) {
 		if (taskScope === "session" && !piTasks) {
 			const sessionId = ctx.sessionManager?.getSessionId?.();
 			const path = resolveStorePath(sessionId);
+			store.setOnChange(() => {});
+			store.close();
 			store = new TaskStore(path);
 			taskStore = store;
+			currentStore = store;
 			widget.setStore(store);
 			store.setOnChange(() => { widget.update(); });
 			log.debug("store upgraded", path);
@@ -281,6 +333,13 @@ export default function (pi: ExtensionAPI) {
 		shuttingDown = true;
 		if (gcTimer) { clearInterval(gcTimer); gcTimer = null; }
 		if (reminderTimer) { clearInterval(reminderTimer); reminderTimer = null; }
+		widget.deactivate();
+		store.setOnChange(() => {});
+		store.close();
+		if (currentWidget === widget) {
+			currentWidget = null;
+			currentStore = null;
+		}
 	});
 
 	pi.on("turn_start", async (_event: any, ctx: any) => {
@@ -314,7 +373,9 @@ export default function (pi: ExtensionAPI) {
 		shuttingDown = false;
 		agentBusy = false;
 		log.debug("agentBusy", "session_start reset");
-		widget.setUICtx(ctx.ui);
+		widget.reactivate(ctx.ui);
+		store.reopen();
+		store.setOnChange(() => { widget.update(); });
 		currentUiCtx = ctx.ui;
 		const reason = (event as any).reason;
 		log.debug("session_start", reason);

package/extensions/pitasks/task-store.ts

@@ -9,6 +9,9 @@ import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileS
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join } from "node:path";
 import type { Task, TaskStatus, TaskStoreData } from "./types.js";
+import { createLogger } from "../shared/logger.js";
+
+const log = createLogger("pitasks");
 
 function sortById(a: Task, b: Task): number {
 	return Number(a.id) - Number(b.id);
@@ -61,6 +64,7 @@ function isProcessRunning(pid: number): boolean {
 
 function normalizeTask(t: any): Task {
 	const now = Date.now();
+	log.debug("task_normalized", { taskId: t.id, hasTelemetry: !!t.telemetry });
 	return {
 		...t,
 		createdBy: t.createdBy && typeof t.createdBy === "object" ? t.createdBy :
@@ -75,6 +79,13 @@ function normalizeTask(t: any): Task {
 		blockedBy: Array.isArray(t.blockedBy) ? t.blockedBy : [],
 		createdAt: typeof t.createdAt === "number" ? t.createdAt : now,
 		updatedAt: typeof t.updatedAt === "number" ? t.updatedAt : now,
+		telemetry: t.telemetry && typeof t.telemetry === "object" &&
+			typeof t.telemetry.startedAt === "number" && typeof t.telemetry.inputTokens === "number" && typeof t.telemetry.outputTokens === "number" ? {
+			startedAt: t.telemetry.startedAt,
+			...(typeof t.telemetry.endedAt === "number" ? { endedAt: t.telemetry.endedAt } : {}),
+			inputTokens: t.telemetry.inputTokens,
+			outputTokens: t.telemetry.outputTokens,
+		} : undefined,
 		statusHistory: t.statusHistory && typeof t.statusHistory === "object" ? {
 			pending_at: typeof t.statusHistory.pending_at === "number" ? new Date(t.statusHistory.pending_at).toISOString() : (t.statusHistory.pending_at || new Date(typeof t.createdAt === "number" ? t.createdAt : now).toISOString()),
 			in_progress_at: typeof t.statusHistory.in_progress_at === "number" ? new Date(t.statusHistory.in_progress_at).toISOString() : (t.statusHistory.in_progress_at || null),
@@ -145,6 +156,10 @@ export class TaskStore {
 		if (this._watcher) { this._watcher.close(); this._watcher = null; }
 	}
 
+	reopen(): void {
+		if (!this._watcher) this._startWatcher();
+	}
+
 	private load(): void {
 		if (!this.filePath) return;
 		if (!existsSync(this.filePath)) return;
@@ -258,11 +273,13 @@ export class TaskStore {
 		activeForm?: string;
 		owner?: string;
 		metadata?: Record<string, any>;
+		telemetry?: Task["telemetry"];
 		addBlocks?: string[];
 		addBlockedBy?: string[];
 	}): { task: Task | undefined; changedFields: string[]; warnings: string[] } {
 		return this.withLock(() => {
 			const task = this.tasks.get(id);
+			log.debug("task_updated", { taskId: id, status: fields.status, hasTelemetry: fields.telemetry !== undefined });
 			if (!task) return { task: undefined, changedFields: [], warnings: [] };
 			const changedFields: string[] = [];
 			const warnings: string[] = [];
@@ -282,8 +299,17 @@ export class TaskStore {
 				changedFields.push("status");
 				const now = Date.now();
 				const isoNow = new Date(now).toISOString();
-				if (fields.status === "in_progress") task.statusHistory.in_progress_at = isoNow;
-				if (fields.status === "completed") task.statusHistory.completed_at = isoNow;
+				if (fields.status === "in_progress") {
+					task.statusHistory.in_progress_at = isoNow;
+					if (!task.telemetry || task.telemetry.endedAt !== undefined) {
+						task.telemetry = { startedAt: now, inputTokens: 0, outputTokens: 0 };
+					}
+				}
+				if (fields.status === "completed") {
+					task.statusHistory.completed_at = isoNow;
+					if (!task.telemetry) task.telemetry = { startedAt: now, inputTokens: 0, outputTokens: 0 };
+					if (!task.telemetry.endedAt) task.telemetry.endedAt = now;
+				}
 				if (fields.status === "pending") task.statusHistory.pending_at = isoNow;
 			}
 			if (fields.subject !== undefined) { task.subject = fields.subject; changedFields.push("subject"); }
@@ -298,6 +324,7 @@ export class TaskStore {
 				}
 				changedFields.push("metadata");
 			}
+			if (fields.telemetry !== undefined) { task.telemetry = fields.telemetry; changedFields.push("telemetry"); }
 
 			if (fields.addBlocks?.length) {
 				for (const targetId of fields.addBlocks) {
@@ -330,6 +357,7 @@ export class TaskStore {
 
 	updateTasks(updates: Array<{ id: string; fields: Record<string, any> }>): Array<{ id: string; success: boolean; changedFields?: string[] }> {
 		return this.withLock(() => {
+			log.debug("tasks_updated", { count: updates.length, statusUpdates: updates.filter(update => update.fields.status !== undefined).length });
 			const results: Array<{ id: string; success: boolean; changedFields?: string[] }> = [];
 			for (const { id, fields } of updates) {
 				const task = this.tasks.get(id);
@@ -350,9 +378,19 @@ export class TaskStore {
 				if (fields.status !== undefined) {
 					task.status = fields.status as TaskStatus;
 					changedFields.push("status");
-					const isoNow = new Date().toISOString();
-					if (fields.status === "in_progress") task.statusHistory.in_progress_at = isoNow;
-					if (fields.status === "completed") task.statusHistory.completed_at = isoNow;
+					const now = Date.now();
+					const isoNow = new Date(now).toISOString();
+					if (fields.status === "in_progress") {
+						task.statusHistory.in_progress_at = isoNow;
+						if (!task.telemetry || task.telemetry.endedAt !== undefined) {
+							task.telemetry = { startedAt: now, inputTokens: 0, outputTokens: 0 };
+						}
+					}
+					if (fields.status === "completed") {
+						task.statusHistory.completed_at = isoNow;
+						if (!task.telemetry) task.telemetry = { startedAt: now, inputTokens: 0, outputTokens: 0 };
+						if (!task.telemetry.endedAt) task.telemetry.endedAt = now;
+					}
 					if (fields.status === "pending") task.statusHistory.pending_at = isoNow;
 				}
 				if (fields.subject !== undefined) { task.subject = fields.subject; changedFields.push("subject"); }
@@ -367,6 +405,7 @@ export class TaskStore {
 					}
 					changedFields.push("metadata");
 				}
+				if (fields.telemetry !== undefined) { task.telemetry = fields.telemetry; changedFields.push("telemetry"); }
 
 				if (fields.addBlocks?.length) {
 					for (const targetId of fields.addBlocks) {

package/extensions/pitasks/task-tools.ts

@@ -5,9 +5,12 @@
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { createLogger } from "../shared/logger.js";
 import type { TaskStore } from "./task-store.js";
 import type { TaskWidget } from "./task-widget.js";
 
+const log = createLogger("pitasks");
+
 function textResult(msg: string) {
 	return { content: [{ type: "text" as const, text: msg }], details: undefined };
 }
@@ -355,6 +358,7 @@ Set up task dependencies:
 			}), { description: "Array of task updates" }),
 		}),
 		async execute(_callId, params) {
+			log.debug("tasks_bulk_updated", { count: params.updates.length });
 			const store = getStore();
 			const updates = params.updates.map(u => ({
 				id: u.taskId,
@@ -367,6 +371,10 @@ Set up task dependencies:
 				},
 			}));
 			const results = store.updateTasks(updates);
+			for (const update of updates) {
+				if (update.fields.status === "in_progress") widget.setActiveTask(update.id);
+				else if (update.fields.status !== undefined) widget.setActiveTask(update.id, false);
+			}
 			widget.update();
 			const lines = results.map(r => r.success ? `#${r.id}: ${r.changedFields?.join(", ") || "no changes"}` : `#${r.id}: not found`);
 			return textResult(`Updated ${results.filter(r => r.success).length} task(s):\n${lines.join("\n")}`);

package/extensions/pitasks/task-widget.ts

@@ -3,8 +3,11 @@
  * Copied from @tintinweb/pi-tasks (MIT license).
  */
 import { truncateToWidth } from "@earendil-works/pi-tui";
+import { createLogger } from "../shared/logger.js";
 import type { TaskStore } from "./task-store.js";
 
+const log = createLogger("pitasks");
+
 const SPINNER = ["✳", "✴", "✵", "✶", "✷", "✸", "✹", "✺", "✻", "✼", "✽"];
 const DEFAULT_MAX_VISIBLE_TASKS = 10;
 
@@ -36,29 +39,61 @@ export class TaskWidget {
 	private metrics = new Map<string, { startedAt: number; inputTokens: number; outputTokens: number }>();
 	private tui: any;
 	private widgetRegistered = false;
+	private disposed = false;
 
-	constructor(private store: TaskStore, private config: Record<string, any> = {}) {}
+	constructor(private store: TaskStore, private config: Record<string, any> = {}) {
+		log.debug("widget_created", { taskCount: store.list().length });
+	}
 
-	setStore(store: TaskStore): void { this.store = store; }
+	setStore(store: TaskStore): void {
+		this.store = store;
+		this.activeTaskIds.clear();
+		this.metrics.clear();
+		log.debug("widget_store_set", { taskCount: store.list().length });
+	}
 	setUICtx(ctx: any): void { this.uiCtx = ctx; }
+	getActiveTaskIds(): string[] { return [...this.activeTaskIds]; }
+
+	reactivate(ctx: any): void {
+		this.disposed = false;
+		this.uiCtx = ctx;
+		log.debug("widget_reactivated", { taskCount: this.store.list().length });
+	}
+
+	deactivate(): void {
+		log.debug("widget_deactivated", { hadWidget: this.widgetRegistered, hadTimer: !!this.widgetInterval });
+		if (this.widgetInterval) { clearInterval(this.widgetInterval); this.widgetInterval = undefined; }
+		if (this.uiCtx) this.uiCtx.setWidget("tasks", undefined);
+		this.widgetRegistered = false;
+		this.tui = undefined;
+		this.uiCtx = undefined;
+	}
 
 	setActiveTask(taskId: string, active = true): void {
-		if (taskId && active) {
+		const task = this.store.get(taskId);
+		log.debug("task_telemetry_active", { taskId, active, status: task?.status });
+		if (taskId && active && task) {
 			this.activeTaskIds.add(taskId);
-			if (!this.metrics.has(taskId)) {
-				this.metrics.set(taskId, { startedAt: Date.now(), inputTokens: 0, outputTokens: 0 });
-			}
+			const telemetry = task.telemetry ?? { startedAt: Date.now(), inputTokens: 0, outputTokens: 0 };
+			if (!task.telemetry) this.store.update(taskId, { telemetry });
+			this.metrics.set(taskId, telemetry);
 			this.ensureTimer();
 		} else if (taskId) {
 			this.activeTaskIds.delete(taskId);
+			if (task?.telemetry && !task.telemetry.endedAt) this.store.update(taskId, { telemetry: { ...task.telemetry, endedAt: Date.now() } });
 		}
 		this.update();
 	}
 
 	addTokenUsage(inputTokens: number, outputTokens: number): void {
+		log.debug("task_telemetry_usage", { activeTaskCount: this.activeTaskIds.size, inputTokens, outputTokens });
 		for (const id of this.activeTaskIds) {
 			const m = this.metrics.get(id);
-			if (m) { m.inputTokens += inputTokens; m.outputTokens += outputTokens; }
+			if (m) {
+				m.inputTokens += inputTokens;
+				m.outputTokens += outputTokens;
+				this.store.update(id, { telemetry: m });
+			}
 		}
 	}
 
@@ -69,6 +104,7 @@ export class TaskWidget {
 	}
 
 	private renderWidget(tui: any, theme: any): string[] {
+		log.debug("task_widget_render", { taskCount: this.store.list().length });
 		try { return this.buildWidgetLines(tui, theme); } catch { return []; }
 	}
 
@@ -114,29 +150,23 @@ export class TaskWidget {
 				if (openBlockers.length > 0) suffix = theme.fg("dim", ` › blocked by ${openBlockers.map((id: string) => "#" + id).join(", ")}`);
 			}
 
+			const m = task.telemetry ?? this.metrics.get(task.id);
+			const stats = m ? (() => {
+				const elapsed = formatDuration(Math.max(0, (m.endedAt ?? Date.now()) - m.startedAt));
+				const tokenParts = [m.inputTokens > 0 && `↑ ${formatTokens(m.inputTokens)}`, m.outputTokens > 0 && `↓ ${formatTokens(m.outputTokens)}`].filter(Boolean);
+				return ` ${theme.fg("dim", tokenParts.length ? `(${elapsed} · ${tokenParts.join(" ")})` : `(${elapsed})`)}`;
+			})() : "";
+
 			let text: string;
 			if (task.status === "in_progress") {
 				const form = task.activeForm || task.subject;
 				const agentId = task.metadata?.agentId;
 				const agentLabel = agentId ? ` (agent ${agentId.slice(0, 5)})` : "";
-				const m = this.metrics.get(task.id);
-				let stats = "";
-				if (m) {
-					const elapsed = formatDuration(Date.now() - m.startedAt);
-					const tokenParts: string[] = [];
-					if (m.inputTokens > 0) tokenParts.push(`↑ ${formatTokens(m.inputTokens)}`);
-					if (m.outputTokens > 0) tokenParts.push(`↓ ${formatTokens(m.outputTokens)}`);
-					stats = tokenParts.length > 0
-						? ` ${theme.fg("dim", `(${elapsed} · ${tokenParts.join(" ")})`)}`
-						: ` ${theme.fg("dim", `(${elapsed})`)}`;
-				}
 				text = `  ${icon} ${theme.fg("dim", "#" + task.id)} ${theme.fg("accent", form + agentLabel + "…")}${stats}`;
 			} else if (task.status === "completed") {
-				text = `  ${icon} ${theme.fg("dim", theme.strikethrough("#" + task.id + " " + task.subject))}`;
+				text = `  ${icon} ${theme.fg("dim", theme.strikethrough("#" + task.id + " " + task.subject))}${stats}`;
 			} else {
-				const agentSuffix = task.status === "in_progress" && task.metadata?.agentId
-					? theme.fg("dim", ` (agent ${task.metadata.agentId.slice(0, 5)})`) : "";
-				text = `  ${icon} ${theme.fg("dim", "#" + task.id)} ${task.subject}${agentSuffix}`;
+				text = `  ${icon} ${theme.fg("dim", "#" + task.id)} ${task.subject}${stats}`;
 			}
 			lines.push(truncate(text + suffix));
 		}
@@ -146,7 +176,8 @@ export class TaskWidget {
 	}
 
 	update(): void {
-		if (!this.uiCtx) return;
+		log.debug("widget_update", { disposed: this.disposed, hasUi: !!this.uiCtx, taskCount: this.store.list().length });
+		if (this.disposed || !this.uiCtx) return;
 		const tasks = this.store.list();
 		if (tasks.length === 0) {
 			if (this.widgetRegistered) { this.uiCtx.setWidget("tasks", undefined); this.widgetRegistered = false; }
@@ -173,9 +204,8 @@ export class TaskWidget {
 	}
 
 	dispose(): void {
-		if (this.widgetInterval) { clearInterval(this.widgetInterval); this.widgetInterval = undefined; }
-		if (this.uiCtx) this.uiCtx.setWidget("tasks", undefined);
-		this.widgetRegistered = false;
-		this.tui = undefined;
+		log.debug("widget_disposed", { hadWidget: this.widgetRegistered, hadTimer: !!this.widgetInterval });
+		this.disposed = true;
+		this.deactivate();
 	}
 }

package/extensions/pitasks/types.ts

@@ -23,6 +23,12 @@ export interface Task {
 	};
 	createdAt: number;
 	updatedAt: number;
+	telemetry?: {
+		startedAt: number;
+		endedAt?: number;
+		inputTokens: number;
+		outputTokens: number;
+	};
 	statusHistory: {
 		pending_at: string;
 		in_progress_at: string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-orchestrator-config",
-  "version": "4.3.14",
+  "version": "4.4.0",
   "description": "Orchestrator pattern for pi: specialist subagents, enforcement, code review loop, workflow commands",
   "keywords": [
     "pi-package"
@@ -39,6 +39,7 @@
     "extensions/pidiff/pidiff-ui/dist/",
     "extensions/pitasks/",
     "scripts/pidash-server.ts",
+    "scripts/pidash-session-state.ts",
     "scripts/pidiff-server.ts",
     "scripts/pidiff-git-ignore.ts",
     "scripts/daemon-shared.ts",

package/rules/10-agent-routing.md

@@ -15,7 +15,8 @@
 | Jenkins/CI/Groovy | `jenkins-expert` |
 | Git operations (local) | `git-expert` |
 | GitHub (PRs, issues, releases, workflows) | `github-expert` |
-| Tests | `test-automator` |
+| Running existing tests / analyzing failures | `test-runner` |
+| Creating or modifying tests / test strategy | `test-automator` |
 | Debugging | `debugger` |
 | API docs | `api-documenter` |
 | External repo security audit | `security-auditor` |
@@ -26,8 +27,10 @@
 
 Route based on the task intent, not just the tool being used.
 
-- Running Python tests? → `python-expert` (not bash-expert)
-- Editing Python files? → `python-expert` (even with sed/awk)
+- Running existing tests (including Python) or analyzing failures? → `test-runner`
+- Fixing Python production code after test failures? → `python-expert`
+- Creating or changing Python tests? → `test-automator`
+- Editing Python production files? → `python-expert` (even with sed/awk)
 - Creating a PR? → `github-expert` (not git-expert)
 - External library docs? → `docs-fetcher` (not direct fetch)
 

package/rules/20-code-review-loop.md

@@ -4,7 +4,7 @@
 
 ## Mandatory review loop
 
-After ANY code change, send to ALL 6 agents (5 reviewers + test-automator) IN PARALLEL. **Never skip the first review.**
+After ANY code change, send to ALL 6 agents (5 reviewers + test-runner) IN PARALLEL. **Never skip the first review.**
 
 ## Commit enforcement
 
@@ -12,7 +12,7 @@ After ANY code change, send to ALL 6 agents (5 reviewers + test-automator) IN PA
 When `review_loop_enforcement` is enabled, the enforcement rule in `enforcement.ts` blocks `git commit` unless:
 
 - Review status is `clean` (all reviewers returned 0 findings)
-- `tests_passed: true` (test-automator or test command succeeded)
+- `tests_passed: true` (a detected test command, including one run by `test-runner`, succeeded)
 
 **You MUST run the review loop BEFORE attempting `git commit`.** The enforcement rule will reject the commit otherwise.
 Do NOT try to work around it — run the actual review agents to reach `clean` status.
@@ -52,7 +52,7 @@ next resolution layer / default `3` — see `dev-docs/project-settings.md` for t
 Disable the review loop via `review_loop_enforcement: false` — not via max_cycles.
 
 Cap check is after 5a; it only blocks `go to 2` (re-dispatch of step 2 / all 6 agents,
-including test-automator), not completing the current cycle's fix/explain.
+including test-runner), not completing the current cycle's fix/explain.
 
 **After 5a completes on the max cycle, two outcomes** (report them; commit may still be
 allowed via the max-cycle path — see step 6):
@@ -71,7 +71,7 @@ cycle3: dispatch → findings → 5a (fix|explain) → cycle >= max → stop (no
 
 ```text
 1. Specialist writes/fixes code
-2. Send ALL 6 agents IN PARALLEL (async): 5 reviewers + test-automator
+2. Send ALL 6 agents IN PARALLEL (async): 5 reviewers + test-runner
    **On cycle 2+: MANDATORY — include prior cycle findings + responses in each reviewer's prompt (see Step 5a format).**
    Reviewers without this context will blindly repeat the same findings. This is not optional.
 3. Wait for all 6 to complete
@@ -94,7 +94,7 @@ The enforcement rule blocks commits until this is satisfied — if it blocks you
 **After a cap stop:** report the two-outcome result (**Not fixed** → outstanding, **Fixed** → verification
 blocked); commit is allowed when status is `has_findings` or `clean`, no reviewers pending, and
 `cycle >= review_loop_max_cycles` (no `tests_passed` requirement); do **not**
-return to step 2 (re-dispatch of all 6 agents, including test-automator).
+return to step 2 (re-dispatch of all 6 agents, including test-runner).
 {{/IF}}
 
 ## Review Agents
@@ -108,7 +108,7 @@ Six agents run in parallel for comprehensive coverage:
 | `code-reviewer-security` | Bugs, logic errors, and security vulnerabilities |
 | `code-reviewer-docs` | Documentation quality, completeness, and accuracy |
 | `code-reviewer-spec` | Code/PR/issue spec alignment and compliance |
-| `test-automator` | Run project tests (pytest, node tests, pre-commit) |
+| `test-runner` | Run project tests (pytest, node tests, pre-commit) |
 
 **All 6 MUST be invoked as async subagents (`async: true`) in the same assistant turn.
 Do NOT block waiting for results — continue working while they run.**
@@ -171,7 +171,7 @@ Findings that were fixed in code → verify the fix, do not re-raise if correct.
 
 ## Key Rules
 
-Never skip code review — all 6 agents always run (5 reviewers + test-automator).
+Never skip code review — all 6 agents always run (5 reviewers + test-runner).
 Exception: on `chore/bump-version` branches (release version bumps), review dirty-tracking and commit blocking are skipped.
 {{IF:review_loop_enforcement}}
 When `review_loop_enforcement` is enabled: loop, respond to each finding (fix or explain), and re-run all 6 from step 2
@@ -197,12 +197,12 @@ Tests still run and `tests_passed` is still recorded; commit is not blocked by r
 
 - **Bash hook detection:** When any agent runs a test command (`pytest`, `npm test`, `npx tsx --test`, `tox`, `go test`, `vitest`, `jest`, `mocha`),
   the enforcement hook detects it and auto-marks `tests_passed` based on exit code.
-- **Agent completion:** When `test-automator` or `test-runner` agents complete, their result auto-marks `tests_passed`.
+- **Async test agents:** `test-runner` and `test-automator` completion never changes `tests_passed`; agent process completion does not prove its test command passed.
 - **Reset on edit:** Any file edit triggers `markNeedsReview()` (except on `chore/bump-version` branches), which resets `tests_passed: false` —
   preventing stale results.
 
 **Duplicate test run avoidance:** If a specialist already ran tests before the review loop, `tests_passed` may already be `true`.
-Any file edit resets it, so test-automator in the parallel batch always validates the latest code.
+Any file edit resets it, so test-runner in the parallel batch always validates the latest code.
 
 ## Baseline Test Comparison (Step 5)
 

package/scripts/pidash-session-state.ts

@@ -0,0 +1,106 @@
+import type { SessionInfo } from "../extensions/shared/types.ts";
+import { initialActivityState } from "../extensions/pidash/activity-state.ts";
+import { createLogger } from "../extensions/shared/logger.ts";
+
+const log = createLogger("pidash");
+
+export interface PiClient {
+  ws: any;
+  session: SessionInfo;
+  eventBuffer: string[];
+  replaying: boolean;
+  connectionGeneration: number;
+}
+
+function registeredSession(parsed: any): SessionInfo {
+  const activity = parsed.activity === "working" || parsed.activity === "waiting_for_input" ? parsed.activity : "idle";
+  const streaming = typeof parsed.streaming === "boolean" ? parsed.streaming : false;
+  return {
+    sessionId: parsed.sessionId || `${parsed.pid}:${parsed.cwd}`,
+    pid: parsed.pid,
+    cwd: parsed.cwd || "",
+    branch: parsed.branch || "",
+    model: parsed.model || "",
+    startedAt: parsed.startedAt || new Date().toISOString(),
+    lastActivity: Date.now(),
+    active: true,
+    sessionFile: parsed.sessionFile || "",
+    gitDirty: parsed.gitDirty || false,
+    gitChanges: parsed.gitChanges || 0,
+    container: parsed.container || false,
+    contextWindow: parsed.contextWindow || 0,
+    diffPort: parsed.diffPort || null,
+    thinkingLevel: parsed.thinkingLevel || "medium",
+    name: parsed.name || undefined,
+    comsName: parsed.comsName || undefined,
+    comsPurpose: parsed.comsPurpose || undefined,
+    comsProject: parsed.comsProject || undefined,
+    ...initialActivityState(),
+    activity,
+    activitySequence: Number.isSafeInteger(parsed.activitySequence) ? parsed.activitySequence : 0,
+    activityBeforePrompt: parsed.activityBeforePrompt === "working" || parsed.activityBeforePrompt === "waiting_for_input" || parsed.activityBeforePrompt === "idle" ? parsed.activityBeforePrompt : undefined,
+    streaming,
+    working: activity === "working",
+  };
+}
+
+export function registerPidashSession(
+  sessions: Map<string, PiClient>,
+  ws: any,
+  parsed: any,
+  broadcast: (event: object) => void,
+): PiClient {
+  const session = registeredSession(parsed);
+  const existing = sessions.get(session.sessionId);
+  let client: PiClient;
+  if (existing) {
+    if (!session.name && existing.session.name) session.name = existing.session.name;
+    if (!session.comsName && existing.session.comsName) session.comsName = existing.session.comsName;
+    if (!session.comsPurpose && existing.session.comsPurpose) session.comsPurpose = existing.session.comsPurpose;
+    if (!session.comsProject && existing.session.comsProject) session.comsProject = existing.session.comsProject;
+    existing.ws = ws;
+    existing.session = session;
+    existing.eventBuffer = [];
+    existing.replaying = true;
+    existing.connectionGeneration++;
+    client = existing;
+  } else {
+    client = { ws, session, eventBuffer: [], replaying: true, connectionGeneration: 1 };
+  }
+  sessions.set(session.sessionId, client);
+  log.info(`session registered: session=${session.sessionId} streaming=${session.streaming}`);
+  broadcast({ type: "session_added", session });
+  return client;
+}
+
+export function disconnectPidashSession(
+  client: PiClient,
+  ws: any,
+  source: "close" | "error",
+  broadcast: (event: object) => void,
+): void {
+  if (client.ws !== ws) {
+    log.debug(`stale connection ${source} ignored: session=${client.session.sessionId}`);
+    return;
+  }
+  client.session.active = false;
+  client.session.activity = "idle";
+  client.session.activityBeforePrompt = undefined;
+  client.session.streaming = false;
+  client.session.working = false;
+  client.ws = null;
+  log.info(`session disconnected: session=${client.session.sessionId} source=${source}`);
+  broadcast({ type: "session_updated", session: client.session });
+}
+
+export function createPidashSessionState(
+  broadcast: (event: object) => void,
+  sessions = new Map<string, PiClient>(),
+) {
+  log.debug(`session state created: sessions=${sessions.size}`);
+  return {
+    sessions,
+    register: (ws: any, parsed: any) => registerPidashSession(sessions, ws, parsed, broadcast),
+    disconnect: (client: PiClient, ws: any, source: "close" | "error") => disconnectPidashSession(client, ws, source, broadcast),
+  };
+}