pi-crew 0.11.1 → 0.11.4

package/src/extension/team-tool/parallel-dispatch.ts

@@ -10,6 +10,7 @@ import { discoverAgents } from "../../agents/discover-agents.ts";
 import { loadConfig } from "../../config/config.ts";
 import { spawnBackgroundTeamRun } from "../../runtime/async-runner.ts";
 import { resolveCrewRuntime } from "../../runtime/model/runtime-resolver.ts";
+import { captureRunModelContext } from "../../runtime/model/session-model.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { appendEventAsync } from "../../state/event-log/event-log.ts";
 import { createRunManifest } from "../../state/stores/state-store.ts";
@@ -66,13 +67,23 @@ export async function handleParallel(params: TeamToolParamsValue, ctx: TeamConte
 
 	const runtime = await resolveCrewRuntime(config.config);
 
+	// Finding #1 (full battery 2026-09-29): parallel-dispatched runs re-enter
+	// through the detached background-runner, which has no ExtensionContext.
+	// Without a persisted modelContext, restoredModelRouting() returns {} and
+	// every worker silently falls back to the DEFAULT chain (live: 3 runs died
+	// on minimax/MiniMax-M3 402 while the parent session ran zai/glm-5.3).
+	// Captured ONCE here (in the parent session's process) so resolveParentModel()
+	// sees the live session model; undefined when nothing is worth persisting
+	// (older manifests stay byte-identical).
+	const modelContext = captureRunModelContext(ctx, typeof params.model === "string" ? params.model : undefined);
+
 	const launched: Array<{ runId: string; goal: string; agent: string }> = [];
 	const errors: Array<{ goal: string; error: string }> = [];
 
 	// C1: Enforce concurrency limit with batched spawning
 	for (let batchStart = 0; batchStart < tasksParam.length; batchStart += concurrency) {
 		const batch = tasksParam.slice(batchStart, batchStart + concurrency);
-		const batchPromises = batch.map((task) => spawnSingleTask(task, ctx, allAgentsList, team, workflow, runtime));
+		const batchPromises = batch.map((task) => spawnSingleTask(task, ctx, allAgentsList, team, workflow, runtime, modelContext));
 		const batchResults = await Promise.allSettled(batchPromises);
 		for (const res of batchResults) {
 			if (res.status === "fulfilled" && res.value.ok) {
@@ -121,6 +132,7 @@ async function spawnSingleTask(
 	team: TeamConfig,
 	workflow: WorkflowConfig,
 	runtime: { available: boolean; kind: string },
+	modelContext: ReturnType<typeof captureRunModelContext>,
 ): Promise<SpawnResult> {
 	try {
 		const taskRec = task as Record<string, unknown>;
@@ -163,6 +175,9 @@ async function spawnSingleTask(
 			// skipped and any session can cancel/retry parallel-dispatched runs.
 			ownerSessionId: ctx.sessionId,
 			runKind: "team-run",
+			// Finding #1: persist the parent session's model routing so the detached
+			// runner restores it instead of default-chaining (see handleParallel).
+			modelContext,
 		});
 
 		await appendEventAsync(created.manifest.eventsPath, {

package/src/extension/team-tool/plan.ts

@@ -5,6 +5,7 @@ import { allWorkflows, discoverWorkflows } from "../../workflows/discover-workfl
 import { validateWorkflowForTeam } from "../../workflows/validate-workflow.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { result, type TeamContext } from "./context.ts";
+import { resolveRoutingHint } from "./routing-hint.ts";
 
 export function handlePlan(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
 	const teamName = params.team ?? "default";
@@ -21,6 +22,12 @@ export function handlePlan(params: TeamToolParamsValue, ctx: TeamContext): PiTea
 			true,
 		);
 	const goal = params.goal ?? params.task ?? "(not provided)";
+	// DP-04: small-goal routing hint (suggest-only by default; never overrides
+	// an explicit team/workflow choice). See routing-hint.ts for the rationale.
+	const routingHint = resolveRoutingHint({
+		goal,
+		explicitOverride: params.team !== undefined || params.workflow !== undefined,
+	});
 	// ROADMAP T2.2: single-agent composition mode (cliff hedge).
 	if (params.singleAgent) {
 		const composed = composeSingleAgentPrompt(workflow, goal);
@@ -46,5 +53,8 @@ export function handlePlan(params: TeamToolParamsValue, ctx: TeamContext): PiTea
 				`${index + 1}. ${step.id} [${step.role}]${step.dependsOn?.length ? ` after ${step.dependsOn.join(", ")}` : ""}`,
 		),
 	];
+	if (routingHint.suggested && routingHint.message) {
+		lines.push("", routingHint.message);
+	}
 	return result(lines.join("\n"), { action: "plan", status: "ok" });
 }

package/src/extension/team-tool/routing-hint.ts

@@ -0,0 +1,63 @@
+/**
+ * DP-04 (2026-09-22): small-goal routing hint.
+ *
+ * Measured: a trivial goal through the default team burns 7.6–9k tokens just on
+ * the 3 context-setup steps (assess → execute → verify). The engine ALREADY
+ * supports `singleAgent: true` (handlePlan → composeSingleAgentPrompt); nothing
+ * suggested it for small goals.
+ *
+ * This module decides the hint. It is deliberately PURE and explainable — no
+ * ML, no hidden state — so the routing decision can be asserted in tests and
+ * audited from the plan output. Default mode is "suggest" (visible nudge, the
+ * caller/agent still decides), NOT a silent switch: this project has been
+ * burned by silent routing changes before (the auto-boomerang aliasing trap),
+ * so the decision must be visible.
+ */
+
+export type SmallGoalRoutingMode = "off" | "suggest" | "auto";
+
+/** Goals at or below this many whitespace tokens are considered "small". */
+export const SMALL_GOAL_TOKEN_THRESHOLD = 40;
+
+export interface RoutingHintInput {
+	goal: string;
+	/** True when the caller supplied an explicit team and/or workflow override. */
+	explicitOverride: boolean;
+	/** Configured mode; defaults to "suggest". */
+	mode?: SmallGoalRoutingMode;
+}
+
+export interface RoutingHint {
+	/** Whether a cheaper single-agent composition is advised. */
+	suggested: boolean;
+	/** Machine-readable reason (empty when not suggested). */
+	reason?: string;
+	/** Human-readable, shown in the plan output. */
+	message?: string;
+	/** Rough token saving estimate for the plan text (informational). */
+	estimatedSavings?: string;
+}
+
+/** Cheap, deterministic token count (whitespace split) — no tokenizer dep. */
+export function goalTokenCount(goal: string): number {
+	const trimmed = goal.trim();
+	if (trimmed.length === 0) return 0;
+	return trimmed.split(/\s+/).length;
+}
+
+export function resolveRoutingHint(input: RoutingHintInput): RoutingHint {
+	const mode = input.mode ?? "suggest";
+	if (mode === "off") return { suggested: false };
+	// Never second-guess an explicit team/workflow choice.
+	if (input.explicitOverride) return { suggested: false };
+	const tokens = goalTokenCount(input.goal);
+	if (tokens === 0 || tokens > SMALL_GOAL_TOKEN_THRESHOLD) return { suggested: false };
+	return {
+		suggested: true,
+		reason: `goal is small (${tokens} tokens ≤ ${SMALL_GOAL_TOKEN_THRESHOLD})`,
+		message:
+			`Hint: this goal is small (${tokens} tokens). The default team runs 3 context-setup phases ` +
+			`(~8k tokens overhead) before real work — consider \`singleAgent: true\` (or a 2-step chain) to skip them.`,
+		estimatedSavings: "~5-6k tokens",
+	};
+}

package/src/extension/team-tool/run-intent.ts

@@ -73,7 +73,7 @@ const MAX_ANALYSIS_BYTES = 100_000;
 var crewInitPromise: Promise<typeof import("../../state/crew-init.ts")> | undefined;
 function loadCrewInit(): Promise<typeof import("../../state/crew-init.ts")> {
 	if (!crewInitPromise) {
-		crewInitPromise = import("../../state/crew-init.ts");
+		crewInitPromise = import("../../state/crew-init.ts"); // LAZY: defer crew-init until first run intent
 	}
 	return crewInitPromise;
 }

package/src/extension/team-tool/run.ts

@@ -61,7 +61,7 @@ import type { RuntimeResolutionState, TeamRunManifest, TeamTaskState } from "../
 var crewInitPromise: Promise<typeof import("../../state/crew-init.ts")> | undefined;
 function loadCrewInit(): Promise<typeof import("../../state/crew-init.ts")> {
 	if (!crewInitPromise) {
-		crewInitPromise = import("../../state/crew-init.ts");
+		crewInitPromise = import("../../state/crew-init.ts"); // LAZY: defer crew-init until first run intent
 	}
 	return crewInitPromise;
 }

package/src/extension/team-tool/status.ts

@@ -2,6 +2,7 @@ import { loadConfig } from "../../config/config.ts";
 import { applyAttentionState, formatActivityAge, resolveCrewControlConfig } from "../../runtime/agent-control.ts";
 import { extractCommandTrace } from "../../runtime/command-trace.ts";
 import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
+import { deadletterStatusLine } from "../../runtime/deadletter.ts";
 import { evaluateRunEffectiveness } from "../../runtime/effectiveness.ts";
 import { computePhaseProgress } from "../../runtime/phase-progress.ts";
 import { checkProcessLiveness, isActiveRunStatus } from "../../runtime/process-status.ts";
@@ -150,6 +151,7 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 	}
 	const counts = new Map<string, number>();
 	for (const task of tasks) counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
+	const deadletterLine = deadletterStatusLine(manifest);
 	const phaseProgress = computePhaseProgress(tasks);
 	// PERF (2026-08-24): intentionally NOT passing `limit` here — readEventsCursor's
 	// limit is a HEAD cap (oldest-first slice for streaming pagination), not a tail
@@ -267,6 +269,8 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 				)
 			: ["- (none)"]),
 		`Task counts: ${[...counts.entries()].map(([status, count]) => `${status}=${count}`).join(", ") || "none"}`,
+		// US-003 AC-3: surface exhausted-retry failures — only when entries exist.
+		...(deadletterLine ? [deadletterLine] : []),
 		"Effectiveness:",
 		`- observable=${effectiveness.observable}/${Math.max(1, effectiveness.completed)} completed tasks`,
 		`- workerExecution=${effectiveness.workerExecution} guard=${effectiveness.guardMode} severity=${effectiveness.severity}`,

package/src/extension/team-tool.ts

@@ -3,6 +3,7 @@ import * as path from "node:path";
 import type { AgentConfig } from "../agents/agent-config.ts";
 import { allAgents, discoverAgents, listDynamicAgents, registerDynamicAgent, unregisterDynamicAgent } from "../agents/discover-agents.ts";
 import { loadConfig } from "../config/config.ts";
+import { DEFAULT_PATHS } from "../config/defaults.ts";
 import { getCrewEnv } from "../config/env-vars.ts";
 // Heavy runtime — lazy-loaded to avoid 1.4s import cost at extension registration.
 // executeTeamRun is only called when a team run actually executes.
@@ -17,6 +18,7 @@ import { loadRunManifestById, saveRunManifestAsync, saveRunTasks, updateRunStatu
 import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
 import { logInternalError } from "../utils/internal-error.ts";
+import { findRepoRoot, projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
 import { resolveRealContainedPath } from "../utils/safe-paths.ts";
 import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
 import { listRecentRuns } from "./run-index.ts";
@@ -191,9 +193,9 @@ function artifactKey(artifact: ArtifactDescriptor): string {
  *  passes) but handlers expect real numbers (TeamToolParamsValue types them as
  *  number). This converts the string form back to a number — and treats "" as
  *  unset (deleted) — before any domain router reads the param. */
-const LOOSE_NUMERIC_PARAM_KEYS = ["interval", "budgetWarning", "budgetAbort", "tokenBudget", "replyDeadline"] as const;
+const LOOSE_NUMERIC_PARAM_KEYS = ["interval", "budgetWarning", "budgetAbort", "tokenBudget", "replyDeadline", "budgetTotal"] as const;
 
-function normalizeLooseNumericFields(params: TeamToolParamsValue): TeamToolParamsValue {
+export function normalizeLooseNumericFields(params: TeamToolParamsValue): TeamToolParamsValue {
 	let mutated = false;
 	const out: Record<string, unknown> = { ...params };
 	for (const key of LOOSE_NUMERIC_PARAM_KEYS) {
@@ -400,7 +402,10 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 			data: { runtimeResolution, action: "resume" },
 		});
 		if (runtime.safety === "blocked") {
-			const runningManifest = updateRunStatus(runtimeManifest, "running", "Checking worker runtime availability before resume.");
+			const runningManifest = updateRunStatus(runtimeManifest, "running", "Checking worker runtime availability before resume.", {
+				// Resume is the ONE legitimate terminal-exit flow (finding 8 write guard).
+				allowTerminalExit: true,
+			});
 			const blocked = updateRunStatus(
 				runningManifest,
 				"blocked",
@@ -511,6 +516,8 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 		reliability: decision.executedConfig.reliability,
 		metricRegistry: ctx.metricRegistry,
 		workspaceId: ctx.sessionId ?? ctx.cwd,
+		// Finding 8: resume is the legitimate terminal-exit flow.
+		isResume: true,
 	});
 	return result(
 		[
@@ -652,9 +659,48 @@ export function locateRunCwd(runId: string, baseCwd: string): string | undefined
  * - Skips hidden entries (starting with `.`) unless they look like run directories
  *   (e.g. .crew, .pi, .tmp-crew-runs)
  */
+/**
+ * F-L1 companion (2026-09-23 correction): a hit counts when the resolved
+ * stateRoot sits under EITHER root that `list` unions (run-index
+ * `scopedRunRoots` = userCrewRoot + projectCrewRoot), because this function
+ * answers "which cwd can read this run's state" — not "was it created here".
+ *
+ * History: the first F-L1 fix (5d3a3d0f) restricted hits to the candidate
+ * cwd's PRIMARY root. That kept `locateRunCwd` from claiming a run created in
+ * a sibling, but it also made every by-ID handler (status/events/summary/
+ * artifacts/worktrees/api/plans/respond/cancel) reject runs that `list` shows
+ * from the user root: `list` unions both roots, `loadRunManifestById` resolves
+ * both roots, yet `locateRunCwd` returned undefined → "Run not found" for
+ * runs the dashboard had just listed. Measured live: 10/10 user-root runs
+ * listed by `action='list'` failed `action='status'`.
+ *
+ * Sibling isolation is preserved WITHOUT the primary-only restriction: a run
+ * living under a sibling's PROJECT root (…/sibling/.crew/state/runs/<id>) is
+ * not under the candidate cwd's project root nor the user root, so it still
+ * does not match (pinned by locate-run-cwd.test.ts "sibling directory").
+ */
+function runUnderListedRoot(cwd: string, runId: string): boolean {
+	const loaded = loadRunManifestById(cwd, runId);
+	if (!loaded) return false;
+	const roots = findRepoRoot(cwd) ? [projectCrewRoot(cwd), userCrewRoot()] : [userCrewRoot()];
+	return roots.some((root) => loaded.manifest.stateRoot === path.join(root, DEFAULT_PATHS.state.runsSubdir, runId));
+}
+
+/**
+ * Scan-path variant: a CHILD directory may claim the run only when the run's
+ * state actually lives under that child's OWN crew root (the nested-child
+ * case this scan exists for). Without this, a shared user-root run would be
+ * "claimed" by whichever child happened to be scanned first.
+ */
+function runUnderOwnRoot(cwd: string, runId: string): boolean {
+	const loaded = loadRunManifestById(cwd, runId);
+	if (!loaded) return false;
+	return loaded.manifest.stateRoot === path.join(projectCrewRoot(cwd), DEFAULT_PATHS.state.runsSubdir, runId);
+}
+
 export function locateRunCwdUncached(runId: string, baseCwd: string): string | undefined {
-	// Fast path: run is in the current CWD
-	if (loadRunManifestById(baseCwd, runId)) {
+	// Fast path: run resolves under one of the roots `list` shows (see helper note).
+	if (runUnderListedRoot(baseCwd, runId)) {
 		return baseCwd;
 	}
 
@@ -670,7 +716,7 @@ export function locateRunCwdUncached(runId: string, baseCwd: string): string | u
 				if (!entry.name.startsWith(".crew") && !entry.name.startsWith(".pi") && !entry.name.startsWith(".tmp-crew")) continue;
 			}
 			const candidate = path.join(baseCwd, entry.name);
-			if (loadRunManifestById(candidate, runId)) {
+			if (runUnderOwnRoot(candidate, runId)) {
 				return candidate;
 			}
 		}