pi-crew 0.9.53 → 0.9.55

package/src/extension/async-notifier.ts

@@ -0,0 +1,179 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { readCrewAgents, saveCrewAgents } from "../runtime/crew-agent-records.ts";
+import { checkProcessLiveness, isActiveRunStatus } from "../runtime/process-status.ts";
+import { appendEvent, readEvents, type TeamEvent } from "../state/event-log.ts";
+import { withRunLockSync } from "../state/locks.ts";
+import { loadRunManifestById, saveRunTasks, updateRunStatus } from "../state/state-store.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import { logInternalError } from "../utils/internal-error.ts";
+import { listRuns } from "./run-index.ts";
+
+export interface AsyncNotifierState {
+	seenFinishedRunIds: Set<string>;
+	interval?: ReturnType<typeof setInterval>;
+	generation?: number;
+	lastStoppedAtMs?: number;
+	lastListRunsMs?: number;
+}
+
+export interface AsyncNotifierOptions {
+	generation?: number;
+	isCurrent?: (generation: number) => boolean;
+}
+
+function isFinished(status: string): boolean {
+	return status === "completed" || status === "failed" || status === "cancelled" || status === "blocked";
+}
+
+function isAsyncTerminalEvent(event: TeamEvent): boolean {
+	return event.type === "async.completed" || event.type === "async.failed" || event.type === "async.died";
+}
+
+function timeMs(value: string | undefined): number | undefined {
+	if (!value) return undefined;
+	const parsed = new Date(value).getTime();
+	return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function latestEventAgeMs(events: TeamEvent[], now = Date.now()): number {
+	const latest = events.at(-1);
+	if (!latest) return Number.POSITIVE_INFINITY;
+	const time = new Date(latest.time).getTime();
+	return Number.isFinite(time) ? now - time : Number.POSITIVE_INFINITY;
+}
+
+function isTaskActive(task: TeamTaskState): boolean {
+	return task.status === "running" || task.status === "queued" || task.status === "waiting";
+}
+
+function markActiveTasksAndAgentsFailed(run: TeamRunManifest, message: string): void {
+	const loaded = loadRunManifestById(run.cwd, run.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
+	const tasks = loaded?.tasks ?? [];
+	const failedAt = new Date().toISOString();
+	if (tasks.some(isTaskActive)) {
+		saveRunTasks(
+			run,
+			tasks.map((task) =>
+				isTaskActive(task)
+					? {
+							...task,
+							status: "failed",
+							finishedAt: failedAt,
+							error: message,
+						}
+					: task,
+			),
+		);
+	}
+	const agents = readCrewAgents(run);
+	if (agents.some((agent) => agent.status === "running" || agent.status === "queued" || agent.status === "waiting")) {
+		saveCrewAgents(
+			run,
+			agents.map((agent) =>
+				agent.status === "running" || agent.status === "queued" || agent.status === "waiting"
+					? {
+							...agent,
+							status: "failed",
+							completedAt: failedAt,
+							error: message,
+						}
+					: agent,
+			),
+		);
+	}
+}
+
+export function markDeadAsyncRunIfNeeded(run: TeamRunManifest, now = Date.now(), quietMs = 30_000): TeamRunManifest | undefined {
+	if (!run.async || !isActiveRunStatus(run.status)) return undefined;
+	const liveness = checkProcessLiveness(run.async.pid);
+	if (liveness.alive) return undefined;
+	const events = readEvents(run.eventsPath);
+	if (events.some(isAsyncTerminalEvent)) return undefined;
+	if (latestEventAgeMs(events, now) < quietMs) return undefined;
+	const asyncPid = run.async.pid;
+	const message = `Background runner died unexpectedly; check background.log (${liveness.detail}).`;
+	return withRunLockSync(run, () => {
+		const fresh = loadRunManifestById(run.cwd, run.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency;
+		if (!fresh || !isActiveRunStatus(fresh.manifest.status)) return undefined;
+		const failed = updateRunStatus(fresh.manifest, "failed", message);
+		markActiveTasksAndAgentsFailed(failed, message);
+		appendEvent(failed.eventsPath, {
+			type: "async.died",
+			runId: failed.runId,
+			message,
+			data: { pid: asyncPid, detail: liveness.detail },
+		});
+		return failed;
+	});
+}
+
+const LIST_RUNS_DEBOUNCE_MS = 30_000;
+
+export function startAsyncRunNotifier(
+	ctx: ExtensionContext,
+	state: AsyncNotifierState,
+	intervalMs = 5000,
+	options: AsyncNotifierOptions = {},
+): void {
+	if (state.interval) clearInterval(state.interval);
+	const generation = options.generation ?? (state.generation ?? 0) + 1;
+	state.generation = generation;
+	const startedAtMs = Date.now();
+	const staleBeforeMs = state.lastStoppedAtMs ?? startedAtMs;
+	for (const run of listRuns(ctx.cwd)) {
+		// Suppress only terminal runs that were already finished before this owner
+		// session (or before the previous session switch). Active runs must remain
+		// un-seen so completions during auto-compaction/session restart are delivered.
+		const updatedAtMs = timeMs(run.updatedAt) ?? 0;
+		if (isFinished(run.status) && updatedAtMs < staleBeforeMs) state.seenFinishedRunIds.add(run.runId);
+	}
+	let cachedRuns: TeamRunManifest[] | undefined;
+	state.interval = setInterval(() => {
+		try {
+			if (options.isCurrent && !options.isCurrent(generation)) return;
+			const nowMs = Date.now();
+			if (cachedRuns === undefined || nowMs - (state.lastListRunsMs ?? 0) > LIST_RUNS_DEBOUNCE_MS) {
+				cachedRuns = listRuns(ctx.cwd).slice(0, 20);
+				state.lastListRunsMs = nowMs;
+			}
+			for (const run of cachedRuns) {
+				const current = markDeadAsyncRunIfNeeded(run) ?? run;
+				if (!isFinished(current.status) || state.seenFinishedRunIds.has(current.runId)) continue;
+				state.seenFinishedRunIds.add(current.runId);
+				// Suppress notifications for INTERNAL goal-loop sub-runs.
+				// The outer goal-loop creates a synthetic 'goal-turn' workflow per turn
+				// (see buildTurnWorkflow in goal-loop-runner.ts). These runs are
+				// implementation details of the autonomous loop — the user only cares
+				// about the OUTER goal-loop's status (runKind:'goal-loop'), which has
+				// its own event stream + status command. Without this filter, every
+				// turn that hits e.g. a transient model rate limit triggers an
+				// alarming 'Error: pi-crew run failed' toast for an internal sub-run
+				// the user never started directly.
+				if (current.workflow === "goal-turn" && current.team.startsWith("goal-")) continue;
+				const level = current.status === "completed" ? "info" : current.status === "cancelled" ? "warning" : "error";
+				ctx.ui.notify(`pi-crew run ${current.status}: ${current.runId} (${current.team}/${current.workflow ?? "none"})`, level);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (message.includes("stale") || message.includes("session replacement") || message.includes("old ctx")) {
+				// Don't stop the interval — session_start will create a new notifier
+				// with the refreshed ctx. The isCurrent guard will make this old
+				// notifier dormant once sessionGeneration increments.
+				// Stopping here creates a race: old notifier dies before new one starts.
+				return;
+			}
+			logInternalError("async-notifier", error, `interval=${intervalMs}`);
+		}
+	}, intervalMs);
+	// Defense-in-depth: never let the notifier timer keep the event loop alive.
+	// If stopAsyncRunNotifier is missed (session switch race), the next run of
+	// this interval is harmless, but the timer must not block process exit.
+	if (typeof state.interval.unref === "function") state.interval.unref();
+}
+
+export function stopAsyncRunNotifier(state: AsyncNotifierState): void {
+	if (state.interval) clearInterval(state.interval);
+	state.interval = undefined;
+	state.generation = (state.generation ?? 0) + 1;
+	state.lastStoppedAtMs = Date.now();
+}

package/src/extension/autonomous-policy.ts

@@ -0,0 +1,209 @@
+import type { BeforeAgentStartEvent, ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { allAgents, discoverAgents } from "../agents/discover-agents.ts";
+import { effectiveAutonomousConfig, loadConfig, type PiTeamsAutonomousConfig } from "../config/config.ts";
+import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
+import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
+
+const DEFAULT_MAGIC_KEYWORDS: Record<string, string[]> = {
+	implementation: ["autoteam", "team:", "implementation-team", "pi-crew", "dùng team", "use team"],
+	review: ["review-team", "security review", "code review"],
+	fastFix: ["fast-fix", "quick fix"],
+	research: ["research-team", "deep research"],
+};
+
+const BULLET_OR_NUMBERED_TASK_RE = /^\s*(?:[-*•]|\d+[.)])\s+\S+/;
+const ACTIONABLE_TASK_TERMS: readonly string[] = Array.from(
+	new Set([
+		"implement",
+		"refactor",
+		"migrate",
+		"fix",
+		"add",
+		"update",
+		"test",
+		"review",
+		"research",
+		"analyze",
+		"document",
+		"docs",
+		"sửa",
+		"thêm",
+		"cập nhật",
+		"kiểm thử",
+		"nghiên cứu",
+		"phân tích",
+		"viết docs",
+	]),
+);
+
+function mergeMagicKeywords(configured: Record<string, string[]> | undefined): Record<string, string[]> {
+	return { ...DEFAULT_MAGIC_KEYWORDS, ...(configured ?? {}) };
+}
+
+function actionableLineCount(prompt: string): number {
+	return prompt
+		.split(/\r?\n/)
+		.map((line) => line.trim())
+		.filter((line) => BULLET_OR_NUMBERED_TASK_RE.test(line) && ACTIONABLE_TASK_TERMS.some((term) => line.toLowerCase().includes(term)))
+		.length;
+}
+
+function hasTaskListSignal(prompt: string): boolean {
+	const lower = prompt.toLowerCase();
+	const bulletCount = prompt.split(/\r?\n/).filter((line) => BULLET_OR_NUMBERED_TASK_RE.test(line)).length;
+	const explicitList = ["các task", "danh sách task", "todo", "tasks sau", "task list", "làm lần lượt"].some((term) =>
+		lower.includes(term),
+	);
+	return bulletCount >= 3 || actionableLineCount(prompt) >= 2 || (explicitList && bulletCount >= 2);
+}
+
+export function detectTeamIntent(prompt: string, config: PiTeamsAutonomousConfig = {}): string[] {
+	const lower = prompt.toLowerCase();
+	const matches: string[] = [];
+	for (const [intent, keywords] of Object.entries(mergeMagicKeywords(config.magicKeywords))) {
+		if (keywords.some((keyword) => lower.includes(keyword.toLowerCase()))) matches.push(intent);
+	}
+	if (hasTaskListSignal(prompt) && !matches.includes("taskList")) matches.push("taskList");
+	return matches;
+}
+
+export function buildAutonomousPolicy(prompt: string, config: PiTeamsAutonomousConfig = {}): string {
+	const effective = effectiveAutonomousConfig(config);
+	const intents = detectTeamIntent(prompt, config);
+	const asyncGuidance = effective.preferAsyncForLongTasks
+		? "For long-running team runs, prefer async: true unless the user needs immediate foreground progress."
+		: "Use async: true only when the task is clearly long-running or the user asks for background execution.";
+	const worktreeGuidance =
+		effective.allowWorktreeSuggestion === false
+			? "Do not suggest worktree mode unless the user explicitly asks for it."
+			: "Consider workspaceMode: 'worktree' for parallel or risky code-changing work in clean git repositories.";
+	return [
+		"# pi-crew Delegation Policy (MANDATORY)",
+		"",
+		`Autonomy profile: ${effective.profile}.`,
+		"You MUST evaluate EVERY user request against the delegation decision table below BEFORE acting.",
+		"",
+		"## Decision Table — Do I delegate?",
+		"",
+		"| Task characteristic | Delegate? | Method |",
+		"|---|---|---|",
+		"| Read/edit 1-2 files, simple question | NO | Do it directly |",
+		'| User explicitly says "do it yourself" / "no team" | NO | Do it directly |',
+		"| Destructive action (delete/prune/forget) | NO | Ask for confirmation first |",
+		"| Research / deep-read / source audit / \"nghiên cứu\" | YES | `team action='research'` |",
+		"| Multi-file implementation / feature / refactor | YES | `team action='run', team='implementation'` |",
+		"| Small bug fix (1-2 files, clear cause) | YES | `team action='run', team='fast-fix'` |",
+		"| Code review / security review | YES | `team action='run', team='review'` |",
+		"| Task list with 2+ actionable items | YES | `team action='plan'` or `action='run'` |",
+		"| Need exploration before knowing scope | YES | `Agent(explorer)` or `team action='recommend'` |",
+		"| Parallel independent subtasks | YES | `team action='parallel'` or multiple `Agent` background |",
+		"| Unsure which team/workflow fits | YES | `team action='recommend'` first |",
+		"",
+		"## Rules",
+		"",
+		"1. If the task needs reading >3 files OR editing >2 files OR has a research/review/planning component → you MUST delegate via `team` or `Agent`. Do not do it yourself.",
+		"2. After delegating, do NOT duplicate the same exploration/reading/review manually. Continue only with non-overlapping work.",
+		"3. Before claiming delegated work is complete, verify with `team action='status'` or `action='summary'`.",
+		"4. If unsure whether subtasks conflict, use `team action='recommend'` first.",
+		"5. For parallel implementation, prefer `workspaceMode: 'worktree'` in clean git repos.",
+		"",
+		"## Conflict-safe task splitting",
+		"- Do not parallelize subtasks that may edit the same file, same symbol, or same lockfile.",
+		"- Assign one owner per file/symbol. Workers must report intended changed files before editing.",
+		"- If workers discover overlap, they must pause and ask the leader to resolve.",
+		"",
+		asyncGuidance,
+		worktreeGuidance,
+		intents.length > 0
+			? `Detected pi-crew routing signals/intents in the user prompt: ${intents.join(", ")}. Consider the matching team workflow if appropriate.`
+			: "No explicit pi-crew routing signal was detected; decide based on complexity, risk, task-list structure, and conflict potential.",
+	].join("\n");
+}
+
+function sourcePriority(source: string): number {
+	if (source === "project") return 0;
+	if (source === "user" || source === "git") return 1;
+	return 2;
+}
+
+function capLines(lines: string[], maxChars: number): string[] {
+	const kept: string[] = [];
+	let used = 0;
+	for (const line of lines) {
+		const next = used + line.length + 1;
+		if (next > maxChars) {
+			kept.push("- ...resource guidance truncated to stay within prompt budget");
+			break;
+		}
+		kept.push(line);
+		used = next;
+	}
+	return kept;
+}
+
+export function buildResourceRoutingGuidance(cwd: string, maxChars = 5000): string {
+	const teams = allTeams(discoverTeams(cwd))
+		.sort((a, b) => sourcePriority(a.source) - sourcePriority(b.source))
+		.slice(0, 12);
+	const workflows = allWorkflows(discoverWorkflows(cwd))
+		.sort((a, b) => sourcePriority(a.source) - sourcePriority(b.source))
+		.slice(0, 12);
+	const agents = allAgents(discoverAgents(cwd))
+		.sort((a, b) => sourcePriority(a.source) - sourcePriority(b.source))
+		.slice(0, 16);
+	const lines = [
+		"# pi-crew Available Resources",
+		"Use project-scoped resources over user/builtin resources when names overlap.",
+		"Teams:",
+		...(teams.length
+			? teams.map(
+					(team) =>
+						`- ${team.name} (${team.source}): ${team.description}; defaultWorkflow=${team.defaultWorkflow ?? "default"}; roles=${team.roles.map((role) => `${role.name}->${role.agent}`).join(", ") || "none"}${team.routing?.triggers?.length ? `; triggers=${team.routing.triggers.join(",")}` : ""}${team.routing?.useWhen?.length ? `; useWhen=${team.routing.useWhen.join(";")}` : ""}`,
+				)
+			: ["- (none)"]),
+		"Workflows:",
+		...(workflows.length
+			? workflows.map(
+					(workflow) =>
+						`- ${workflow.name} (${workflow.source}): ${workflow.description}; steps=${workflow.steps.map((step) => `${step.id}:${step.role}`).join(", ") || "none"}`,
+				)
+			: ["- (none)"]),
+		"Agents:",
+		...(agents.length
+			? agents.map(
+					(agent) =>
+						`- ${agent.name} (${agent.source}): ${agent.description}${agent.routing?.triggers?.length ? `; triggers=${agent.routing.triggers.join(",")}` : ""}${agent.routing?.useWhen?.length ? `; useWhen=${agent.routing.useWhen.join(";")}` : ""}${agent.routing?.avoidWhen?.length ? `; avoidWhen=${agent.routing.avoidWhen.join(";")}` : ""}${agent.routing?.cost ? `; cost=${agent.routing.cost}` : ""}${agent.routing?.category ? `; category=${agent.routing.category}` : ""}`,
+				)
+			: ["- (none)"]),
+	];
+	return capLines(lines, maxChars).join("\n");
+}
+
+export function appendAutonomousPolicy(
+	systemPrompt: string,
+	userPrompt: string,
+	config: PiTeamsAutonomousConfig = {},
+	cwd?: string,
+): string {
+	const resourceGuidance = cwd ? `\n\n${buildResourceRoutingGuidance(cwd)}` : "";
+	return `${systemPrompt}\n\n${buildAutonomousPolicy(userPrompt, config)}${resourceGuidance}`;
+}
+
+export function registerAutonomousPolicy(pi: ExtensionAPI): void {
+	pi.on("before_agent_start", (event: BeforeAgentStartEvent) => {
+		const options =
+			(
+				event as BeforeAgentStartEvent & {
+					systemPromptOptions?: { cwd?: unknown };
+				}
+			).systemPromptOptions ?? {};
+		const cwd = typeof options.cwd === "string" ? options.cwd : undefined;
+		const loaded = loadConfig(cwd);
+		const autonomous = effectiveAutonomousConfig(loaded.config.autonomous);
+		if (!autonomous.enabled) return undefined;
+		if (!autonomous.injectPolicy) return undefined;
+		return {
+			systemPrompt: appendAutonomousPolicy(event.systemPrompt, event.prompt, autonomous, cwd),
+		};
+	});
+}

package/src/extension/command-completions.ts

@@ -0,0 +1,120 @@
+/**
+ * Command argument autocomplete helpers (Round 13 UX quick-win).
+ *
+ * Pi's built-in slash-command autocomplete calls a command's
+ * `getArgumentCompletions(argumentPrefix)` when the user types
+ * `/command <prefix><TAB>`. Returning AutocompleteItem[] surfaces those
+ * suggestions; returning null falls back to file completion.
+ *
+ * These helpers provide run-id, team, and workflow completions without
+ * requiring the user to memorize long generated IDs.
+ */
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+import { allAgents, discoverAgents } from "../agents/discover-agents.ts";
+import type { TeamRunManifest } from "../state/types.ts";
+import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
+import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
+import { listRecentRuns } from "./run-index.ts";
+
+const MAX_RUN_SUGGESTIONS = 15;
+
+function filterByPrefix(items: AutocompleteItem[], prefix: string): AutocompleteItem[] | null {
+	const trimmed = prefix.trim();
+	const filtered =
+		trimmed === ""
+			? items
+			: items.filter((item) => item.value.startsWith(trimmed) || item.label.toLowerCase().includes(trimmed.toLowerCase()));
+	return filtered.length > 0 ? filtered.slice(0, MAX_RUN_SUGGESTIONS) : null;
+}
+
+function statusIcon(status: TeamRunManifest["status"]): string {
+	switch (status) {
+		case "running":
+		case "planning":
+			return "▶";
+		case "queued":
+			return "⏳";
+		case "completed":
+			return "✓";
+		case "failed":
+		case "blocked":
+			return "✗";
+		case "cancelled":
+			return "⊘";
+		default:
+			return "•";
+	}
+}
+
+/**
+ * Suggest recent run IDs for run-scoped commands (/team-status, /team-cancel, …).
+ * Falls back to `process.cwd()` because Pi does not pass cwd into
+ * `getArgumentCompletions` — this is correct in the interactive TUI where the
+ * process cwd matches the session cwd.
+ */
+export function suggestRunIds(_prefix: string, cwd?: string): AutocompleteItem[] | null {
+	const resolvedCwd = cwd ?? process.cwd();
+	const runs = listRecentRuns(resolvedCwd, MAX_RUN_SUGGESTIONS);
+	if (runs.length === 0) return null;
+	const items: AutocompleteItem[] = runs.map((run) => ({
+		value: run.runId,
+		label: run.runId,
+		description: `${statusIcon(run.status)} ${run.status} · ${run.team} · ${(run.goal ?? "").slice(0, 48)}`,
+	}));
+	return filterByPrefix(items, _prefix);
+}
+
+/** Suggest task IDs within a specific run (for /team-result <runId> <taskId>). */
+export async function suggestTaskIds(runId: string, prefix: string, cwd?: string): Promise<AutocompleteItem[] | null> {
+	const resolvedCwd = cwd ?? process.cwd();
+	// Dynamic import to avoid pulling state-store into the hot command-registration path.
+	// LAZY: defer dynamic import of ../state/state-store.ts to its call site.
+	const { loadRunManifestById } = await import("../state/state-store.ts");
+	const loaded = loadRunManifestById(resolvedCwd, runId);
+	if (!loaded) return null;
+	const items: AutocompleteItem[] = loaded.tasks.map((task) => ({
+		value: task.id,
+		label: task.id,
+		description: `${task.status} · ${task.role} · ${task.title?.slice(0, 40) ?? ""}`,
+	}));
+	return filterByPrefix(items, prefix);
+}
+
+/** Suggest available teams for /team-run <team>. */
+export function suggestTeams(prefix: string, cwd?: string): AutocompleteItem[] | null {
+	const resolvedCwd = cwd ?? process.cwd();
+	const teams = allTeams(discoverTeams(resolvedCwd));
+	if (teams.length === 0) return null;
+	const items: AutocompleteItem[] = teams.map((team) => ({
+		value: team.name,
+		label: team.name,
+		description: team.defaultWorkflow ? `workflow=${team.defaultWorkflow}` : undefined,
+	}));
+	return filterByPrefix(items, prefix);
+}
+
+/** Suggest available workflows. */
+export function suggestWorkflows(prefix: string, cwd?: string): AutocompleteItem[] | null {
+	const resolvedCwd = cwd ?? process.cwd();
+	const workflows = allWorkflows(discoverWorkflows(resolvedCwd));
+	if (workflows.length === 0) return null;
+	const items: AutocompleteItem[] = workflows.map((wf) => ({
+		value: wf.name,
+		label: wf.name,
+		description: `${wf.steps?.length ?? 0} steps`,
+	}));
+	return filterByPrefix(items, prefix);
+}
+
+/** Suggest available agents. */
+export function suggestAgents(prefix: string, cwd?: string): AutocompleteItem[] | null {
+	const resolvedCwd = cwd ?? process.cwd();
+	const agents = allAgents(discoverAgents(resolvedCwd));
+	if (agents.length === 0) return null;
+	const items: AutocompleteItem[] = agents.map((agent) => ({
+		value: agent.name,
+		label: agent.name,
+		description: agent.description?.slice(0, 60),
+	}));
+	return filterByPrefix(items, prefix);
+}