pi-crew 0.9.51 → 0.9.52

package/src/extension/async-notifier.ts

@@ -1,179 +0,0 @@
-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

@@ -1,209 +0,0 @@
-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

@@ -1,120 +0,0 @@
-/**
- * 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);
-}