pi-crew 0.9.9 → 0.9.11

package/src/runtime/compact-stages/tail-capture-stage.ts

@@ -0,0 +1,72 @@
+/**
+ * TailCaptureStage — keep the last N characters/bytes of the input, prepend
+ * an optional marker when truncation fires.
+ *
+ * Distinct from TruncationStage (head + important-middle + tail, P0-B / P0-A):
+ * this stage is pure tail-capture, used by streaming accumulators that need to
+ * keep the most recent N chars/bytes and drop the oldest. No important-line
+ * preservation, no head — just the tail + optional marker.
+ *
+ * Use cases in pi-crew:
+ *   - `appendBoundedTail` (child-pi.ts) — stdout/stderr streaming accumulator
+ *     with byte cap and a `[pi-crew captured output truncated to last X KiB]`
+ *     marker.
+ *   - `stream-preview.ts` textBuffer — incremental text buffer for the live UI
+ *     preview, char cap, NO marker (the UI shows raw text without a prefix).
+ *
+ * Two cap modes:
+ *   - `maxChars`: character-based cap (UTF-8 safe by definition).
+ *   - `maxBytes`: byte-based cap (legacy, used when memory budget matters
+ *     more than UTF-8 safety). The tail is snapped to the last byte that
+ *     keeps the result ≤ maxBytes to avoid splitting a multi-byte sequence.
+ */
+import type { ICompactStage } from "../compact-pipeline.ts";
+
+export interface TailCaptureStageConfig {
+	/** Character cap (UTF-8 safe). Mutually exclusive with maxBytes. */
+	maxChars?: number;
+	/** Byte cap (legacy, used by streaming accumulators). Mutually exclusive with maxChars. */
+	maxBytes?: number;
+	/** Marker prepended (with a newline separator) when truncation fires. Empty string = no marker. */
+	marker?: string;
+	/** Optional explicit id; defaults to "tail-capture" (or "tail-capture-stream" if maxBytes mode). */
+	id?: string;
+}
+
+export class TailCaptureStage implements ICompactStage {
+	readonly id: string;
+	private readonly maxChars: number | undefined;
+	private readonly maxBytes: number | undefined;
+	private readonly marker: string;
+	constructor(config: TailCaptureStageConfig) {
+		const hasChars = typeof config.maxChars === "number";
+		const hasBytes = typeof config.maxBytes === "number";
+		if (hasChars === hasBytes) {
+			throw new Error(`TailCaptureStage requires exactly one of maxChars or maxBytes (got chars=${config.maxChars} bytes=${config.maxBytes})`);
+		}
+		if (hasChars && (config.maxChars as number) <= 0) throw new Error(`TailCaptureStage: maxChars must be > 0, got ${config.maxChars}`);
+		if (hasBytes && (config.maxBytes as number) <= 0) throw new Error(`TailCaptureStage: maxBytes must be > 0, got ${config.maxBytes}`);
+		this.maxChars = config.maxChars;
+		this.maxBytes = config.maxBytes;
+		this.marker = config.marker ?? "";
+		this.id = config.id ?? (hasBytes ? "tail-capture" : "tail-capture");
+	}
+	apply(text: string): string {
+		if (this.maxBytes !== undefined) {
+			// Byte cap mode — snap tail to a UTF-8 char boundary so the result
+			// never contains a partial multi-byte sequence.
+			if (Buffer.byteLength(text, "utf-8") <= this.maxBytes) return text;
+			let tail = text.slice(Math.max(0, text.length - this.maxBytes));
+			while (Buffer.byteLength(tail, "utf-8") > this.maxBytes) tail = tail.slice(1024);
+			return this.marker ? `${this.marker}\n${tail}` : tail;
+		}
+		// Char cap mode.
+		const max = this.maxChars as number;
+		if (text.length <= max) return text;
+		const tail = text.slice(text.length - max);
+		return this.marker ? `${this.marker}\n${tail}` : tail;
+	}
+}
+
+/** Singleton: char-cap tail capture with no marker (for `stream-preview.ts` textBuffer). */
+export const TAIL_CAPTURE_STREAM_STAGE = new TailCaptureStage({ maxChars: 16_384, id: "tail-capture-stream" });

package/src/runtime/compact-stages/truncation-stage.ts

@@ -0,0 +1,71 @@
+/**
+ * TruncationStage — head(75%) + important-middle + tail(25%) compression.
+ *
+ * Wraps the head/tail/important-line split (from P0-B's `important-line-classifier.ts`)
+ * as a pipeline stage so it composes with other stages (ANSI strip, blank
+ * collapse, etc.). When the input is at or below `maxChars`, returns the
+ * input unchanged (idempotent — the pipeline gate then marks this stage as
+ * a no-op).
+ *
+ * Marker wording is parameterized so the SAME stage serves both `compactString`
+ * ("compacted ... chars") and `readIfSmall` ("truncated ... chars") with
+ * their distinct separators. Defaults match `compactString`'s pre-P0-A output
+ * exactly so that callers that do not opt into additional stages get
+ * bit-identical output (L4 backward-compat safety).
+ */
+import type { ICompactStage } from "../compact-pipeline.ts";
+import { splitWithImportantLines } from "../important-line-classifier.ts";
+
+export interface TruncationMarkerConfig {
+	/** "compacted" (compactString default) or "truncated" (readIfSmall default). */
+	verb: "compacted" | "truncated";
+	/** Unit reported in the marker. Both callers currently use "chars" post-Sprint 1. */
+	unit: "chars" | "bytes";
+	/** Newline(s) between `head` and the marker line. compactString uses "\n"; readIfSmall uses "\n\n". */
+	headSeparator: string;
+	/** Newline(s) between the marker (or joined important lines) and `tail`. Both callers use "\n". */
+	tailSeparator: string;
+}
+
+const DEFAULT_MARKER: TruncationMarkerConfig = {
+	verb: "compacted",
+	unit: "chars",
+	headSeparator: "\n",
+	tailSeparator: "\n",
+};
+
+export class TruncationStage implements ICompactStage {
+	readonly id = "truncation";
+	private readonly maxChars: number;
+	private readonly preserveImportant: boolean;
+	private readonly marker: TruncationMarkerConfig;
+	constructor(
+		maxChars: number,
+		opts: { preserveImportant?: boolean; marker?: Partial<TruncationMarkerConfig> } = {},
+	) {
+		if (!Number.isFinite(maxChars) || maxChars <= 0) {
+			throw new Error(`TruncationStage: maxChars must be a positive finite number, got ${maxChars}`);
+		}
+		this.maxChars = maxChars;
+		this.preserveImportant = opts.preserveImportant !== false;
+		this.marker = { ...DEFAULT_MARKER, ...(opts.marker ?? {}) };
+	}
+	apply(text: string): string {
+		if (text.length <= this.maxChars) return text;
+		const { head, tail, importantLines, baseDropped } = splitWithImportantLines(text, this.maxChars, {
+			preserveImportant: this.preserveImportant,
+		});
+		let result: string;
+		if (importantLines.length === 0) {
+			result = `${head}${this.marker.headSeparator}...[pi-crew ${this.marker.verb} ${baseDropped} ${this.marker.unit}, head+tail preserved]...${this.marker.tailSeparator}${tail}`;
+		} else {
+			const joined = importantLines.join("\n");
+			const remaining = text.length - head.length - tail.length - joined.length;
+			result = `${head}${this.marker.headSeparator}...[pi-crew ${this.marker.verb} ${baseDropped} ${this.marker.unit}, head+tail + ${importantLines.length} important lines preserved, ${remaining} ${this.marker.unit} remaining dropped]...\n${joined}${this.marker.tailSeparator}${tail}`;
+		}
+		// Defense-in-depth: this stage's own monotonic-shrink invariant. The
+		// pipeline gate is a SECOND line of defense.
+		if (result.length >= text.length) return text;
+		return result;
+	}
+}

package/src/runtime/handoff-manager.ts

@@ -202,6 +202,16 @@ export class HandoffManager {
 		this.cleanupTimer = setInterval(() => {
 			this.cleanupStaleHandoffs();
 		}, this.options.cleanupIntervalMs);
+		// FIX (BG2 hang): without .unref(), the cleanup interval keeps the Node
+		// event loop alive forever — tests that create HandoffManager without
+		// calling dispose() (e.g. chain-runner.test.ts mock helper that does
+		// `return new HandoffManager()`) leak an interval per test, and the
+		// file-level test never completes because Node waits for all handles
+		// to close. .unref() lets the process exit when nothing else is pending
+		// — this is the standard Node.js pattern for background timers.
+		if (typeof this.cleanupTimer.unref === "function") {
+			this.cleanupTimer.unref();
+		}
 	}
 
 	/**

package/src/runtime/important-line-classifier.ts

@@ -0,0 +1,130 @@
+/**
+ * Important-Line Classifier (P0-B) — scan middle slice of a truncated value
+ * for diagnostic lines worth preserving between head and tail.
+ *
+ * Ported from Hypa's `ImportantLineClassifier.cs` (5 regexes) and the
+ * middle-scanning portion of `Stages/TruncationStage.cs:24-46`, adapted to TS
+ * (no `[GeneratedRegex]` AOT) and to pi-crew's head(75%)/tail(25%) split.
+ *
+ * Design rationale:
+ * - Patterns are intentionally OVER-INCLUSIVE. False positives preserve
+ *   harmless lines; false negatives drop critical diagnostics, which is
+ *   unacceptable (the whole point of this module). Hypa uses the same
+ *   over-inclusive design.
+ * - Patterns are evaluated against a WHOLE line, not against the raw
+ *   truncated slice, so a match at a line boundary is reliable.
+ * - The `splitWithImportantLines` helper performs the head/tail split AND
+ *   greedily picks whole important lines from the middle that fit inside
+ *   `slackFactor * maxChars` (default 15% slack). Callers compose their own
+ *   marker using the returned parts — keeping `compactString` (marker
+ *   "compacted ... chars, head+tail preserved") and `readIfSmall` (marker
+ *   "truncated ... bytes, head+tail preserved") backward-compatible when no
+ *   important lines are present.
+ */
+
+/** Diagnostic patterns. Anchored where safe to avoid matching noise. */
+export const IMPORTANT_LINE_PATTERNS: readonly RegExp[] = [
+	// error keywords — NOTE: "warning" is intentionally excluded here; it has
+	// its own case-sensitive pattern below so that the common prose word
+	// "warning" does not over-match. (Hypa does the same split.)
+	/\b(error|failed|exception|fatal|panic)\b/i,
+	// file:line diagnostic — `child-pi.ts:383:`, `App.tsx:42:`
+	/\w+\.\w+:\d+:/,
+	// HTTP 4xx / 5xx — bounded so it does not match phone numbers etc.
+	/\b[45]\d{2}\b/,
+	// k8s / linter "Warning" event (case-sensitive so prose is not matched)
+	/\bWarning\b/,
+	// compiler / linter diagnostic id — `TS2304`, `CS0246`, `ES1234`
+	/\b[A-Z]{2,4}\d{3,5}\b/,
+];
+
+/** True iff `line` matches at least one important-line pattern. */
+export function isImportantLine(line: string): boolean {
+	if (!line) return false;
+	for (const pattern of IMPORTANT_LINE_PATTERNS) {
+		if (pattern.test(line)) return true;
+	}
+	return false;
+}
+
+/**
+ * Extract up to `maxLines` important lines from `text`. Lines are split on
+ * `\n` (also handles `\r\n`). Order preserved; duplicates kept (callers may
+ * want to see the same diagnostic twice if it appears twice — that often
+ * signals a recurring failure).
+ */
+export function extractImportantLines(text: string, maxLines = 30): string[] {
+	if (!text || maxLines <= 0) return [];
+	const out: string[] = [];
+	for (const line of text.split(/\r?\n/)) {
+		if (out.length >= maxLines) break;
+		if (isImportantLine(line)) out.push(line);
+	}
+	return out;
+}
+
+export interface TruncationSplit {
+	/** The first 75% of the value (by char count), verbatim. */
+	head: string;
+	/** The last 25% of the value (by char count), verbatim. */
+	tail: string;
+	/**
+	 * Important lines from the middle slice, greedily picked (whole lines) so
+	 * the joined length fits inside `slackFactor * maxChars`. Empty when
+	 * `preserveImportant` is false OR no important lines are present OR none
+	 * fit the slack budget.
+	 */
+	importantLines: string[];
+	/** `value.length - maxChars` — chars dropped if no important lines preserved. */
+	baseDropped: number;
+}
+
+export interface SplitOptions {
+	/** When false, important-line scanning is skipped (assistant-text mode). */
+	preserveImportant?: boolean;
+	/** Hard cap on candidate lines before slack-budget selection. Default 30. */
+	maxImportantLines?: number;
+	/** Fraction of `maxChars` available for important-line content. Default 0.15. */
+	slackFactor?: number;
+}
+
+/**
+ * Split `value` into head + important-middle + tail, returning the parts.
+ * The caller is responsible for composing the final result (marker + glue)
+ * because the marker wording differs between `compactString` and
+ * `readIfSmall`.
+ *
+ * When no important lines are picked, the returned `importantLines` is `[]`
+ * and the marker wording stays bit-identical to the pre-P0-B format.
+ */
+export function splitWithImportantLines(value: string, maxChars: number, opts: SplitOptions = {}): TruncationSplit {
+	if (value.length <= maxChars) {
+		return { head: value, tail: "", importantLines: [], baseDropped: 0 };
+	}
+	const headLen = Math.floor(maxChars * 0.75);
+	const tailLen = maxChars - headLen;
+	const head = value.slice(0, headLen);
+	const tail = value.slice(value.length - tailLen);
+
+	if (opts.preserveImportant === false) {
+		return { head, tail, importantLines: [], baseDropped: value.length - maxChars };
+	}
+
+	const slackFactor = opts.slackFactor ?? 0.15;
+	const slackChars = Math.max(0, Math.floor(maxChars * slackFactor));
+	const maxCandidates = opts.maxImportantLines ?? 30;
+	const middle = value.slice(headLen, value.length - tailLen);
+	const candidates = extractImportantLines(middle, maxCandidates);
+
+	// Greedily pick whole lines that fit in the slack budget.
+	const chosen: string[] = [];
+	let used = 0;
+	for (const line of candidates) {
+		const addLen = (chosen.length > 0 ? 1 : 0) + line.length; // '\n' separator
+		if (used + addLen > slackChars) break;
+		chosen.push(line);
+		used += addLen;
+	}
+
+	return { head, tail, importantLines: chosen, baseDropped: value.length - maxChars };
+}

package/src/runtime/iteration-hooks.ts

@@ -8,6 +8,7 @@ import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { WINDOWS_ESSENTIAL_ENV_VARS } from "../utils/env-allowlist.ts";
+import { HeadSnapStage } from "./compact-stages/index.ts";
 import { resolveShellForScript } from "../utils/resolve-shell.ts";
 import { sanitizeEnvSecrets } from "../utils/env-filter.ts";
 import { DENIED_METRIC_NAMES } from "./metric-parser.ts";
@@ -98,23 +99,6 @@ function notFiredResult(): HookResult {
 	};
 }
 
-/**
- * Truncate a buffer to the given byte limit, snapping to the last newline
- * boundary for UTF-8 safety.
- */
-function truncateToLimit(buf: Buffer, limit: number): Buffer {
-	if (buf.byteLength <= limit) return buf;
-
-	const slice = buf.subarray(0, limit);
-	// Find the last newline within the truncated region
-	const lastNewline = slice.lastIndexOf("\n");
-	if (lastNewline >= 0) {
-		return slice.subarray(0, lastNewline);
-	}
-	// No newline found — return the full slice
-	return slice;
-}
-
 /**
  * Check if a script path exists and is executable.
  */
@@ -196,13 +180,17 @@ export async function runIterationHook(
 			const durationMs = Date.now() - startTime;
 
 			const rawStdout = Buffer.concat(stdoutChunks);
-			const truncatedStdout = truncateToLimit(rawStdout, MAX_STDOUT_BYTES);
+			// Sprint 5: refactored onto HeadSnapStage. Convert to UTF-8 string once,
+			// then apply the byte-cap stage with newline-snap so partial lines
+			// never appear in the captured preview. HeadSnapStage is byte-cap-safe
+			// (walks back partial UTF-8 sequences at the cut boundary).
+			const stdoutText = new HeadSnapStage({ maxBytes: MAX_STDOUT_BYTES }).apply(rawStdout.toString("utf-8"));
 
 			const rawStderr = Buffer.concat(stderrChunks);
 
 			resolve({
 				fired: true,
-				stdout: truncatedStdout.toString("utf-8"),
+				stdout: stdoutText,
 				stderr: rawStderr.toString("utf-8"),
 				exitCode: code,
 				timedOut: killed,

package/src/runtime/live-session-runtime.ts

@@ -241,6 +241,54 @@ function modelFromRegistry(modelRegistry: unknown, modelId: string | undefined):
 	}
 }
 
+/**
+ * Round 18: when agent declares `model: false`, the inherited `parentModel`
+ * (= `ctx.model` from Pi runtime, set via `team-tool.ts:541/655`) is the
+ * session's SAVED model. That saved model can be stale (e.g. a previous
+ * session used claude-sonnet-4-5 and saved it as session.model; the new
+ * session actually runs on minimax-M3 displayed in the footer). If the
+ * saved model has no auth in `modelRegistry`, the worker fails immediately
+ * with "No API key found" before reaching any fallback candidate.
+ *
+ * This helper prefers the saved model when it is in the auth-available
+ * registry; otherwise falls back to the first auth-available registry
+ * model (e.g. minimax/MiniMax-M3, zai/glm-5.2); otherwise returns the
+ * raw `parentModel` unchanged so the caller surfaces E008.
+ */
+export function resolveParentModelFromRegistry(
+	modelRegistry: unknown,
+	rawParentModel: unknown,
+): string | undefined {
+	const raw = typeof rawParentModel === "string" ? rawParentModel.trim() : undefined;
+	if (raw) {
+		const candidate = raw.includes("/")
+			? raw
+			: (() => {
+				const m = modelFromRegistry(modelRegistry, raw);
+				if (m && typeof m === "object" && "fullId" in m) {
+					return String((m as { fullId?: unknown }).fullId ?? raw);
+				}
+				return undefined;
+			})();
+		if (candidate && modelFromRegistry(modelRegistry, candidate)) return candidate;
+	}
+	const registry = modelRegistry as { getAvailable?: () => unknown[] } | undefined;
+	if (registry && typeof registry.getAvailable === "function") {
+		try {
+			const available = registry.getAvailable();
+			if (Array.isArray(available) && available.length > 0) {
+				const first = available[0] as { provider?: unknown; id?: unknown } | undefined;
+				if (first && typeof first.provider === "string" && typeof first.id === "string") {
+					return `${first.provider}/${first.id}`;
+				}
+			}
+		} catch {
+			// ignore — fall through to raw
+		}
+	}
+	return raw;
+}
+
 /** Communication intensity by role (caveman-inspired token optimization) */
 const ROLE_INTENSITY: Record<string, "lite" | "full" | "ultra"> = {
 	explorer: "ultra",
@@ -473,7 +521,8 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 			});
 			await (resourceLoader as { reload?: () => Promise<void> }).reload?.();
 		}
-		const modelRouting = buildConfiguredModelRouting({ overrideModel: input.modelOverride, stepModel: input.step.model, teamRoleModel: input.teamRoleModel, agentModel: input.agent.model, fallbackModels: input.agent.fallbackModels, parentModel: input.parentModel, modelRegistry: input.modelRegistry, cwd: input.manifest.cwd, scopeModelsPatterns: await resolveScopeModelsPatterns(input.manifest.cwd) });
+		const effectiveParentModel = resolveParentModelFromRegistry(input.modelRegistry, input.parentModel);
+		const modelRouting = buildConfiguredModelRouting({ overrideModel: input.modelOverride, stepModel: input.step.model, teamRoleModel: input.teamRoleModel, agentModel: input.agent.model, fallbackModels: input.agent.fallbackModels, parentModel: effectiveParentModel, modelRegistry: input.modelRegistry, cwd: input.manifest.cwd, scopeModelsPatterns: await resolveScopeModelsPatterns(input.manifest.cwd) });
 		const resolvedModel = modelFromRegistry(input.modelRegistry, modelRouting.candidates[0] ?? modelRouting.requested) ?? input.parentModel;
 		// Phase 4: MCP proxy — will be determined after session creation
 		// (we check parent's MCP tools and share connections when available)

package/src/runtime/model-fallback.ts

@@ -209,6 +209,25 @@ const RETRYABLE_MODEL_FAILURE_PATTERNS = [
 	/internal(?:_server)?[ _]error/i,
 	/server error/i,
 	/bad gateway/i,
+	//
+	// Broader retryable patterns (added 2026-06-25, FIX 2):
+	// - `/provider[_ ]?error/i`: OpenAI-compatible "Provider error" generic fault.
+	// - `/context[_ ]?length[_ ]?exceeded/i`: "context_length_exceeded" from
+	//   OpenAI/Anthropic — when the configured model is the bottleneck, a
+	//   different model in the fallback chain may have a larger window.
+	// - `/safety/i`: Anthropic safety blocks — typically retryable on a
+	//   different model in the fallback chain.
+	// - `/is[_ ]?overloaded/i`: alias to the existing `/overloaded/i` pattern
+	//   to catch phrasings like "upstream is overloaded".
+	// - `/\b408\b/`: HTTP 408 Request Timeout — transient, provider-side.
+	//
+	// Intentionally NOT added: `/bad_request/` — can mean bad input (e.g.
+	// invalid schema), which is non-retryable.
+	/provider[_ ]?error/i,
+	/context[_ ]?length[_ ]?exceeded/i,
+	/safety/i,
+	/is[_ ]?overloaded/i,
+	/\b408\b/,
 ];
 
 // These patterns indicate auth/key/billing issues that will never succeed on retry.
@@ -313,9 +332,18 @@ export function buildConfiguredModelRouting(input: {
 	const rawModels = availableModels
 		? [input.overrideModel, input.stepModel, input.teamRoleModel, effectiveAgentModel, ...(input.fallbackModels ?? []), ...availableModels.map((model) => model.fullId)]
 		: [input.overrideModel, input.stepModel, input.teamRoleModel, effectiveAgentModel, ...(input.fallbackModels ?? []), parentModel];
+	// Fix (Round 18): when an agent has `model: false` (frontmatter) the
+	// inherited `parentModel` (= session chính's model, e.g. minimax-M3) IS the
+	// desired primary. It must NOT be filtered out by isAvailableModel — which
+	// only knows about models from models.json / registry, NOT builtin Pi models.
+	// Pin the inherited parentModel at index 0 regardless of availability.
+	const parentModelRaw = effectiveAgentModel?.trim() || undefined;
 	const configuredModels = rawModels
 		.filter((model): model is string => Boolean(model?.trim()))
-		.filter((model) => isAvailableModel(model.trim(), availableModels));
+		.filter((model, idx) => {
+			if (parentModelRaw && idx === 0 && model.trim() === parentModelRaw) return true;
+			return isAvailableModel(model.trim(), availableModels);
+		});
 	const candidates = buildModelCandidates(configuredModels[0], configuredModels.slice(1), availableModels, preferredProvider);
 	const reason = requested && candidates[0] && resolveModelCandidate(requested, availableModels, preferredProvider) !== candidates[0]
 		? "requested model unavailable; selected configured Pi fallback"

package/src/runtime/role-permission.ts

@@ -1,11 +1,10 @@
-import { isSensitivePath } from "./sensitive-paths.ts";
-
 export type RolePermissionMode = "read_only" | "workspace_write" | "danger_full_access" | "explicit_confirm";
 
-const READ_ONLY_ROLES = new Set(["explorer", "reviewer", "security-reviewer", "verifier", "analyst", "critic", "planner", "writer"]);
-const WRITE_ROLES = new Set(["executor", "test-engineer"]);
-const READ_ONLY_COMMANDS = new Set(["cat", "head", "tail", "less", "more", "wc", "ls", "find", "grep", "rg", "awk", "sed", "echo", "printf", "which", "where", "whoami", "pwd", "env", "printenv", "date", "df", "du", "uname", "file", "stat", "diff", "sort", "uniq", "tr", "cut", "paste", "test", "true", "false", "type", "readlink", "realpath", "basename", "dirname", "sha256sum", "md5sum", "xxd", "hexdump", "od", "strings", "tree", "jq", "git", "gh"]);
-
+// Read-only roles: cannot mutate files/source. `verifier` is NOT here — it runs
+// tests (bash + cache writes) so it is a WRITE role (F4). `planner` stays
+// read-only to preserve the plan-approval gate boundary (F3).
+const READ_ONLY_ROLES = new Set(["explorer", "reviewer", "security-reviewer", "analyst", "critic", "planner"]);
+const WRITE_ROLES = new Set(["executor", "test-engineer", "writer", "verifier"]);
 export interface PermissionCheckResult {
 	allowed: boolean;
 	mode: RolePermissionMode;
@@ -18,21 +17,6 @@ export function permissionForRole(role: string): RolePermissionMode {
 	return "workspace_write";
 }
 
-export function isReadOnlyCommand(command: string): boolean {
-	const first = command.trim().split(/\s+/)[0]?.split(/[\\/]/).pop() ?? "";
-	return READ_ONLY_COMMANDS.has(first) && !/\s(-i|--in-place)\b|\s>{1,2}\s|\brm\b|\bmv\b|\bcp\b|\b(?:npm|pnpm|yarn|bun)\s+(install|add|ci|remove)\b|\bgit\s+(commit|push|merge|rebase|reset|checkout|clean)\b/.test(command);
-}
-
-export function checkRolePermission(role: string, command: string, filePath?: string): PermissionCheckResult {
-	const mode = permissionForRole(role);
-	// Also block access to known sensitive paths even for read-only commands
-	if (filePath && isSensitivePath(filePath)) {
-		return { allowed: false, mode, reason: `Path '${filePath}' is sensitive (credentials, SSH keys, etc.) — access denied for all roles.` };
-	}
-	if (mode === "read_only" && !isReadOnlyCommand(command)) return { allowed: false, mode, reason: `Role '${role}' is read-only and command may modify state.` };
-	return { allowed: true, mode };
-}
-
 export function currentCrewRole(env: NodeJS.ProcessEnv = process.env): string | undefined {
 	return env.PI_CREW_ROLE?.trim() || env.PI_TEAMS_ROLE?.trim() || undefined;
 }

package/src/runtime/stream-preview.ts

@@ -3,6 +3,7 @@
 // Used by the UI layer to show partial results before task completion.
 
 import type { ParsedPiUsage } from "./pi-json-output.ts";
+import { TAIL_CAPTURE_STREAM_STAGE } from "./compact-stages/index.ts";
 
 export interface ToolCallPreview {
 	toolName: string;
@@ -111,7 +112,13 @@ export function feedJsonEvent(preview: StreamPreview, event: unknown): boolean {
 		const text = extractTextFromContent(message?.content ?? obj.content);
 		if (text) {
 			const appended = preview.textBuffer.length > 0 ? preview.textBuffer + "\n" + text : text;
-			preview.textBuffer = appended.length > MAX_TEXT_BUFFER ? appended.slice(appended.length - MAX_TEXT_BUFFER) : appended;
+			// Sprint 5: refactored onto the stage-chain. TAIL_CAPTURE_STREAM_STAGE
+			// is a 16_384-char tail-capture stage with no marker (the UI shows
+			// raw text without a prefix). It is bit-equivalent to the inline
+			// `appended.slice(appended.length - MAX_TEXT_BUFFER)` for inputs at
+			// or below the cap (returns verbatim) and equivalent for over-cap
+			// inputs (returns last MAX_TEXT_BUFFER chars).
+			preview.textBuffer = TAIL_CAPTURE_STREAM_STAGE.apply(appended);
 		}
 		modified = true;
 	}
@@ -119,7 +126,7 @@ export function feedJsonEvent(preview: StreamPreview, event: unknown): boolean {
 	// Detect direct text/final output
 	if (typeof obj.text === "string" && obj.text.trim()) {
 		const appended = preview.textBuffer.length > 0 ? preview.textBuffer + "\n" + obj.text : obj.text;
-		preview.textBuffer = appended.length > MAX_TEXT_BUFFER ? appended.slice(appended.length - MAX_TEXT_BUFFER) : appended;
+		preview.textBuffer = TAIL_CAPTURE_STREAM_STAGE.apply(appended);
 		modified = true;
 	}