pi-crew 0.6.0 → 0.6.3

package/src/runtime/subagent-manager.ts

@@ -1,14 +1,21 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { loadRunManifestById } from "../state/state-store.ts";
+import { DEFAULT_PATHS, DEFAULT_SUBAGENT } from "../config/defaults.ts";
 import type { PiTeamsToolResult } from "../extension/tool-result.ts";
-import { DEFAULT_SUBAGENT } from "../config/defaults.ts";
-import { projectCrewRoot } from "../utils/paths.ts";
-import { DEFAULT_PATHS } from "../config/defaults.ts";
+import { loadRunManifestById } from "../state/state-store.ts";
 import { logInternalError } from "../utils/internal-error.ts";
+import { projectCrewRoot } from "../utils/paths.ts";
 import { redactSecrets } from "../utils/redaction.ts";
 
-export type SubagentStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "error" | "blocked" | "stopped";
+export type SubagentStatus =
+	| "queued"
+	| "running"
+	| "completed"
+	| "failed"
+	| "cancelled"
+	| "error"
+	| "blocked"
+	| "stopped";
 
 export interface SubagentSpawnOptions {
 	cwd: string;
@@ -49,7 +56,10 @@ export interface SubagentRecord {
 	lifetimeUsage?: { input: number; output: number; cacheWrite: number };
 }
 
-type SpawnRunner = (options: SubagentSpawnOptions, signal?: AbortSignal) => Promise<PiTeamsToolResult>;
+type SpawnRunner = (
+	options: SubagentSpawnOptions,
+	signal?: AbortSignal,
+) => Promise<PiTeamsToolResult>;
 type Notify = (record: SubagentRecord) => void;
 type NotifyEvent = (type: string, data: Record<string, unknown>) => void;
 
@@ -66,7 +76,11 @@ function isValidSubagentId(id: string): boolean {
 
 function persistedSubagentPath(cwd: string, id: string): string {
 	if (!isValidSubagentId(id)) throw new Error(`Invalid subagent id: ${id}`);
-	return path.join(projectCrewRoot(cwd), DEFAULT_PATHS.state.subagentsSubdir, `${id}.json`);
+	return path.join(
+		projectCrewRoot(cwd),
+		DEFAULT_PATHS.state.subagentsSubdir,
+		`${id}.json`,
+	);
 }
 
 function serializableRecord(record: SubagentRecord): SubagentRecord {
@@ -74,11 +88,18 @@ function serializableRecord(record: SubagentRecord): SubagentRecord {
 	return rest;
 }
 
-export function savePersistedSubagentRecord(cwd: string, record: SubagentRecord): void {
+export function savePersistedSubagentRecord(
+	cwd: string,
+	record: SubagentRecord,
+): void {
 	try {
 		const filePath = persistedSubagentPath(cwd, record.id);
 		fs.mkdirSync(path.dirname(filePath), { recursive: true });
-		fs.writeFileSync(filePath, `${JSON.stringify(redactSecrets(serializableRecord(record)), null, 2)}\n`, "utf-8");
+		fs.writeFileSync(
+			filePath,
+			`${JSON.stringify(redactSecrets(serializableRecord(record)), null, 2)}\n`,
+			"utf-8",
+		);
 		// SECURITY: Restrict permissions to owner-only (rw-------).
 		// On multi-user systems, other users must not read task prompts,
 		// agent descriptions, and run IDs from subagent record files.
@@ -88,17 +109,81 @@ export function savePersistedSubagentRecord(cwd: string, record: SubagentRecord)
 	}
 }
 
-export function readPersistedSubagentRecord(cwd: string, id: string): SubagentRecord | undefined {
+const ALLOWED_RECORD_FIELDS = new Set([
+	"id",
+	"agentId",
+	"agentName",
+	"subagentType",
+	"type",
+	"description",
+	"prompt",
+	"status",
+	"startedAt",
+	"completedAt",
+	"spawnedAt",
+	"model",
+	"runId",
+	"cwd",
+	"taskId",
+	"result",
+	"error",
+	"resultConsumed",
+	"background",
+	"ownerSessionGeneration",
+	"stuckNotified",
+	"blockedAt",
+	"turnCount",
+	"terminated",
+	"durationMs",
+]);
+
+function sanitizePersistedRecord(raw: unknown): SubagentRecord | undefined {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return undefined;
+	const obj = raw as Record<string, unknown>;
+	// Accept either `id` (public SubagentRecord field) or `agentId` (legacy).
+	// The saved JSON uses `id` (from serializableRecord → JSON.stringify of record).
+	const idValue = obj.id ?? obj.agentId;
+	if (typeof idValue !== "string" || !idValue) return undefined;
+	const clean: Record<string, unknown> = { id: idValue };
+	if (obj.agentId && typeof obj.agentId === "string") {
+		clean.agentId = obj.agentId;
+	}
+	for (const key of Object.keys(obj)) {
+		if (
+			ALLOWED_RECORD_FIELDS.has(key) &&
+			(typeof obj[key] === "string" ||
+				typeof obj[key] === "number" ||
+				typeof obj[key] === "boolean")
+		) {
+			clean[key] = obj[key];
+		}
+	}
+	// Re-validate `id` to prevent prototype/constructor smuggling
+	if (typeof clean.id !== "string" || clean.id.length === 0) return undefined;
+	return clean as unknown as SubagentRecord;
+}
+
+export function readPersistedSubagentRecord(
+	cwd: string,
+	id: string,
+): SubagentRecord | undefined {
 	try {
-		const parsed = JSON.parse(fs.readFileSync(persistedSubagentPath(cwd, id), "utf-8"));
-		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed as SubagentRecord : undefined;
+		const raw = JSON.parse(
+			fs.readFileSync(persistedSubagentPath(cwd, id), "utf-8"),
+		);
+		return sanitizePersistedRecord(raw);
 	} catch {
 		return undefined;
 	}
 }
 
 function resultText(result: PiTeamsToolResult): string {
-	return result.content?.map((item) => item.type === "text" ? item.text : "").filter(Boolean).join("\n") ?? "";
+	return (
+		result.content
+			?.map((item) => (item.type === "text" ? item.text : ""))
+			.filter(Boolean)
+			.join("\n") ?? ""
+	);
 }
 
 function detailsRunId(result: PiTeamsToolResult): string | undefined {
@@ -106,9 +191,12 @@ function detailsRunId(result: PiTeamsToolResult): string | undefined {
 	return typeof details?.runId === "string" ? details.runId : undefined;
 }
 
-function totalRunTurns(cwd: string, runId: string | undefined): number | undefined {
+function totalRunTurns(
+	cwd: string,
+	runId: string | undefined,
+): number | undefined {
 	if (!runId) return undefined;
-	const loaded = loadRunManifestById(cwd, runId);
+	const loaded = loadRunManifestById(cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return undefined;
 	let total = 0;
 	let hasTurns = false;
@@ -135,20 +223,33 @@ export class SubagentManager {
 	private readonly onEvent?: NotifyEvent;
 	private readonly pollIntervalMs: number;
 
-	constructor(maxConcurrent = 4, onComplete?: Notify, pollIntervalMs = 1000, onEvent?: NotifyEvent) {
+	constructor(
+		maxConcurrent = 4,
+		onComplete?: Notify,
+		pollIntervalMs = 1000,
+		onEvent?: NotifyEvent,
+	) {
 		this.maxConcurrent = maxConcurrent;
 		this.onComplete = onComplete;
 		this.onEvent = onEvent;
 		this.pollIntervalMs = pollIntervalMs;
 	}
 
-	spawn(options: SubagentSpawnOptions, runner: SpawnRunner, signal?: AbortSignal): SubagentRecord {
+	spawn(
+		options: SubagentSpawnOptions,
+		runner: SpawnRunner,
+		signal?: AbortSignal,
+	): SubagentRecord {
 		const record: SubagentRecord = {
 			id: `agent_${Date.now().toString(36)}_${(++this.counter).toString(36)}`,
 			type: options.type,
 			description: options.description,
 			prompt: options.prompt,
-			status: options.background && this.runningBackground >= this.maxConcurrent ? "queued" : "running",
+			status:
+				options.background &&
+				this.runningBackground >= this.maxConcurrent
+					? "queued"
+					: "running",
 			startedAt: Date.now(),
 			model: options.model,
 			skill: options.skill,
@@ -171,7 +272,9 @@ export class SubagentManager {
 	}
 
 	listAgents(): SubagentRecord[] {
-		return [...this.records.values()].sort((a, b) => b.startedAt - a.startedAt);
+		return [...this.records.values()].sort(
+			(a, b) => b.startedAt - a.startedAt,
+		);
 	}
 
 	abort(id: string, reason?: string): boolean {
@@ -182,7 +285,8 @@ export class SubagentManager {
 			this.markStopped(record, reason ?? "Aborted by caller.");
 			return true;
 		}
-		if (record.status !== "running" && record.status !== "blocked") return false;
+		if (record.status !== "running" && record.status !== "blocked")
+			return false;
 		this.controllers.get(id)?.abort();
 		this.markStopped(record, reason ?? "Aborted by caller.");
 		return true;
@@ -209,7 +313,16 @@ export class SubagentManager {
 	async waitForAll(): Promise<void> {
 		while (true) {
 			this.drainQueue();
-			const pending = this.listAgents().filter((record) => record.status === "running" || record.status === "queued").map((record) => record.promise).filter((promise): promise is Promise<void> => Boolean(promise));
+			const pending = this.listAgents()
+				.filter(
+					(record) =>
+						record.status === "running" ||
+						record.status === "queued",
+				)
+				.map((record) => record.promise)
+				.filter((promise): promise is Promise<void> =>
+					Boolean(promise),
+				);
 			if (!pending.length) break;
 			await Promise.allSettled(pending);
 		}
@@ -219,8 +332,16 @@ export class SubagentManager {
 		while (true) {
 			const record = this.records.get(id);
 			if (!record) return undefined;
-			if (record.status !== "running" && record.status !== "queued") return record;
-			if (record.promise) await record.promise.catch((error) => { logInternalError("subagent-manager.waitForRecord", error, `id=${id}`); });
+			if (record.status !== "running" && record.status !== "queued")
+				return record;
+			if (record.promise)
+				await record.promise.catch((error) => {
+					logInternalError(
+						"subagent-manager.waitForRecord",
+						error,
+						`id=${id}`,
+					);
+				});
 			else await new Promise((resolve) => setTimeout(resolve, 100));
 		}
 	}
@@ -230,7 +351,12 @@ export class SubagentManager {
 		this.drainQueue();
 	}
 
-	private start(record: SubagentRecord, options: SubagentSpawnOptions, runner: SpawnRunner, signal?: AbortSignal): void {
+	private start(
+		record: SubagentRecord,
+		options: SubagentSpawnOptions,
+		runner: SpawnRunner,
+		signal?: AbortSignal,
+	): void {
 		if (options.background) this.runningBackground++;
 		record.status = "running";
 		record.startedAt = Date.now();
@@ -249,33 +375,72 @@ export class SubagentManager {
 					record.error = record.result;
 					throw new Error(record.error);
 				}
-				if (record.runId) await this.pollRunToTerminal(options.cwd, record);
+				if (record.runId)
+					await this.pollRunToTerminal(options.cwd, record);
 				else record.status = "completed";
 			} catch (error) {
 				if (record.status === "stopped" || runSignal.aborted) {
-					const abortReason = runSignal.aborted ? "Signal aborted — agent cancelled by parent (session switch, user cancel, or tool timeout)." : undefined;
+					const abortReason = runSignal.aborted
+						? "Signal aborted — agent cancelled by parent (session switch, user cancel, or tool timeout)."
+						: undefined;
 					record.status = "stopped";
-					if (!record.error) record.error = abortReason ?? (error instanceof Error ? error.message : String(error));
+					if (!record.error)
+						record.error =
+							abortReason ??
+							(error instanceof Error
+								? error.message
+								: String(error));
 					return;
 				}
 				record.status = "error";
-				record.error = error instanceof Error ? error.message : String(error);
+				record.error =
+					error instanceof Error ? error.message : String(error);
 				throw error; // H4: Propagate rejection so callers awaiting record.promise see the error
 			} finally {
 				this.cleanupRunSignal(record.id);
-				if (options.background) this.runningBackground = Math.max(0, this.runningBackground - 1);
-				if (record.status !== "blocked") record.completedAt = record.completedAt ?? Date.now();
+				if (options.background)
+					this.runningBackground = Math.max(
+						0,
+						this.runningBackground - 1,
+					);
+				if (record.status !== "blocked")
+					record.completedAt = record.completedAt ?? Date.now();
 				savePersistedSubagentRecord(options.cwd, record);
-				if (record.status === "completed" || record.status === "failed" || record.status === "cancelled" || record.status === "error" || record.status === "stopped") {
+				if (
+					record.status === "completed" ||
+					record.status === "failed" ||
+					record.status === "cancelled" ||
+					record.status === "error" ||
+					record.status === "stopped"
+				) {
 					// Phase 1.6: Populate telemetry fields
-					record.turnCount = record.turnCount ?? totalRunTurns(options.cwd, record.runId);
-					record.durationMs = record.completedAt ? Math.max(0, record.completedAt - record.startedAt) : undefined;
+					record.turnCount =
+						record.turnCount ??
+						totalRunTurns(options.cwd, record.runId);
+					record.durationMs = record.completedAt
+						? Math.max(0, record.completedAt - record.startedAt)
+						: undefined;
 					savePersistedSubagentRecord(options.cwd, record);
 					this.onComplete?.(record);
 				}
 				this.drainQueue();
 			}
 		})();
+		// Defense in depth (issue #29): a subagent failure should never crash
+		// the host pi process. The IIFE above can reject (e.g. when a run
+		// lookup fails) and the re-throw at line 281 propagates to
+		// `record.promise`. If no caller awaits the promise, that rejection
+		// would become `unhandledRejection` → `uncaughtException` → pi exits.
+		// Attaching a no-op catch here keeps the contract for callers that
+		// DO await (they still see the rejection) while preventing the
+		// harness-killing failure mode for callers that don't.
+		record.promise.catch((error) => {
+			logInternalError(
+				"subagent-manager.start.unhandled",
+				error,
+				`id=${record.id}`,
+			);
+		});
 	}
 
 	private markStopped(record: SubagentRecord, reason?: string): void {
@@ -296,7 +461,9 @@ export class SubagentManager {
 		if (signal) {
 			const abort = (): void => controller.abort();
 			signal.addEventListener("abort", abort, { once: true });
-			this.controllerCleanup.set(id, () => signal.removeEventListener("abort", abort));
+			this.controllerCleanup.set(id, () =>
+				signal.removeEventListener("abort", abort),
+			);
 		}
 		return controller.signal;
 	}
@@ -308,32 +475,48 @@ export class SubagentManager {
 	}
 
 	private drainQueue(): void {
-		while (this.queue.length > 0 && this.runningBackground < this.maxConcurrent) {
+		while (
+			this.queue.length > 0 &&
+			this.runningBackground < this.maxConcurrent
+		) {
 			const next = this.queue.shift();
 			if (!next || next.record.status !== "queued") continue;
 			this.start(next.record, next.options, next.runner, next.signal);
 		}
 	}
 
-	private async pollRunToTerminal(cwd: string, record: SubagentRecord): Promise<void> {
-		while (record.runId && (record.status === "running" || record.status === "blocked")) {
-			const loaded = loadRunManifestById(cwd, record.runId);
+	private async pollRunToTerminal(
+		cwd: string,
+		record: SubagentRecord,
+	): Promise<void> {
+		while (
+			record.runId &&
+			(record.status === "running" || record.status === "blocked")
+		) {
+			const loaded = loadRunManifestById(cwd, record.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 			if (!loaded) {
-				await new Promise((resolve) => setTimeout(resolve, this.pollIntervalMs));
+				await new Promise((resolve) =>
+					setTimeout(resolve, this.pollIntervalMs),
+				);
 				continue;
 			}
 			if (loaded.manifest.status === "completed") {
 				record.status = "completed";
 				record.error = undefined;
-				record.turnCount = record.turnCount ?? totalRunTurns(cwd, record.runId);
+				record.turnCount =
+					record.turnCount ?? totalRunTurns(cwd, record.runId);
 				record.completedAt = Date.now();
 				savePersistedSubagentRecord(cwd, record);
 				return;
 			}
-			if (loaded.manifest.status === "failed" || loaded.manifest.status === "cancelled") {
+			if (
+				loaded.manifest.status === "failed" ||
+				loaded.manifest.status === "cancelled"
+			) {
 				record.status = loaded.manifest.status;
 				record.error = loaded.manifest.summary;
-				record.turnCount = record.turnCount ?? totalRunTurns(cwd, record.runId);
+				record.turnCount =
+					record.turnCount ?? totalRunTurns(cwd, record.runId);
 				record.completedAt = Date.now();
 				savePersistedSubagentRecord(cwd, record);
 				return;
@@ -352,32 +535,52 @@ export class SubagentManager {
 				savePersistedSubagentRecord(cwd, record);
 				return;
 			}
-			await new Promise((resolve) => setTimeout(resolve, this.pollIntervalMs));
+			await new Promise((resolve) =>
+				setTimeout(resolve, this.pollIntervalMs),
+			);
 		}
 	}
 
-	private scheduleBlockedTerminalPoll(cwd: string, record: SubagentRecord): void {
+	private scheduleBlockedTerminalPoll(
+		cwd: string,
+		record: SubagentRecord,
+	): void {
 		const poll = (): void => {
 			const current = this.records.get(record.id);
-			if (!current || current.status !== "blocked" || !current.runId) return;
-			const loaded = loadRunManifestById(cwd, current.runId);
-			if (!loaded || loaded.manifest.status === "blocked" || loaded.manifest.status === "running" || loaded.manifest.status === "planning" || loaded.manifest.status === "queued") {
+			if (!current || current.status !== "blocked" || !current.runId)
+				return;
+			const loaded = loadRunManifestById(cwd, current.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
+			if (
+				!loaded ||
+				loaded.manifest.status === "blocked" ||
+				loaded.manifest.status === "running" ||
+				loaded.manifest.status === "planning" ||
+				loaded.manifest.status === "queued"
+			) {
 				const timer = setTimeout(poll, this.pollIntervalMs);
 				timer.unref();
 				return;
 			}
 			const persisted = readPersistedSubagentRecord(cwd, current.id);
-			current.resultConsumed = current.resultConsumed || persisted?.resultConsumed;
+			current.resultConsumed =
+				current.resultConsumed || persisted?.resultConsumed;
 			if (loaded.manifest.status === "completed") {
 				current.status = "completed";
 				current.error = undefined;
-			} else if (loaded.manifest.status === "failed" || loaded.manifest.status === "cancelled") {
+			} else if (
+				loaded.manifest.status === "failed" ||
+				loaded.manifest.status === "cancelled"
+			) {
 				current.status = loaded.manifest.status;
 				current.error = loaded.manifest.summary;
 			} else return;
 			current.completedAt = Date.now();
-			current.turnCount = current.turnCount ?? totalRunTurns(cwd, current.runId);
-			current.durationMs = Math.max(0, current.completedAt - current.startedAt);
+			current.turnCount =
+				current.turnCount ?? totalRunTurns(cwd, current.runId);
+			current.durationMs = Math.max(
+				0,
+				current.completedAt - current.startedAt,
+			);
 			savePersistedSubagentRecord(cwd, current);
 			this.onComplete?.(current);
 		};
@@ -385,11 +588,20 @@ export class SubagentManager {
 		timer.unref();
 	}
 
-	private scheduleStuckBlockedNotify(cwd: string, record: SubagentRecord): void {
+	private scheduleStuckBlockedNotify(
+		cwd: string,
+		record: SubagentRecord,
+	): void {
 		const threshold = DEFAULT_SUBAGENT.stuckBlockedNotifyMs;
 		const fire = (): void => {
 			const current = this.records.get(record.id);
-			if (!current || current.status !== "blocked" || !current.blockedAt || current.stuckNotified) return;
+			if (
+				!current ||
+				current.status !== "blocked" ||
+				!current.blockedAt ||
+				current.stuckNotified
+			)
+				return;
 			current.stuckNotified = true;
 			this.onEvent?.("subagent.stuck-blocked", {
 				event: "subagent.stuck-blocked",

package/src/runtime/subprocess-tool-registry.ts

@@ -61,7 +61,7 @@ class SubprocessToolRegistryImpl implements SubprocessToolRegistry {
 
 export const subprocessToolRegistry: SubprocessToolRegistry = new SubprocessToolRegistryImpl();
 
-/** H3: Reset the global singleton registry (for test isolation). */
-export function resetSubprocessToolRegistry(): void {
+/** @internal Reset the global singleton registry (for test isolation). */
+function resetSubprocessToolRegistry(): void {
 	subprocessToolRegistry.clear();
 }

package/src/runtime/task-health.ts

@@ -0,0 +1,76 @@
+export type HealthGrade = "A" | "B" | "C" | "D" | "F";
+
+export interface HealthPenalty {
+  reason: string;
+  deduction: number;
+}
+
+export interface HealthDelta {
+  metric: string;
+  delta: number;
+  trend: "improving" | "degrading" | "stable";
+}
+
+export interface RunHealth {
+  score: number;
+  grade: HealthGrade;
+  penalties: HealthPenalty[];
+  deltas: HealthDelta[];
+}
+
+const STALLED_THRESHOLD_MS = 5 * 60 * 1000;
+
+export function scoreToGrade(score: number): HealthGrade {
+  if (score >= 90) return "A";
+  if (score >= 70) return "B";
+  if (score >= 50) return "C";
+  if (score >= 30) return "D";
+  return "F";
+}
+
+export interface TaskSummary {
+  id: string;
+  status: string;
+  stalledSince?: number;
+}
+
+export interface ManifestSummary {
+  runId: string;
+  tasks: TaskSummary[];
+  createdAt: string;
+}
+
+export function computeRunHealth(manifest: ManifestSummary): RunHealth {
+  const penalties: HealthPenalty[] = [];
+  const tasks = manifest.tasks;
+  const taskCount = tasks.length;
+  if (taskCount === 0) return { score: 100, grade: "A", penalties: [], deltas: [] };
+
+  const failedCount = tasks.filter(t => t.status === "failed").length;
+  const stalledCount = tasks.filter(t =>
+    t.stalledSince !== undefined && (Date.now() - t.stalledSince) > STALLED_THRESHOLD_MS
+  ).length;
+
+  const failureRate = failedCount / taskCount;
+  if (failureRate > 0.2) {
+    penalties.push({ reason: "high-failure-rate", deduction: Math.round(failureRate * 50) });
+  }
+
+  if (stalledCount > 0) {
+    penalties.push({ reason: "stalled-tasks", deduction: Math.min(15, stalledCount * 5) });
+  }
+
+  if (taskCount > 20) {
+    penalties.push({ reason: "large-task-count", deduction: Math.min(10, Math.floor((taskCount - 20) / 10)) });
+  }
+
+  const totalDeduction = penalties.reduce((sum, p) => sum + p.deduction, 0);
+  const score = Math.max(0, Math.min(100, 100 - totalDeduction));
+
+  return {
+    score,
+    grade: scoreToGrade(score),
+    penalties,
+    deltas: [],
+  };
+}

package/src/runtime/task-id.ts

@@ -146,3 +146,23 @@ export type DependencyType =
 	| "duplicates"          // A duplicates B
 	| "delegated-from"      // A was delegated from B
 	| "validates";          // A validates B's output
+
+// ── Stable IDs (full hash, for cross-run references) ──────────────────────
+
+/**
+ * Generate a stable, collision-resistant ID from arbitrary content.
+ * Uses full SHA-256 hash (not adaptive length) for maximum stability.
+ * Format: {prefix}-{first12charsOfBase36hash}
+ *
+ * Use for: run-level IDs, artifact keys, cross-run references
+ * where determinism and uniqueness matter more than short length.
+ */
+export function stableIdFromContent(content: string, prefix = "id"): string {
+	const hash = createHash("sha256").update(content).digest("hex");
+	const hashChars = "0123456789abcdefghijklmnopqrstuvwxyz";
+	let b36 = "";
+	for (let i = 0; i < 16 && i < hash.length; i++) {
+		b36 += hashChars[parseInt(hash[i]!, 16)] ?? "0";
+	}
+	return `${prefix}-${b36.slice(0, 12)}`;
+}

package/src/runtime/task-packet.ts

@@ -1,6 +1,7 @@
 import * as path from "node:path";
 import type { TeamRunManifest, TaskPacket, TaskScope, VerificationContract } from "../state/types.ts";
 import type { WorkflowStep } from "../workflows/workflow-config.ts";
+import { generateTaskHashId } from "./task-id.ts";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // SEC-007 Fix: Workflow Step Task Sanitization
@@ -81,8 +82,19 @@ export function buildTaskPacket(input: BuildTaskPacketInput): TaskPacket {
 	const scopePath = reads.length === 1 ? reads[0] : reads.length > 1 ? reads.join(", ") : undefined;
 	// SEC-007: Sanitize task text before inserting into task packet
 	const sanitizedTask = sanitizeTaskText(input.step.task);
+	const sanitizedGoal = sanitizeTaskText(input.manifest.goal);
+
+	// Generate a deterministic hash-based task ID for traceability and logging.
+	// Uses goal + step ID + run ID as content parts.
+	// TODO: Once TaskPacket type gains a hashId field, include this in the packet.
+	const _taskHashId = generateTaskHashId([
+		input.manifest.goal,
+		input.step.id,
+		input.manifest.runId,
+	]);
+
 	return {
-		objective: sanitizedTask.replaceAll("{goal}", input.manifest.goal),
+		objective: sanitizedTask.replaceAll("{goal}", sanitizedGoal),
 		scope,
 		scopePath,
 		repo: path.basename(input.manifest.cwd) || input.manifest.cwd,

package/src/runtime/task-runner/live-executor.ts

@@ -65,7 +65,7 @@ export async function runLiveTask(input: RunLiveTaskInput): Promise<RunLiveTaskO
 	const transcriptPath = `${manifest.artifactsRoot}/transcripts/${task.id}.jsonl`;
 	const isCurrent = input.isCurrent ?? (() => {
 		if (input.signal?.aborted) return false;
-		const loaded = loadRunManifestById(manifest.cwd, manifest.runId);
+		const loaded = loadRunManifestById(manifest.cwd, manifest.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
 		const currentTask = loaded?.tasks.find((item) => item.id === task.id);
 		if (loaded?.manifest.status && loaded.manifest.status !== "running") return false;
 		return currentTask ? currentTask.status === "running" : true;

package/src/runtime/task-runner/progress.ts

@@ -77,7 +77,7 @@ export function applyUsageToProgress(progress: CrewAgentProgress | undefined, us
 
 export function shouldFlushProgressEvent(event: unknown): boolean {
 	const type = asRecord(event)?.type;
-	return type === "tool_execution_start" || type === "tool_execution_end" || type === "message_end" || type === "tool_result_end";
+	return type === "tool_execution_start" || type === "tool_execution_end" || type === "message_start" || type === "message_end" || type === "tool_result_end";
 }
 
 export function progressEventSummary(task: TeamTaskState, event: unknown): ProgressEventSummary {