pi-crew 0.1.45 → 0.1.46

package/src/runtime/session-snapshot.ts

@@ -1,59 +1,59 @@
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-
-/**
- * Creates a lightweight snapshot of task state for event emission.
- * Prevents mutation-during-callback issues by copying relevant fields.
- */
-export function snapshotTaskState(task: TeamTaskState): Readonly<TeamTaskState> {
-	return {
-		...task,
-		dependsOn: [...task.dependsOn],
-		usage: task.usage ? { ...task.usage } : undefined,
-		agentProgress: task.agentProgress ? { ...task.agentProgress } : undefined,
-		heartbeat: task.heartbeat ? { ...task.heartbeat } : undefined,
-		modelAttempts: task.modelAttempts?.map((a) => ({ ...a })),
-		modelRouting: task.modelRouting ? { ...task.modelRouting } : undefined,
-		claim: task.claim ? { ...task.claim } : undefined,
-		checkpoint: task.checkpoint ? { ...task.checkpoint } : undefined,
-		attempts: task.attempts?.map((a) => ({ ...a })),
-		worktree: task.worktree ? { ...task.worktree } : undefined,
-	};
-}
-
-/**
- * Session state snapshot for persistence before session switches.
- * Captures the minimal set of data needed to resume operations.
- */
-export interface SessionStateSnapshot {
-	/** ISO timestamp of the snapshot */
-	capturedAt: string;
-	/** Active run IDs at time of snapshot */
-	activeRunIds: string[];
-	/** Number of pending deliveries */
-	pendingDeliveryCount: number;
-	/** Session generation counter */
-	sessionGeneration: number;
-	/** Summary of active tasks by status */
-	taskSummary: Record<string, number>;
-}
-
-/**
- * Create a session state snapshot for pre-switch persistence.
- */
-export function createSessionSnapshot(
-	activeRuns: TeamRunManifest[],
-	pendingDeliveryCount: number,
-	sessionGeneration: number,
-): SessionStateSnapshot {
-	const taskSummary: Record<string, number> = {};
-	for (const run of activeRuns) {
-		taskSummary[run.status] = (taskSummary[run.status] ?? 0) + 1;
-	}
-	return {
-		capturedAt: new Date().toISOString(),
-		activeRunIds: activeRuns.map((r) => r.runId),
-		pendingDeliveryCount,
-		sessionGeneration,
-		taskSummary,
-	};
-}
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+
+/**
+ * Creates a lightweight snapshot of task state for event emission.
+ * Prevents mutation-during-callback issues by copying relevant fields.
+ */
+export function snapshotTaskState(task: TeamTaskState): Readonly<TeamTaskState> {
+	return {
+		...task,
+		dependsOn: [...task.dependsOn],
+		usage: task.usage ? { ...task.usage } : undefined,
+		agentProgress: task.agentProgress ? { ...task.agentProgress } : undefined,
+		heartbeat: task.heartbeat ? { ...task.heartbeat } : undefined,
+		modelAttempts: task.modelAttempts?.map((a) => ({ ...a })),
+		modelRouting: task.modelRouting ? { ...task.modelRouting } : undefined,
+		claim: task.claim ? { ...task.claim } : undefined,
+		checkpoint: task.checkpoint ? { ...task.checkpoint } : undefined,
+		attempts: task.attempts?.map((a) => ({ ...a })),
+		worktree: task.worktree ? { ...task.worktree } : undefined,
+	};
+}
+
+/**
+ * Session state snapshot for persistence before session switches.
+ * Captures the minimal set of data needed to resume operations.
+ */
+export interface SessionStateSnapshot {
+	/** ISO timestamp of the snapshot */
+	capturedAt: string;
+	/** Active run IDs at time of snapshot */
+	activeRunIds: string[];
+	/** Number of pending deliveries */
+	pendingDeliveryCount: number;
+	/** Session generation counter */
+	sessionGeneration: number;
+	/** Summary of active tasks by status */
+	taskSummary: Record<string, number>;
+}
+
+/**
+ * Create a session state snapshot for pre-switch persistence.
+ */
+export function createSessionSnapshot(
+	activeRuns: TeamRunManifest[],
+	pendingDeliveryCount: number,
+	sessionGeneration: number,
+): SessionStateSnapshot {
+	const taskSummary: Record<string, number> = {};
+	for (const run of activeRuns) {
+		taskSummary[run.status] = (taskSummary[run.status] ?? 0) + 1;
+	}
+	return {
+		capturedAt: new Date().toISOString(),
+		activeRunIds: activeRuns.map((r) => r.runId),
+		pendingDeliveryCount,
+		sessionGeneration,
+		taskSummary,
+	};
+}

package/src/runtime/session-usage.ts

@@ -1,79 +1,79 @@
-import * as fs from "node:fs";
-import type { UsageState } from "../state/types.ts";
-
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
-}
-
-function numberField(obj: Record<string, unknown>, keys: string[]): number | undefined {
-	for (const key of keys) {
-		const value = obj[key];
-		if (typeof value === "number" && Number.isFinite(value)) return value;
-	}
-	return undefined;
-}
-
-function usageFromValue(value: unknown): UsageState | undefined {
-	const obj = asRecord(value);
-	if (!obj) return undefined;
-	const direct: UsageState = {
-		input: numberField(obj, ["input", "inputTokens", "input_tokens"]),
-		output: numberField(obj, ["output", "outputTokens", "output_tokens"]),
-		cacheRead: numberField(obj, ["cacheRead", "cache_read", "cacheReadTokens", "cache_read_tokens"]),
-		cacheWrite: numberField(obj, ["cacheWrite", "cache_write", "cacheWriteTokens", "cache_write_tokens"]),
-		cost: numberField(obj, ["cost", "costUsd", "cost_usd"]),
-		turns: numberField(obj, ["turns", "turnCount", "turn_count"]),
-	};
-	if (Object.values(direct).some((entry) => entry !== undefined)) return direct;
-	for (const key of ["usage", "tokenUsage", "tokens", "stats"]) {
-		const nested = usageFromValue(obj[key]);
-		if (nested) return nested;
-	}
-	const message = asRecord(obj.message);
-	return message ? usageFromValue(message.usage) : undefined;
-}
-
-function addUsage(total: UsageState, usage: UsageState): UsageState {
-	return {
-		input: (total.input ?? 0) + (usage.input ?? 0),
-		output: (total.output ?? 0) + (usage.output ?? 0),
-		cacheRead: (total.cacheRead ?? 0) + (usage.cacheRead ?? 0),
-		cacheWrite: (total.cacheWrite ?? 0) + (usage.cacheWrite ?? 0),
-		cost: (total.cost ?? 0) + (usage.cost ?? 0),
-		turns: (total.turns ?? 0) + (usage.turns ?? 0),
-	};
-}
-
-function compactUsage(total: UsageState, foundKeys: Set<keyof UsageState>): UsageState | undefined {
-	if (foundKeys.size === 0) return undefined;
-	const compact: UsageState = {};
-	for (const key of foundKeys) compact[key] = total[key];
-	return compact;
-}
-
-export function parseSessionUsageFromJsonlText(text: string): UsageState | undefined {
-	let total: UsageState = {};
-	const foundKeys = new Set<keyof UsageState>();
-	for (const line of text.split(/\r?\n/)) {
-		const trimmed = line.trim();
-		if (!trimmed) continue;
-		try {
-			const usage = usageFromValue(JSON.parse(trimmed) as unknown);
-			if (!usage) continue;
-			for (const key of Object.keys(usage) as Array<keyof UsageState>) foundKeys.add(key);
-			total = addUsage(total, usage);
-		} catch {
-			// Session JSONL can contain partial/corrupt lines after interrupted workers.
-		}
-	}
-	return compactUsage(total, foundKeys);
-}
-
-export function parseSessionUsage(filePath: string): UsageState | undefined {
-	try {
-		if (!fs.existsSync(filePath)) return undefined;
-		return parseSessionUsageFromJsonlText(fs.readFileSync(filePath, "utf-8"));
-	} catch {
-		return undefined;
-	}
-}
+import * as fs from "node:fs";
+import type { UsageState } from "../state/types.ts";
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+function numberField(obj: Record<string, unknown>, keys: string[]): number | undefined {
+	for (const key of keys) {
+		const value = obj[key];
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+	}
+	return undefined;
+}
+
+function usageFromValue(value: unknown): UsageState | undefined {
+	const obj = asRecord(value);
+	if (!obj) return undefined;
+	const direct: UsageState = {
+		input: numberField(obj, ["input", "inputTokens", "input_tokens"]),
+		output: numberField(obj, ["output", "outputTokens", "output_tokens"]),
+		cacheRead: numberField(obj, ["cacheRead", "cache_read", "cacheReadTokens", "cache_read_tokens"]),
+		cacheWrite: numberField(obj, ["cacheWrite", "cache_write", "cacheWriteTokens", "cache_write_tokens"]),
+		cost: numberField(obj, ["cost", "costUsd", "cost_usd"]),
+		turns: numberField(obj, ["turns", "turnCount", "turn_count"]),
+	};
+	if (Object.values(direct).some((entry) => entry !== undefined)) return direct;
+	for (const key of ["usage", "tokenUsage", "tokens", "stats"]) {
+		const nested = usageFromValue(obj[key]);
+		if (nested) return nested;
+	}
+	const message = asRecord(obj.message);
+	return message ? usageFromValue(message.usage) : undefined;
+}
+
+function addUsage(total: UsageState, usage: UsageState): UsageState {
+	return {
+		input: (total.input ?? 0) + (usage.input ?? 0),
+		output: (total.output ?? 0) + (usage.output ?? 0),
+		cacheRead: (total.cacheRead ?? 0) + (usage.cacheRead ?? 0),
+		cacheWrite: (total.cacheWrite ?? 0) + (usage.cacheWrite ?? 0),
+		cost: (total.cost ?? 0) + (usage.cost ?? 0),
+		turns: (total.turns ?? 0) + (usage.turns ?? 0),
+	};
+}
+
+function compactUsage(total: UsageState, foundKeys: Set<keyof UsageState>): UsageState | undefined {
+	if (foundKeys.size === 0) return undefined;
+	const compact: UsageState = {};
+	for (const key of foundKeys) compact[key] = total[key];
+	return compact;
+}
+
+export function parseSessionUsageFromJsonlText(text: string): UsageState | undefined {
+	let total: UsageState = {};
+	const foundKeys = new Set<keyof UsageState>();
+	for (const line of text.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			const usage = usageFromValue(JSON.parse(trimmed) as unknown);
+			if (!usage) continue;
+			for (const key of Object.keys(usage) as Array<keyof UsageState>) foundKeys.add(key);
+			total = addUsage(total, usage);
+		} catch {
+			// Session JSONL can contain partial/corrupt lines after interrupted workers.
+		}
+	}
+	return compactUsage(total, foundKeys);
+}
+
+export function parseSessionUsage(filePath: string): UsageState | undefined {
+	try {
+		if (!fs.existsSync(filePath)) return undefined;
+		return parseSessionUsageFromJsonlText(fs.readFileSync(filePath, "utf-8"));
+	} catch {
+		return undefined;
+	}
+}

package/src/runtime/sidechain-output.ts

@@ -1,29 +1,29 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { redactSecrets } from "../utils/redaction.ts";
-
-export interface SidechainEntry {
-	isSidechain: true;
-	agentId: string;
-	type: string;
-	message: unknown;
-	timestamp: string;
-	cwd: string;
-}
-
-export function writeSidechainEntry(filePath: string, entry: Omit<SidechainEntry, "isSidechain" | "timestamp">): void {
-	fs.mkdirSync(path.dirname(filePath), { recursive: true });
-	fs.appendFileSync(filePath, `${JSON.stringify(redactSecrets({ isSidechain: true, timestamp: new Date().toISOString(), ...entry }))}\n`, "utf-8");
-}
-
-export function sidechainOutputPath(stateRoot: string, taskId: string): string {
-	return path.join(stateRoot, "agents", taskId, "sidechain.output.jsonl");
-}
-
-export function eventToSidechainType(event: unknown): string | undefined {
-	if (!event || typeof event !== "object" || Array.isArray(event)) return undefined;
-	const type = (event as { type?: unknown }).type;
-	if (type === "message_start" || type === "message_update" || type === "message_end") return "message";
-	if (type === "tool_execution_start" || type === "tool_execution_update" || type === "tool_execution_end") return "tool";
-	return typeof type === "string" ? type : undefined;
-}
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { redactSecrets } from "../utils/redaction.ts";
+
+export interface SidechainEntry {
+	isSidechain: true;
+	agentId: string;
+	type: string;
+	message: unknown;
+	timestamp: string;
+	cwd: string;
+}
+
+export function writeSidechainEntry(filePath: string, entry: Omit<SidechainEntry, "isSidechain" | "timestamp">): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.appendFileSync(filePath, `${JSON.stringify(redactSecrets({ isSidechain: true, timestamp: new Date().toISOString(), ...entry }))}\n`, "utf-8");
+}
+
+export function sidechainOutputPath(stateRoot: string, taskId: string): string {
+	return path.join(stateRoot, "agents", taskId, "sidechain.output.jsonl");
+}
+
+export function eventToSidechainType(event: unknown): string | undefined {
+	if (!event || typeof event !== "object" || Array.isArray(event)) return undefined;
+	const type = (event as { type?: unknown }).type;
+	if (type === "message_start" || type === "message_update" || type === "message_end") return "message";
+	if (type === "tool_execution_start" || type === "tool_execution_update" || type === "tool_execution_end") return "tool";
+	return typeof type === "string" ? type : undefined;
+}

package/src/runtime/skill-instructions.ts

@@ -0,0 +1,222 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { AgentConfig } from "../agents/agent-config.ts";
+import type { TeamRole } from "../teams/team-config.ts";
+import type { WorkflowStep } from "../workflows/workflow-config.ts";
+import { isSafePathId, resolveContainedPath, resolveRealContainedPath } from "../utils/safe-paths.ts";
+
+const PACKAGE_SKILLS_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "skills");
+const MAX_SKILL_CHARS = 1500;
+const MAX_TOTAL_CHARS = 6000;
+const MAX_SKILL_NAME_CHARS = 80;
+const MAX_SELECTED_SKILLS = 32;
+const SKILL_CACHE_MAX_ENTRIES = 128;
+
+const DEFAULT_ROLE_SKILLS: Record<string, string[]> = {
+	explorer: ["read-only-explorer", "context-artifact-hygiene"],
+	analyst: ["read-only-explorer", "requirements-to-task-packet"],
+	planner: ["delegation-patterns", "requirements-to-task-packet"],
+	critic: ["read-only-explorer", "multi-perspective-review"],
+	executor: ["state-mutation-locking", "safe-bash", "verification-before-done"],
+	reviewer: ["read-only-explorer", "multi-perspective-review"],
+	"security-reviewer": ["secure-agent-orchestration-review", "ownership-session-security"],
+	"test-engineer": ["verification-before-done", "safe-bash"],
+	verifier: ["verification-before-done", "runtime-state-reader"],
+	writer: ["context-artifact-hygiene", "verify-evidence"],
+};
+
+export interface ResolveTaskSkillsInput {
+	role: string;
+	agent?: Pick<AgentConfig, "skills">;
+	teamRole?: Pick<TeamRole, "skills">;
+	step?: Pick<WorkflowStep, "skills">;
+	override?: string[] | false;
+}
+
+export interface RenderSkillInstructionsInput extends ResolveTaskSkillsInput {
+	cwd: string;
+}
+
+function isValidSkillName(name: string): boolean {
+	return name.length > 0 && name.length <= MAX_SKILL_NAME_CHARS && isSafePathId(name);
+}
+
+function sanitizeSkillName(name: string): string {
+	return name.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, MAX_SKILL_NAME_CHARS) || "invalid";
+}
+
+function unique(items: string[]): string[] {
+	const seen = new Set<string>();
+	const result: string[] = [];
+	for (const item of items.map((entry) => entry.trim()).filter(Boolean)) {
+		if (!isValidSkillName(item)) continue;
+		if (seen.has(item)) continue;
+		seen.add(item);
+		result.push(item);
+	}
+	return result;
+}
+
+export function normalizeSkillOverride(value: string | string[] | boolean | undefined): string[] | false | undefined {
+	if (value === false) return false;
+	if (typeof value === "string") return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+	if (value === true) return undefined;
+	if (Array.isArray(value)) return value.map((entry) => entry.trim()).filter(Boolean);
+	return undefined;
+}
+
+export function defaultSkillsForRole(role: string): string[] {
+	return DEFAULT_ROLE_SKILLS[role] ?? [];
+}
+
+function collectTaskSkillNames(input: ResolveTaskSkillsInput): string[] {
+	if (input.override === false) return [];
+	const roleDefaultsDisabled = input.teamRole?.skills === false || input.step?.skills === false;
+	const names = roleDefaultsDisabled ? [] : defaultSkillsForRole(input.role);
+	if (input.agent?.skills?.length) names.push(...input.agent.skills);
+	if (Array.isArray(input.teamRole?.skills)) names.push(...input.teamRole.skills);
+	if (Array.isArray(input.step?.skills)) names.push(...input.step.skills);
+	if (Array.isArray(input.override)) names.push(...input.override);
+	return unique(names);
+}
+
+export function resolveTaskSkillNames(input: ResolveTaskSkillsInput): string[] {
+	return collectTaskSkillNames(input).slice(0, MAX_SELECTED_SKILLS);
+}
+
+function candidateSkillDirs(cwd: string): Array<{ root: string; source: "project" | "package" }> {
+	return [
+		{ root: path.resolve(cwd, "skills"), source: "project" },
+		{ root: PACKAGE_SKILLS_DIR, source: "package" },
+	];
+}
+
+interface CachedSkillMarkdown {
+	path: string;
+	source: "project" | "package";
+	content: string;
+	mtimeMs: number;
+	size: number;
+}
+
+const skillReadCache = new Map<string, CachedSkillMarkdown>();
+
+function rememberSkill(key: string, value: CachedSkillMarkdown): CachedSkillMarkdown {
+	if (skillReadCache.has(key)) skillReadCache.delete(key);
+	skillReadCache.set(key, value);
+	while (skillReadCache.size > SKILL_CACHE_MAX_ENTRIES) {
+		const oldest = skillReadCache.keys().next().value;
+		if (!oldest) break;
+		skillReadCache.delete(oldest);
+	}
+	return value;
+}
+
+export function clearSkillInstructionCache(): void {
+	skillReadCache.clear();
+}
+
+function cachedSkillFresh(value: CachedSkillMarkdown): boolean {
+	try {
+		const stat = fs.statSync(value.path);
+		return stat.mtimeMs === value.mtimeMs && stat.size === value.size;
+	} catch {
+		return false;
+	}
+}
+
+function readSkillMarkdown(cwd: string, name: string): { path: string; source: "project" | "package"; content: string } | undefined {
+	if (!isValidSkillName(name)) return undefined;
+	const cacheKey = `${path.resolve(cwd)}:${name}`;
+	const cached = skillReadCache.get(cacheKey);
+	if (cached && cachedSkillFresh(cached)) return cached;
+	if (cached) skillReadCache.delete(cacheKey);
+	for (const entry of candidateSkillDirs(cwd)) {
+		try {
+			const relative = path.join(name, "SKILL.md");
+			const contained = resolveContainedPath(entry.root, relative);
+			if (!fs.existsSync(contained)) continue;
+			if (fs.lstatSync(contained).isSymbolicLink()) continue;
+			const filePath = resolveRealContainedPath(entry.root, relative);
+			const stat = fs.statSync(filePath);
+			return rememberSkill(cacheKey, { path: filePath, source: entry.source, content: fs.readFileSync(filePath, "utf-8"), mtimeMs: stat.mtimeMs, size: stat.size });
+		} catch {
+			continue;
+		}
+	}
+	return undefined;
+}
+
+function frontmatterDescription(content: string): string | undefined {
+	const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+	if (!match) return undefined;
+	const line = match[1].split(/\r?\n/).find((entry) => entry.startsWith("description:"));
+	return line?.slice("description:".length).trim();
+}
+
+function stripFrontmatter(content: string): string {
+	return content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, "").trim();
+}
+
+function compactSkillContent(content: string): string {
+	const body = stripFrontmatter(content);
+	if (body.length <= MAX_SKILL_CHARS) return body;
+	const preferred = body.split(/\r?\n## Verification\r?\n/)[0]?.trim() ?? body;
+	const truncated = preferred.length > MAX_SKILL_CHARS ? preferred.slice(0, MAX_SKILL_CHARS - 40).trimEnd() : preferred;
+	return `${truncated}\n\n[skill instructions truncated]`;
+}
+
+export interface RenderedSkillInstructions {
+	names: string[];
+	paths: string[];
+	block: string;
+}
+
+export function renderSkillInstructions(input: RenderSkillInstructionsInput): RenderedSkillInstructions {
+	const allNames = collectTaskSkillNames(input);
+	const names = allNames.slice(0, MAX_SELECTED_SKILLS);
+	const overflowCount = Math.max(0, allNames.length - names.length);
+	if (names.length === 0) return { names, paths: [], block: "" };
+	const sections: string[] = [];
+	const skillPaths: string[] = [];
+	let total = 0;
+	let omittedCount = overflowCount;
+	const pushSection = (section: string): boolean => {
+		if (total + section.length > MAX_TOTAL_CHARS) return false;
+		sections.push(section);
+		total += section.length;
+		return true;
+	};
+	for (const name of names) {
+		const safeName = sanitizeSkillName(name);
+		const loaded = readSkillMarkdown(input.cwd, name);
+		if (!loaded) {
+			const missing = `## ${safeName}\n\nSkill '${safeName}' was selected but no SKILL.md file was found. Continue with the task packet and report this missing skill.`;
+			if (!pushSection(missing)) omittedCount += 1;
+			continue;
+		}
+		skillPaths.push(path.dirname(loaded.path));
+		const description = frontmatterDescription(loaded.content);
+		const source = loaded.source === "project" ? `project:skills/${safeName}` : `package:skills/${safeName}`;
+		const header = [`## ${safeName}`, description ? `Description: ${description}` : undefined, `Source: ${source}`].filter(Boolean).join("\n");
+		const section = `${header}\n\n${compactSkillContent(loaded.content)}`;
+		if (!pushSection(section)) omittedCount += 1;
+	}
+	if (omittedCount > 0) {
+		const summary = `## Omitted skills\n\n[omitted ${omittedCount} selected skill(s): skill instruction budget exceeded]`;
+		if (!pushSection(summary) && sections.length > 0) {
+			sections[sections.length - 1] = summary;
+		}
+	}
+	return {
+		names,
+		paths: [...new Set(skillPaths)],
+		block: [
+			"# Applicable Skills",
+			"The following skills were selected for this worker. Follow them when they match the current task. If a selected skill conflicts with the explicit task packet, project AGENTS.md, or user request, follow the stricter/higher-priority instruction and report the conflict.",
+			"",
+			sections.join("\n\n---\n\n"),
+		].join("\n"),
+	};
+}

package/src/runtime/stale-reconciler.ts

@@ -1,9 +1,5 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { checkProcessLiveness } from "./process-status.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import { writeAtomicJson } from "../utils/atomic-write.ts";
 
 /**
  * Result of reconciling a single stale run.
@@ -16,6 +12,8 @@ export interface ReconcileResult {
 	repaired: boolean;
 	/** Human-readable detail */
 	detail: string;
+	/** Repaired task state, returned to a locked caller for persistence. */
+	repairedTasks?: TeamTaskState[];
 }
 
 const STALE_ALIVE_PID_MS = 24 * 60 * 60 * 1000; // 24 hours
@@ -106,16 +104,6 @@ function repairStaleRun(
 		return task;
 	});
 
-	// Write repaired tasks atomically
-	const tasksPath = manifest.tasksPath;
-	if (tasksPath) {
-		try {
-			writeAtomicJson(tasksPath, repairedTasks);
-		} catch (error) {
-			logInternalError("stale-reconciler.repair-tasks", error, `runId=${manifest.runId}`);
-		}
-	}
-
 	return repairedTasks;
 }
 
@@ -167,6 +155,7 @@ export function reconcileStaleRun(
 				verdict: "no_status",
 				repaired: true,
 				detail: `No PID; stale ${Math.round((now - updatedAt) / 3600_000)}h; repaired ${repaired.filter((t) => t.status === "cancelled").length} tasks`,
+				repairedTasks: repaired,
 			};
 		}
 		return {
@@ -195,5 +184,6 @@ export function reconcileStaleRun(
 		verdict: pidStatus.alive ? "pid_alive_stale" : "pid_dead",
 		repaired: true,
 		detail: `PID ${pid}: ${pidStatus.detail}; ${staleness.reason}; repaired ${repaired.filter((t) => t.status === "cancelled").length} tasks`,
+		repairedTasks: repaired,
 	};
 }

package/src/runtime/subagent-manager.ts

@@ -17,6 +17,7 @@ export interface SubagentSpawnOptions {
 	prompt: string;
 	background: boolean;
 	model?: string;
+	skill?: string | string[] | false;
 	maxTurns?: number;
 	ownerSessionGeneration?: number;
 }
@@ -34,6 +35,7 @@ export interface SubagentRecord {
 	error?: string;
 	resultConsumed?: boolean;
 	model?: string;
+	skill?: string | string[] | false;
 	background: boolean;
 	ownerSessionGeneration?: number;
 	stuckNotified?: boolean;
@@ -138,6 +140,7 @@ export class SubagentManager {
 			status: options.background && this.runningBackground >= this.maxConcurrent ? "queued" : "running",
 			startedAt: Date.now(),
 			model: options.model,
+			skill: options.skill,
 			background: options.background,
 			ownerSessionGeneration: options.ownerSessionGeneration,
 		};