pi-crew 0.11.6 → 0.11.8

package/src/runtime/task-output-context.ts

@@ -41,6 +41,12 @@ export interface DependencyContextEntry {
 	 *  the workflow (earlier deps = higher relevance because they were
 	 *  explicitly listed first). Defaults to 0.5 (neutral) when unknown. */
 	relevance?: number;
+	/** Handoff-budget marker: set by {@link applyHandoffBudget} when this
+	 *  entry was downgraded to the compact form (taskId/role/status + summary
+	 *  head ≤240 chars + artifact pointer). The render path emits the compact
+	 *  block for marked entries; `writeTaskInputsArtifact` still serializes the
+	 * ORIGINAL (untrimmed) context — the trim is render-only, never persisted. */
+	budgetTrimmed?: boolean;
 }
 
 export interface DependencyOutputContext {
@@ -58,6 +64,12 @@ export interface DependencyOutputContext {
 		content: string;
 		fullOutputPath?: string;
 	}>;
+	/** Run id (from the team manifest). Populated by
+	 *  `collectDependencyOutputContext` so the handoff-budget trim can build
+	 *  artifact pointers (`artifacts/<runId>/results/<taskId>.txt`). Optional
+	 *  for backward-compat with hand-built fixtures; without it trimmed deps
+	 *  simply omit the pointer line. */
+	runId?: string;
 }
 
 function containedExists(filePath: string, baseDir?: string): boolean {
@@ -523,7 +535,7 @@ export function collectDependencyOutputContext(
 	// outputs with compact digest notices before injecting into the worker
 	// prompt. OPT-IN: default config protects recent results.
 	const sharedReads = pruneSharedReads(rawSharedReads, trimmedDependencies, manifest.artifactsRoot);
-	return { dependencies: trimmedDependencies, sharedReads };
+	return { dependencies: trimmedDependencies, sharedReads, runId: manifest.runId };
 }
 
 // ADR-5 §trust-fence: dependency output is DATA, never instructions. Mirror the
@@ -536,46 +548,193 @@ function sanitizeFencedBody(body: string): string {
 	return body.replace(DEPENDENCY_CONTROL_CHAR_PATTERN, "").replace(/<\/dependency-context/g, "&lt;/dependency-context");
 }
 
-export function renderDependencyOutputContext(context: DependencyOutputContext): string {
+// ── Handoff budget (est-token cap on this layer) ─────────────────────────────
+
+/** Default est-token budget for the dynamic.dependencyContext layer. */
+export const DEFAULT_HANDOFF_BUDGET_TOKENS = 1800;
+/** Budget ceiling: a resolved budget above this is treated as the off-switch
+ *  (same semantics as ≤0 — clearly not a real handoff cap, so render
+ *  untrimmed instead of guessing). */
+export const HANDOFF_BUDGET_CEILING_TOKENS = 1_000_000;
+/** Summary head kept per dependency when the budget trims it. */
+export const HANDOFF_SUMMARY_HEAD_CHARS = 240;
+
+/** Strict integer env syntax — "12abc" must NOT parse as 12. */
+const HANDOFF_BUDGET_ENV_RE = /^[+-]?\d+$/;
+
+/** Est tokens = chars/4 — the same heuristic as `estimateTokens` in
+ *  src/runtime/task-runner/prompt-builder.ts (SR-02 breakdown). Duplicated
+ *  here instead of imported: importing prompt-builder would pull its
+ *  retrieval/workspace-tree graph into every task-output-context consumer
+ *  (post-execution, aggregate outputs) for a one-line heuristic. Keep the
+ *  two in sync if either changes. */
+function estimateHandoffTokens(chars: number): number {
+	return Math.round(chars / 4);
+}
+
+/** Budget active iff it is a positive finite number at or below the ceiling;
+ *  ≤0 or >ceiling = off-switch (render untrimmed). */
+function handoffBudgetActive(budgetTokens: number): boolean {
+	return Number.isFinite(budgetTokens) && budgetTokens > 0 && budgetTokens <= HANDOFF_BUDGET_CEILING_TOKENS;
+}
+
+/** Resolve the handoff budget: env PI_CREW_HANDOFF_BUDGET_TOKENS beats the
+ *  configured value, which beats the default (1800). A non-numeric/invalid
+ *  env string NEVER throws — it falls through to config/default. The resolved
+ *  number may still be ≤0 or >1_000_000 (off-switch at the render site). */
+export function resolveHandoffBudgetTokens(configured: number | undefined): number {
+	const raw = getCrewEnv("PI_CREW_HANDOFF_BUDGET_TOKENS");
+	if (raw !== undefined) {
+		const trimmed = raw.trim();
+		if (HANDOFF_BUDGET_ENV_RE.test(trimmed)) {
+			const parsed = Number.parseInt(trimmed, 10);
+			if (Number.isFinite(parsed)) return parsed;
+		}
+	}
+	return configured ?? DEFAULT_HANDOFF_BUDGET_TOKENS;
+}
+
+/** Full-form render lines for one dependency (pre-sanitize). */
+function dependencyEntryLines(dep: DependencyContextEntry): string[] {
+	const lines: string[] = [
+		`## ${dep.taskId} (${dep.role})`,
+		`Status: ${dep.status}`,
+		dep.resultPath ? `Result artifact: ${dep.resultPath}` : "",
+		"",
+		dep.resultSummary?.trim() || "(no result output)",
+		"",
+	];
+	// P1-A dependency tee-recovery hint: when the dependency's result was
+	// materially truncated (>1.25× MAX_RESULT_INLINE_BYTES) the full RAW
+	// content was teed to fullOutputPath. Mirrors the sharedReads hint so the
+	// downstream worker can read the dropped middle instead of re-deriving.
+	if (dep.fullOutputPath) lines.push(`Full output (if you need the missing middle): ${dep.fullOutputPath}`, "");
+	if (dep.structuredResults) lines.push("Structured results:", JSON.stringify(dep.structuredResults, null, 2), "");
+	if (dep.artifactsProduced?.length) lines.push(`Artifacts produced: ${dep.artifactsProduced.join(", ")}`, "");
+	if (dep.usage)
+		lines.push(`Usage: ${dep.usage.inputTokens} input tokens, ${dep.usage.outputTokens} output tokens, ${dep.usage.durationMs}ms`, "");
+	return lines;
+}
+
+/** Compact handoff-budget form for one dependency (pre-sanitize): keeps the
+ *  taskId/role/status lines + a ≤240-char summary head (with a truncation
+ *  marker when the summary was longer) + a relative artifact pointer the
+ *  worker can `read`. Drops structuredResults, usage, artifactsProduced and
+ *  the absolute-path lines — all recoverable via the pointer. The pointer is
+ *  built ONLY from manifest-derived runId/taskId (same trust level as the
+ *  existing `## <taskId>` headers and the results/<taskId>.txt artifact
+ *  naming); dep-controlled content never reaches it. */
+function budgetTrimmedDependencyEntryLines(dep: DependencyContextEntry, runId: string | undefined): string[] {
+	const summary = dep.resultSummary?.trim() ?? "";
+	const head = summary.slice(0, HANDOFF_SUMMARY_HEAD_CHARS);
+	const body =
+		summary.length > HANDOFF_SUMMARY_HEAD_CHARS ? `${head}\n[trimmed, ${summary.length} chars total]` : summary || "(no result output)";
+	return [
+		`## ${dep.taskId} (${dep.role})`,
+		`Status: ${dep.status}`,
+		body,
+		...(runId ? [`full output: artifacts/${runId}/results/${dep.taskId}.txt`] : []),
+		"",
+	];
+}
+
+/** Full-form render lines for one shared read (pre-sanitize). */
+function sharedReadLines(read: { name: string; path: string; content: string; fullOutputPath?: string }): string[] {
+	const lines = [`## shared/${read.name}`, `Path: ${read.path}`];
+	// P1-A tee-recovery hint: when the file was materially truncated
+	// (>2× threshold) the full content was teed to fullOutputPath so the
+	// worker can read the dropped middle if needed. The path is inside
+	// artifactsRoot/tee/ and goes through the normal permission gate.
+	if (read.fullOutputPath) lines.push(`Full output (if you need the missing middle): ${read.fullOutputPath}`);
+	lines.push("", read.content.trim(), "");
+	return lines;
+}
+
+/** Build the unsanitized body parts for a (possibly budget-trimmed) context.
+ *  Shared by the renderer (sanitize path) and the budget estimator so the
+ *  estimate can never drift from what is actually rendered. */
+function buildDependencyOutputBodyParts(context: DependencyOutputContext): string[] {
 	const parts: string[] = [];
 	if (context.dependencies.length) {
 		parts.push("# Dependency Outputs", "");
 		for (const dep of context.dependencies) {
-			parts.push(
-				`## ${dep.taskId} (${dep.role})`,
-				`Status: ${dep.status}`,
-				dep.resultPath ? `Result artifact: ${dep.resultPath}` : "",
-				"",
-				dep.resultSummary?.trim() || "(no result output)",
-				"",
-			);
-			// P1-A dependency tee-recovery hint: when the dependency's result was
-			// materially truncated (>1.25× MAX_RESULT_INLINE_BYTES) the full RAW
-			// content was teed to fullOutputPath. Mirrors the sharedReads hint so the
-			// downstream worker can read the dropped middle instead of re-deriving.
-			if (dep.fullOutputPath) parts.push(`Full output (if you need the missing middle): ${dep.fullOutputPath}`, "");
-			if (dep.structuredResults) parts.push("Structured results:", JSON.stringify(dep.structuredResults, null, 2), "");
-			if (dep.artifactsProduced?.length) parts.push(`Artifacts produced: ${dep.artifactsProduced.join(", ")}`, "");
-			if (dep.usage)
-				parts.push(
-					`Usage: ${dep.usage.inputTokens} input tokens, ${dep.usage.outputTokens} output tokens, ${dep.usage.durationMs}ms`,
-					"",
-				);
+			parts.push(...(dep.budgetTrimmed ? budgetTrimmedDependencyEntryLines(dep, context.runId) : dependencyEntryLines(dep)));
 		}
 	}
 	if (context.sharedReads.length) {
 		parts.push("# Shared Run Context Reads", "");
-		for (const read of context.sharedReads) {
-			parts.push(`## shared/${read.name}`, `Path: ${read.path}`);
-			// P1-A tee-recovery hint: when the file was materially truncated
-			// (>2× threshold) the full content was teed to fullOutputPath so the
-			// worker can read the dropped middle if needed. The path is inside
-			// artifactsRoot/tee/ and goes through the normal permission gate.
-			if (read.fullOutputPath) parts.push(`Full output (if you need the missing middle): ${read.fullOutputPath}`);
-			parts.push("", read.content.trim(), "");
-		}
+		for (const read of context.sharedReads) parts.push(...sharedReadLines(read));
 	}
-	return sanitizeFencedBody(parts.join("\n").trim());
+	return parts;
+}
+
+/** Measure a candidate context in est tokens (chars/4), mirroring the render
+ *  byte-for-byte (same parts builder; `.trim()` matches the render join). */
+function measureHandoffTokens(context: DependencyOutputContext): number {
+	return estimateHandoffTokens(buildDependencyOutputBodyParts(context).join("\n").trim().length);
+}
+
+/**
+ * Handoff budget: trim the dependency-output context to an est-token
+ * (chars/4) budget. PURE — no I/O, no env reads (callers pass the resolved
+ * budget from {@link resolveHandoffBudgetTokens}); returns the input
+ * reference unchanged when the budget is off (≤0 or >1_000_000) or the
+ * context already fits.
+ *
+ * Trim policy (declaration order): dependencies are probed from ALL-full
+ * downward — the largest prefix of dependencies that still fits keeps its
+ * FULL output; every dependency after the cutoff is downgraded to the
+ * compact form (taskId/role/status + ≤240-char summary head + truncation
+ * marker + `artifacts/<runId>/results/<taskId>.txt` pointer). Earlier deps
+ * therefore always keep ≥ as much as later ones. Long (>240 chars) sharedRead
+ * bodies are replaced by a trim marker (the Path pointer is already
+ * rendered); short shared reads pass through.
+ *
+ * When even the fully-trimmed form exceeds the budget (extreme dependency
+ * count), the fully-trimmed context is returned as the bounded best effort —
+ * every entry is then ≤ ~240 chars + pointer, so the layer stays small and
+ * deterministic.
+ *
+ * Composes AFTER the L4 byte trim (`enforceDependencyInlineBudget`, 96KB,
+ * priority-ordered path-only downgrade) which runs at collect time and is
+ * untouched by this function.
+ */
+export function applyHandoffBudget(context: DependencyOutputContext, budgetTokens: number, runId?: string): DependencyOutputContext {
+	if (!handoffBudgetActive(budgetTokens)) return context;
+	const effectiveRunId = runId ?? context.runId;
+	const base: DependencyOutputContext =
+		effectiveRunId !== undefined && context.runId !== effectiveRunId ? { ...context, runId: effectiveRunId } : context;
+	if (measureHandoffTokens(base) <= budgetTokens) return base;
+	const trimmedRead = (read: { name: string; path: string; content: string; fullOutputPath?: string }) => {
+		const content = read.content.trim();
+		return content.length > HANDOFF_SUMMARY_HEAD_CHARS
+			? { ...read, content: `[content trimmed, ${content.length} chars total — read Path above for the full file]` }
+			: read;
+	};
+	const candidateAt = (fullCount: number): DependencyOutputContext => ({
+		...base,
+		dependencies: base.dependencies.map((dep, index) => (index < fullCount ? dep : { ...dep, budgetTrimmed: true })),
+		sharedReads: base.sharedReads.map(trimmedRead),
+	});
+	for (let fullCount = base.dependencies.length; fullCount >= 0; fullCount--) {
+		const candidate = candidateAt(fullCount);
+		if (measureHandoffTokens(candidate) <= budgetTokens) return candidate;
+	}
+	return candidateAt(0);
+}
+
+export interface RenderDependencyOutputContextOptions {
+	/** Configured budget (runtime.handoffBudgetTokens). Env
+	 *  PI_CREW_HANDOFF_BUDGET_TOKENS beats this value; when neither is set the
+	 *  default is 1800. A resolved value ≤0 or >1_000_000 disables the trim
+	 *  (off-switch). */
+	budgetTokens?: number;
+}
+
+export function renderDependencyOutputContext(context: DependencyOutputContext, opts: RenderDependencyOutputContextOptions = {}): string {
+	const budgetTokens = resolveHandoffBudgetTokens(opts.budgetTokens);
+	const effective = applyHandoffBudget(context, budgetTokens);
+	return sanitizeFencedBody(buildDependencyOutputBodyParts(effective).join("\n").trim());
 }
 
 export function writeTaskSharedOutput(manifest: TeamRunManifest, step: WorkflowStep, task: TeamTaskState): ArtifactDescriptor | undefined {

package/src/runtime/task-packet.ts

@@ -203,6 +203,9 @@ export const HANDOFF_TEMPLATE = [
 	"",
 	"### Follow-ups",
 	"<!-- Any remaining issues or next steps -->",
+	"",
+	"### Provenance",
+	"<!-- Self-report your runtime identity (pre-set in your bash tool env, one line): PI_SESSION_ID, PI_SESSION_FILE, PI_MODEL, PI_PROVIDER, PI_REASONING_LEVEL — e.g. `session=<id> model=<provider>/<model> reasoning=<level>` -->",
 ].join("\n");
 
 export interface ParsedHandoff {

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

@@ -30,6 +30,7 @@ import * as path from "node:path";
 import { loadConfig } from "../../config/config.ts";
 import { getCrewEnv, getCrewEnvInt } from "../../config/env-vars.ts";
 import { errors } from "../../errors.ts";
+import type { MetricRegistry } from "../../observability/metric-registry.ts";
 import { appendEventAsync, appendEventBuffered } from "../../state/event-log/event-log.ts";
 import { writeArtifact } from "../../state/stores/artifact-store.ts";
 import { upsertOwnershipEntry } from "../../state/stores/ownership-map.ts";
@@ -38,6 +39,8 @@ import { type FatalFsCause, failureCauseForAttempt } from "../../utils/fs-errno.
 import { logInternalError } from "../../utils/internal-error.ts";
 import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
 import type { ChildPiLifecycleEvent, ChildPiRunResult } from "../child-pi/child-pi.ts";
+import type { SessionRecoveryInfo } from "../child-pi/session-recovery.ts";
+import { classifyBool, resolveClassifierEnabled, resolveClassifierModel } from "../classifier/classifier-service.ts";
 import {
 	appendCrewAgentEventBuffered,
 	appendCrewAgentOutputBuffered,
@@ -393,12 +396,113 @@ export function attemptErrorFor(
 	return err;
 }
 
+/** Outcome of the P2-1 retry-triage classifier consultation. */
+export interface RetryTriageResult {
+	/** false → skip the queued re-attempt (classifier judged the failure permanent). */
+	proceedWithRetry: boolean;
+	/** true ONLY when a real classifier answer informed the decision (event + decision metric emitted). */
+	consulted: boolean;
+}
+
+export interface RetryTriageArgs {
+	/** Pre-resolved gate (resolveClassifierEnabled) — false short-circuits before ANY registry touch. */
+	enabled: boolean;
+	/** Host-process model registry (ctx.modelRegistry, threaded unknown). */
+	modelRegistry: unknown;
+	/** Pre-resolved classifier model id (resolveClassifierModel). */
+	classifierModel: string;
+	/** Failure summary the attempt loop already computed (task error string). */
+	failureSummary: string;
+	/** Model the failed attempt used. */
+	failedModel: string;
+	/** Failed attempt's exit code (null = signal death). */
+	exitCode: number | null;
+	/** Event-log identity for the task.retry_triage diagnostic event. */
+	eventsPath: string;
+	runId: string;
+	taskId: string;
+	/** Optional host metric registry (crew.classifier.decisions_total). */
+	metricRegistry?: MetricRegistry;
+}
+
+/**
+ * P2-1 (pi 1.0.4 adoption) spike consumer: transient-vs-permanent triage for
+ * a queued model-fallback re-attempt, asked BEFORE burning the next full
+ * worker spawn. ONE bool question built from the failure summary; the answer
+ * is honored ONLY when `enabled` (runtime.classifierEnabled, default FALSE →
+ * dormant → zero behavior change: the helper returns without touching the
+ * registry). Fallback on every classifier failure mode is `proceedWithRetry:
+ * true` — the pre-existing retry behavior (classifyBool never-rejects).
+ *
+ * Emits `crew.classifier.decisions_total{consumer,decision}` + a
+ * `task.retry_triage` event ONLY when a real classifier answer informed the
+ * decision (fallback paths are already counted by the service's
+ * calls_total metric and must not double-report a decision they did not make).
+ */
+export async function triageRetryWithClassifier(args: RetryTriageArgs): Promise<RetryTriageResult> {
+	if (!args.enabled) return { proceedWithRetry: true, consulted: false };
+	const result = await classifyBool({
+		modelRegistry: args.modelRegistry,
+		classifierModel: args.classifierModel,
+		questionKey: "transient",
+		question: {
+			type: "bool",
+			instructions:
+				"A worker task failed and a retry on a different model is queued. Read the failure state. Is the failure TRANSIENT (a retry has a realistic chance of success, e.g. rate limit, provider hiccup, timeout, network error) rather than PERMANENT (a retry will fail the same way, e.g. auth/permission denied, invalid request, missing resource, deterministic error)?",
+			criteria: {
+				true: "Transient — the queued retry may succeed",
+				false: "Permanent — the queued retry will fail the same way",
+			},
+		},
+		state: {
+			// Cap the summary: classifiers reason over small JSON state — the raw
+			// error can carry multi-KB stderr tails.
+			failureSummary: args.failureSummary.slice(0, 2000),
+			failedModel: args.failedModel,
+			exitCode: args.exitCode,
+		},
+		fallback: true,
+		metricRegistry: args.metricRegistry,
+		metricLabels: { consumer: "retry_triage" },
+	});
+	if (!result.fromClassifier) return { proceedWithRetry: true, consulted: false };
+	const decision = result.decision ? "transient" : "permanent";
+	try {
+		args.metricRegistry?.counter("crew.classifier.decisions_total", "Classifier-informed decisions by consumer and verdict").inc({
+			consumer: "retry_triage",
+			decision: result.decision ? "transient_retry" : "permanent_skip",
+		});
+	} catch (metricError) {
+		logInternalError("child-executor.retry-triage.metric", metricError, `decision=${decision}`, "warn");
+	}
+	void appendEventAsync(args.eventsPath, {
+		type: "task.retry_triage",
+		runId: args.runId,
+		taskId: args.taskId,
+		message: `Retry triage classified the failure as ${decision} (classifier ${result.usedModel ?? args.classifierModel})`,
+		data: {
+			decision,
+			classifierModel: result.usedModel,
+			configuredModel: args.classifierModel,
+			failedModel: args.failedModel,
+			stopReason: result.stopReason,
+		},
+	}).catch(() => {
+		/* no-op: best-effort diagnostic append, ignore delivery errors */
+	});
+	return { proceedWithRetry: result.decision, consulted: true };
+}
+
 export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<TaskExecutionResult> {
 	const input = ctx.input;
 	const manifest: TeamRunManifest = ctx.manifest;
 	let task = ctx.task;
 	let tasks = ctx.tasks;
-	const prompt = ctx.prompt;
+	// R3-1: the child-pi worker's USER message is the dynamic suffix — the
+	// run-static header rides --append-system-prompt (compaction-safe).
+	// Fallback to the full prompt keeps hand-built contexts (tests, custom
+	// callers that skip pre-execution) on the old single-channel behavior.
+	const userPrompt = ctx.userPrompt ?? ctx.prompt;
 	const skillPaths = ctx.skillPaths;
 	const collectedJsonEvents = ctx.collectedJsonEvents;
 	const streamBridge: StreamBridgeHandle | undefined = ctx.streamBridge;
@@ -409,6 +513,9 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 	let modelAttempts: ModelAttemptSummary[] | undefined;
 	let parsedOutput: ParsedPiJsonOutput | undefined;
 	let rawFinalText: string | undefined;
+	// W2 (P1-1): last attempt's session-recovery provenance (thread-level,
+	// mirrors rawFinalText — escapes the attempt loop's block scope).
+	let recoveredFromSession: SessionRecoveryInfo | undefined;
 	let intermediateFindings: string | undefined;
 	let finalStdout = "";
 	let transcriptPath: string | undefined;
@@ -417,6 +524,12 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 
 	const modelFallbackPolicy = resolveTaskModelFallbackPolicy(task.cwd);
 	const defaultSubagentModel = resolveTaskDefaultSubagentModel(task.cwd);
+	// P2-1 (pi 1.0.4 adoption): retry-triage classifier gate — resolved once
+	// per task (env PI_CREW_CLASSIFIER_ENABLED beats runtime.classifierEnabled
+	// beats default FALSE — dormant). The disabled path never touches the
+	// registry, so default-off is a zero behavior change.
+	const classifierTriageEnabled = resolveClassifierEnabled(input.runtimeConfig?.classifierEnabled);
+	const classifierTriageModel = resolveClassifierModel(input.runtimeConfig?.classifierModel);
 	const modelRoutingPlan = buildConfiguredModelRouting({
 		overrideModel: input.modelOverride,
 		stepModel: input.step.model,
@@ -652,7 +765,15 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 		try {
 			childResult = await runWorker({
 				cwd: task.cwd,
-				task: prompt,
+				task: userPrompt,
+				systemPromptAppend: ctx.systemPromptAppend,
+				// R3-19/D5: thread the runtime.hermeticWorkers config gate to the
+				// worker argv (--no-extensions). Env PI_CREW_HERMETIC_WORKERS still
+				// overrides either way (resolveHermeticWorkers).
+				hermeticWorkers: input.runtimeConfig?.hermeticWorkers,
+				// DR2/D1: thread runtime.workerTransport to the run-worker seam (env
+				// PI_CREW_WORKER_TRANSPORT still wins — resolveWorkerTransport).
+				workerTransport: input.runtimeConfig?.workerTransport,
 				agent: input.agent,
 				model,
 				signal: timeoutController.signal,
@@ -665,6 +786,10 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 				parentContext: input.parentContext,
 				excludeContextBash: input.runtimeConfig?.excludeContextBash,
 				sessionId: manifest.sessionId,
+				// W2 (P1-1): thread the runtime.sessionRecovery flag so the config
+				// gate reaches the crash-path tail-replay (env/default still work
+				// without this — resolveSessionRecoveryEnabled precedence).
+				sessionRecovery: input.runtimeConfig?.sessionRecovery,
 				role: task.role,
 				thinkingOverride: input.teamRoleThinking,
 				runId: manifest.runId,
@@ -997,6 +1122,9 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 		const transcriptText = tailReadWithLineSnap(transcriptPath, MAX_TRANSCRIPT_PARSE_BYTES, childResult.stdout);
 		parsedOutput = parsePiJsonOutput(transcriptText);
 		rawFinalText = childResult.rawFinalText;
+		// W2 (P1-1): keep the most recent recovery info (crash-path only —
+		// undefined on clean exits, so this stays dormant in the happy path).
+		recoveredFromSession = childResult.recoveredFromSession ?? recoveredFromSession;
 		intermediateFindings = childResult.intermediateFindings;
 		error = attemptErrorFor(childResult, parsedOutput, task.id);
 		// bug-026 sub-issue B: classify fatal fs errnos (ENOSPC/EDQUOT/EMFILE/
@@ -1074,6 +1202,30 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 			}
 		}
 		if (!nextModel || !isRetryableModelFailure(error)) break;
+		// P2-1 spike: before burning the queued (expensive) re-attempt, ask the
+		// host classifier whether the failure looks transient. Dormant unless
+		// classifierTriageEnabled — the disabled path returns without touching
+		// the registry (zero behavior change), and every classifier failure
+		// mode falls back to proceeding with the retry (never-rejects contract).
+		const triage = await triageRetryWithClassifier({
+			enabled: classifierTriageEnabled,
+			modelRegistry: input.modelRegistry,
+			classifierModel: classifierTriageModel,
+			failureSummary: error,
+			failedModel: attempt.model,
+			exitCode,
+			eventsPath: manifest.eventsPath,
+			runId: manifest.runId,
+			taskId: task.id,
+			metricRegistry: input.metricRegistry,
+		});
+		if (!triage.proceedWithRetry) {
+			logs.push(
+				`CLASSIFIER TRIAGE: failure classified PERMANENT — skipping retry on ${nextModel} (classifier ${classifierTriageModel})`,
+				"",
+			);
+			break;
+		}
 		logs.push(formatModelAttemptNote(attempt, nextModel), "");
 	}
 	// E2 (Round 15): when the fallback chain was used and STILL failed, surface
@@ -1121,6 +1273,12 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 	const resultCandidates: ReadonlyArray<{ source: ResultSource; text: string | undefined }> = [
 		{ source: "rawFinalText", text: cleanResultText(rawFinalText) },
 		{ source: "finalText", text: cleanResultText(parsedOutput?.finalText) },
+		// W2 (P1-1): crash-path session tail-recovery. Ranks BELOW live captures
+		// (raw/finalText — the stream is authoritative when it survived) but
+		// ABOVE stdout/stderr noise: on signal death (exitCode null) the live
+		// captures are empty and this is the recovered last complete assistant
+		// message from the worker's session JSONL.
+		{ source: "session", text: cleanResultText(recoveredFromSession?.text) },
 		{ source: "stdout", text: cleanResultText(finalStdout) },
 		{ source: "stderr", text: cleanResultText(finalStderr) },
 		{ source: "findings", text: cleanResultText(intermediateFindings) },
@@ -1142,6 +1300,18 @@ export async function runChildProcessTask(ctx: TaskExecutionContext): Promise<Ta
 			"(no output)",
 		producer: task.id,
 	});
+	// W2 (P1-1): serialize the recovery provenance as a result sidecar — the
+	// recovered text itself flows through the "session" candidate above; this
+	// records WHERE it came from (session id/file, timestamp, stopReason) so
+	// crash-path recovery is auditable after the fact.
+	if (recoveredFromSession) {
+		writeArtifact(manifest.artifactsRoot, {
+			kind: "result",
+			relativePath: `results/${task.id}.session-recovery.json`,
+			content: JSON.stringify(recoveredFromSession, null, "\t"),
+			producer: task.id,
+		});
+	}
 	const logArtifact = writeArtifact(manifest.artifactsRoot, {
 		kind: "log",
 		relativePath: `logs/${task.id}.log`,

package/src/runtime/task-runner/post-execution.ts

@@ -86,16 +86,18 @@ export interface TaskExecutionResult {
 	terminalEvidence: OperationTerminalEvidence[];
 	startupEvidence: import("../heartbeat/worker-startup.ts").WorkerStartupEvidence;
 	/** Which child-executor fallback branch produced the result artifact
-	 *  content (rawFinalText → finalText → stdout → stderr → findings →
+	 *  content (rawFinalText → finalText → session → stdout → stderr → findings →
 	 *  "(no output)"). Finding #2 (2026-09-29 battery): "stderr"/"none" mean
 	 *  every authoritative worker output source was empty — finalizeTaskResult
 	 *  fails those DETERMINISTICALLY; the stderr-noise classifier stays a
-	 *  defense layer, never the verdict oracle. */
+	 *  defense layer, never the verdict oracle. "session" (W2/P1-1) = the text
+	 *  was tail-recovered from the worker's session JSONL on a signal-death
+	 *  crash path — authoritative recovered output, not a failure source. */
 	resultSource?: ResultSource;
 }
 
 /** Result-artifact provenance tags (see {@link TaskExecutionResult.resultSource}). */
-export type ResultSource = "rawFinalText" | "finalText" | "stdout" | "stderr" | "findings" | "none";
+export type ResultSource = "rawFinalText" | "finalText" | "session" | "stdout" | "stderr" | "findings" | "none";
 
 /** Final persisted task state returned by finalizeTaskResult. */
 export interface FinalTaskResult {

package/src/runtime/task-runner/pre-execution.ts

@@ -69,6 +69,17 @@ export interface TaskExecutionContext {
 	skillNames: string[] | undefined;
 	skillPaths: string[] | undefined;
 	prompt: string;
+	/** R3-1: the USER-message half of the rendered prompt (dynamicSuffix) —
+	 *  what the worker's task.md actually carries when the run-static header
+	 *  moves to the --append-system-prompt channel. `prompt` stays the FULL
+	 *  rendered prompt (stablePrefix + dynamicSuffix) for artifacts and the
+	 *  live-session path. Optional so hand-built contexts (tests, custom
+	 *  callers) keep the old single-channel behavior via the ?? fallback. */
+	userPrompt?: string;
+	/** R3-1: run-static worker header (stablePrefix) for the append-system-prompt
+	 *  channel — threaded to buildPiWorkerArgs via ChildPiRunInput. Undefined on
+	 *  hand-built contexts → single-channel legacy behavior. */
+	systemPromptAppend?: string;
 	promptArtifact: ArtifactDescriptor;
 	/** G18: prompt-breakdown artifact descriptor (undefined when PI_CREW_PROMPT_BREAKDOWN off). */
 	breakdownArtifact?: ArtifactDescriptor;
@@ -141,7 +152,14 @@ export async function prepareTaskExecutionContext(
 	// caller provided one) into the dep-context collection — cache hits reuse
 	// the closeout's reads byte-identically; undefined keeps uncached behavior.
 	const dependencyContext = collectDependencyOutputContext(manifest, input.tasks, input.task, input.step, input.resultReadCache);
-	const dependencyContextText = input.dependencyContextText ?? renderDependencyOutputContext(dependencyContext);
+	// Handoff budget: caps the dynamic.dependencyContext layer at an est-token
+	// (chars/4) budget (env PI_CREW_HANDOFF_BUDGET_TOKENS > runtime config >
+	// default 1800). IMPORTANT: only the RENDER path is budgeted — an explicit
+	// input.dependencyContextText override (leader-provided text) passes through
+	// UNCHANGED.
+	const dependencyContextText =
+		input.dependencyContextText ??
+		renderDependencyOutputContext(dependencyContext, { budgetTokens: input.runtimeConfig?.handoffBudgetTokens });
 	let task: TeamTaskState = {
 		...input.task,
 		cwd: workspace.cwd,
@@ -238,6 +256,14 @@ export async function prepareTaskExecutionContext(
 					step: input.step,
 					override: input.skillOverride,
 					runId: manifest.runId,
+					// R3-23: the child-process spawn path feeds every resolved skill to
+					// the worker via --skill (ctx.skillPaths → buildPiWorkerArgs), so the
+					// host advertises them in <available_skills> — drop the duplicated
+					// per-skill entries from the prompt block. Live-session/scaffold
+					// workers get no --skill channel and keep the full block. Externally
+					// supplied skillPaths may diverge from this render — stay safe and
+					// keep the full block for those callers.
+					advertisedByHost: runtimeKind === "child-process" && input.skillPaths === undefined,
 				})
 			: undefined;
 	const skillBlock = input.skillBlock ?? renderedSkills?.block;
@@ -435,6 +461,11 @@ export async function prepareTaskExecutionContext(
 			collectedJsonEvents,
 			streamBridge,
 			startupEvidence,
+			// R3-1: channel split for child-pi workers — user message = dynamic
+			// suffix; run-static header = system-prompt append channel (compaction
+			// summarizes the user-message span, compaction.md:150-160).
+			userPrompt: promptResult.dynamicSuffix,
+			systemPromptAppend: promptResult.stablePrefix,
 		},
 	};
 }

package/src/runtime/task-runner/prompt-builder.ts

@@ -275,11 +275,14 @@ export interface RenderedTaskPrompt {
 	/** Full rendered prompt (stablePrefix + dynamicSuffix). */
 	full: string;
 	/**
-	 * SR-02 phase 1 (2026-09-23): per-section char counts of the USER prompt,
+	 * SR-02 phase 1 (2026-09-23): per-section char counts of the worker prompt,
 	 * keyed by section name — the token-breakdown instrumentation. Populated
 	 * only when PI_CREW_PROMPT_BREAKDOWN=1 (off by default; zero cost when off:
 	 * the sections object is built lazily). Pre-execution adds the SYSTEM-side
 	 * pieces (agent definition, skills) and writes the JSON artifact.
+	 * R3-1 note: stable.* sections ride the --append-system-prompt channel;
+	 * total.userPrompt counts the user message (dynamic suffix) only, while
+	 * total.systemAppend counts the system-channel header.
 	 */
 	sections?: Record<string, number>;
 }
@@ -424,6 +427,8 @@ export async function renderTaskPrompt(
 	const full = [stablePrefix, "", dynamicSuffix].join("\n");
 	const sections: Record<string, number> | undefined = promptBreakdownEnabled()
 		? {
+				// R3-1: the stable.* sections now ride the --append-system-prompt
+				// channel; the worker's user message is the dynamic suffix only.
 				"stable.runtimeHeader": headerBlock.length,
 				"stable.protocol": protocolBlock.length,
 				"stable.roleInstructions": roleInstructions.length,
@@ -440,7 +445,10 @@ export async function renderTaskPrompt(
 				"dynamic.memory": memoryBlock.length,
 				"dynamic.outputSchema": outputSchemaBlock.length,
 				"dynamic.taskAndHandoff": taskAndHandoff.length,
-				"total.userPrompt": full.length,
+				// R3-1: channel split — the user message carries ONLY the dynamic
+				// suffix; the stable prefix went to the system-prompt append channel.
+				"total.systemAppend": stablePrefix.length,
+				"total.userPrompt": dynamicSuffix.length,
 			}
 		: undefined;
 	return { stablePrefix, dynamicSuffix, full, sections };

package/src/runtime/task-runner.ts

@@ -1,5 +1,6 @@
 import type { AgentConfig } from "../agents/agent-config.ts";
 import type { CrewLimitsConfig, CrewRuntimeConfig } from "../config/config.ts";
+import type { MetricRegistry } from "../observability/metric-registry.ts";
 import { writeArtifact } from "../state/stores/artifact-store.ts";
 import type { ArtifactDescriptor, OperationTerminalEvidence, TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import type { WorkflowStep } from "../workflows/workflow-config.ts";
@@ -51,6 +52,11 @@ export interface TaskRunnerInput {
 	parentContext?: string;
 	parentModel?: unknown;
 	modelRegistry?: unknown;
+	/** P2-1 (pi 1.0.4 adoption): host-process metric registry threaded from
+	 *  ExecuteTeamRunInput so the retry-triage classifier seam can count its
+	 *  calls/decisions (crew.classifier.* counters). Optional — undefined keeps
+	 *  the uncounted behavior (e.g. tests, hand-built contexts). */
+	metricRegistry?: MetricRegistry;
 	modelOverride?: string;
 	teamRoleModel?: string;
 	teamRoleFallbackModels?: string[];