pi-crew 0.9.55 → 0.9.57

package/src/utils/conflict-detect.ts

@@ -341,11 +341,20 @@ export function parseConflictUri(raw: string): ParsedConflictUri | null {
  * Works by locating the recorded marker block by content (anchored to
  * `entry.startLine` as the preferred match), so out-of-band edits earlier
  * in the file that shift line numbers don't break resolution.
+ *
+ * EOL preservation: lines are split keeping each line's original ending
+ * bytes (CRLF / LF / none). Only the conflicting region is rewritten; every
+ * other line is round-tripped byte-for-byte, so a mixed-EOL file produces a
+ * minimal git diff (previously every line ending was normalised, rewriting
+ * the whole file even when only a few lines conflicted).
  */
 export function spliceConflict(originalText: string, entry: ConflictEntry, replacement: string): string {
-	// Preserve the original line ending (CRLF or LF) for a byte-accurate round-trip.
-	const eol = originalText.includes("\r\n") ? "\r\n" : "\n";
-	const lines = originalText.split(/\r?\n/);
+	// Split preserving each line's original EOL so non-conflicting lines are
+	// round-tripped byte-for-byte (minimal git diff on mixed-EOL files).
+	const segments = splitPreservingEol(originalText);
+	// Content-only view (CR stripped) — identical to the old `split(/\r?\n/)`,
+	// so conflict detection / region matching behaviour is unchanged.
+	const lines = segments.map((s) => s.content);
 	const expected = buildRecordedRegion(entry);
 	const match = locateRegion(lines, expected, entry.startLine - 1);
 	if (!match) {
@@ -356,8 +365,52 @@ export function spliceConflict(originalText: string, entry: ConflictEntry, repla
 
 	const trimmed = normalizeTrailingNewline(replacement);
 	const replacementLines = trimmed.split("\n");
-	const next = [...lines.slice(0, match.startIdx), ...replacementLines, ...lines.slice(match.endIdx + 1)];
-	return next.join(eol);
+	// EOL for the inserted lines: prefer the EOL that originally terminated the
+	// conflict region (local style); fall back to the file's dominant EOL.
+	const regionEol = segments[match.endIdx]?.eol ?? "";
+	const interEol = regionEol || (originalText.includes("\r\n") ? "\r\n" : "\n");
+
+	const out: string[] = [];
+	// Lines before the conflict — verbatim (original content + original EOL).
+	for (let i = 0; i < match.startIdx; i++) out.push(segments[i].content, segments[i].eol);
+	// Replacement lines — intermediate ones use the local EOL; the final one
+	// reuses the boundary EOL that originally separated the region from the
+	// following line, preserving that line's leading boundary exactly.
+	for (let i = 0; i < replacementLines.length; i++) {
+		out.push(replacementLines[i]);
+		out.push(i < replacementLines.length - 1 ? interEol : regionEol);
+	}
+	// Lines after the conflict — verbatim.
+	for (let i = match.endIdx + 1; i < segments.length; i++) out.push(segments[i].content, segments[i].eol);
+	return out.join("");
+}
+
+/**
+ * Split `text` into `{ content, eol }` segments keeping each line's exact
+ * ending bytes. The `content` view equals `text.split(/\r?\n/)`, but the
+ * original EOL (`"\r\n"`, `"\n"`, or `""` for the final line) is retained
+ * so callers can reconstruct the text byte-for-byte.
+ */
+function splitPreservingEol(text: string): { content: string; eol: string }[] {
+	const segments: { content: string; eol: string }[] = [];
+	const n = text.length;
+	let i = 0;
+	while (i <= n) {
+		const nl = text.indexOf("\n", i);
+		if (nl === -1) {
+			segments.push({ content: text.slice(i), eol: "" });
+			break;
+		}
+		let contentEnd = nl;
+		let eol = "\n";
+		if (nl > 0 && text.charCodeAt(nl - 1) === 13 /* \r */) {
+			contentEnd = nl - 1;
+			eol = "\r\n";
+		}
+		segments.push({ content: text.slice(i, contentEnd), eol });
+		i = nl + 1;
+	}
+	return segments;
 }
 
 /** Reconstruct the recorded marker block as it should appear in the file. */

package/src/utils/ndjson.ts

@@ -2,7 +2,7 @@
  * ndjson.ts — Canonical broker NDJSON framing primitives (encoder + decoder
  *              + typed errors). Newline-delimited JSON, one frame per `\\n`.
  *
- * Moved out of the parallel-work stub `src/runtime/crew-broker-deps.ts`.
+ * Moved out of the parallel-work stub `src/runtime/broker/crew-broker-deps.ts`.
  * The public surface (MAX_BROKER_FRAME_BYTES, BrokerError, BrokerErrorCode,
  * encodeBrokerFrame, NdjsonDecoder) is preserved verbatim so importers
  * can be updated with a single import-path change.
@@ -112,4 +112,4 @@ export class NdjsonDecoder {
 // External re-exports
 // ============================================================================
 // Re-exported here for callers that import all broker primitives from ndjson.ts.
-export { newBrokerToken } from "../runtime/crew-broker-tokens.ts";
+export { newBrokerToken } from "../runtime/broker/crew-broker-tokens.ts";

package/src/utils/redaction.ts

@@ -222,7 +222,46 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return true;
 }
 
+// P1-6: cheap pre-filter. The common clean case (plain output, JSON event
+// lines without secret-like key names) bails after one sweep instead of running
+// all ~14 redaction passes. The marker set is the NECESSARY substring for every
+// redactable pattern below — a string containing none of them cannot hold a
+// redactable secret, so skipping is safe. Any marker present → full redaction.
+// NOTE: keep this set in sync with the patterns in redactSecretString; the
+// redaction-corpus test asserts every known secret type trips the pre-filter.
+const SECRET_MARKERS_CASE_SENSITIVE = [
+	"-----BEGIN",
+	"eyJ",
+	"AKIA",
+	"AIza",
+	"sk_live_",
+	"xox",
+	// GitHub PAT prefixes (gh[pousr]_) — exact, not the over-broad "gh" which
+	// matched "though"/"highlight"/"might" and defeated the pre-filter skip.
+	"ghp_",
+	"gho_",
+	"ghu_",
+	"ghs_",
+	"ghr_",
+];
+const SECRET_MARKERS_LOWER = ["bearer", "authorization", "token", "api", "key", "password", "passwd", "secret", "credential", "private"];
+
+function mayContainSecret(value: string): boolean {
+	for (const m of SECRET_MARKERS_CASE_SENSITIVE) {
+		if (value.includes(m)) return true;
+	}
+	// Case-insensitive markers (Bearer/auth headers + inline-secret key names).
+	// toLowerCase is a full pass, so only pay it after the case-sensitive misses.
+	const lower = value.toLowerCase();
+	for (const m of SECRET_MARKERS_LOWER) {
+		if (lower.includes(m)) return true;
+	}
+	return false;
+}
+
 export function redactSecretString(value: string): string {
+	// P1-6: skip the ~14 redaction passes when no secret marker is present.
+	if (!mayContainSecret(value)) return value;
 	let result = value;
 
 	// Replace PEM private keys. Skip the regex entirely on very large inputs —

package/src/utils/socket-path.ts

@@ -1,7 +1,7 @@
 /**
  * socket-path.ts — Canonical broker Unix-socket / named-pipe path utilities.
  *
- * Moved out of the parallel-work stub `src/runtime/crew-broker-deps.ts`.
+ * Moved out of the parallel-work stub `src/runtime/broker/crew-broker-deps.ts`.
  * The public surface (hashSessionId, getBrokerSocketPath,
  * prepareBrokerSocketDir, removeStaleBrokerSocket) is preserved verbatim
  * so importers can be updated with a single import-path change.

package/src/workflows/workflow-config.ts

@@ -63,7 +63,7 @@ export interface WorkflowConfig {
 	 *  multiple ready tasks sharing role + cwd are grouped into a single
 	 *  multi-task worker prompt to reduce per-task cold-start cost. Disabled
 	 *  in v0.9.17 unless the workflow author opts in. See
-	 *  src/runtime/coalesce-tasks.ts. */
+	 *  src/runtime/scheduling/coalesce-tasks.ts. */
 	coalesceMicroTasks?: boolean;
 }
 

package/src/worktree/cleanup.ts

@@ -2,7 +2,7 @@ import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { DEFAULT_PATHS } from "../config/defaults.ts";
-import { writeArtifact } from "../state/artifact-store.ts";
+import { writeArtifact } from "../state/stores/artifact-store.ts";
 import type { TeamRunManifest } from "../state/types.ts";
 import { WINDOWS_ESSENTIAL_ENV_VARS } from "../utils/env-allowlist.ts";
 import { sanitizeEnvSecrets } from "../utils/env-filter.ts";

package/src/worktree/worktree-manager.ts

@@ -5,7 +5,7 @@ import * as path from "node:path";
 import { promisify } from "node:util";
 import { loadConfig } from "../config/config.ts";
 import { DEFAULT_PATHS } from "../config/defaults.ts";
-import { writeArtifact } from "../state/artifact-store.ts";
+import { writeArtifact } from "../state/stores/artifact-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { WINDOWS_ESSENTIAL_ENV_VARS } from "../utils/env-allowlist.ts";
 import { sanitizeEnvSecrets } from "../utils/env-filter.ts";
@@ -463,15 +463,30 @@ async function branchExistsAsync(repoRoot: string, branch: string): Promise<{ lo
 	}
 }
 
+// P1-11: `git worktree prune` is a repo-level write that cleans ALL stale
+// worktrees — running it per task is pure waste. Coalesce concurrent calls
+// (N tasks in a batch → 1 prune) and memoize per repo per process (within a
+// run no new stale worktrees appear, so one prune suffices).
+const _prunedRepos = new Set<string>();
+const _pruneInFlight = new Map<string, Promise<void>>();
 async function pruneStaleWorktreesAsync(repoRoot: string): Promise<void> {
-	try {
-		await execFileAsync("git", ["worktree", "prune"], {
-			cwd: repoRoot,
-			windowsHide: true,
-		});
-	} catch {
-		/* best-effort */
-	}
+	if (_prunedRepos.has(repoRoot)) return;
+	const inFlight = _pruneInFlight.get(repoRoot);
+	if (inFlight) return inFlight;
+	const p = (async () => {
+		try {
+			await execFileAsync("git", ["worktree", "prune"], {
+				cwd: repoRoot,
+				windowsHide: true,
+			});
+		} catch {
+			/* best-effort */
+		}
+		_prunedRepos.add(repoRoot);
+		_pruneInFlight.delete(repoRoot);
+	})();
+	_pruneInFlight.set(repoRoot, p);
+	return p;
 }
 
 /**
@@ -568,7 +583,7 @@ export function overlaySeedPaths(repoRoot: string, worktreePath: string, seedPat
  * recovered via `git apply` / manual restore. Best-effort: a snapshot failure
  * only logs (it must not block the clean-slate reuse flow).
  */
-function snapshotDirtyWorktree(manifest: TeamRunManifest, task: TeamTaskState, worktreePath: string, dirtyStatus: string): boolean {
+export function snapshotDirtyWorktree(manifest: TeamRunManifest, task: TeamTaskState, worktreePath: string, dirtyStatus: string): boolean {
 	try {
 		const parts: string[] = [
 			`# Worktree recovery snapshot`,
@@ -576,15 +591,18 @@ function snapshotDirtyWorktree(manifest: TeamRunManifest, task: TeamTaskState, w
 			`capturedAt: ${new Date().toISOString()}`,
 			"",
 		];
+		// ST-1: use --binary so tracked binary modifications are recoverable via `git apply`.
 		let trackedDiff = "";
 		try {
-			trackedDiff = git(worktreePath, ["diff", "HEAD"]);
+			trackedDiff = git(worktreePath, ["diff", "HEAD", "--binary"]);
 		} catch {
 			trackedDiff = "";
 		}
 		if (trackedDiff.trim()) {
-			parts.push("## Tracked changes (`git diff HEAD`)", "```diff", trackedDiff, "```", "");
+			parts.push("## Tracked changes (`git diff HEAD --binary`)", "```diff", trackedDiff, "```", "");
 		}
+		// ST-1: per-file byte cap — skip/truncate larger files with a note to avoid OOM.
+		const MAX_FILE_BYTES = 256 * 1024;
 		for (const line of dirtyStatus.split("\n")) {
 			if (!line.startsWith("?? ")) continue;
 			// Strip the "?? " prefix and surrounding git quotes.
@@ -593,8 +611,27 @@ function snapshotDirtyWorktree(manifest: TeamRunManifest, task: TeamTaskState, w
 			try {
 				const abs = path.join(worktreePath, rel);
 				if (!fs.existsSync(abs) || fs.statSync(abs).isDirectory()) continue;
-				const content = fs.readFileSync(abs, "utf-8");
-				parts.push(`## Untracked file: ${rel}`, "```", content, "```", "");
+				// ST-1: read raw bytes (not utf-8) so binary files are not corrupted.
+				const buf = fs.readFileSync(abs);
+				const originalSize = buf.byteLength;
+				let data: Buffer = buf;
+				let note = "";
+				if (originalSize > MAX_FILE_BYTES) {
+					data = buf.subarray(0, MAX_FILE_BYTES);
+					note = ` (truncated: ${originalSize} → ${MAX_FILE_BYTES} bytes)`;
+				}
+				// ST-1: detect non-UTF-8 via fatal TextDecoder; base64-encode binary files.
+				let isUtf8 = true;
+				try {
+					new TextDecoder("utf-8", { fatal: true }).decode(data);
+				} catch {
+					isUtf8 = false;
+				}
+				if (isUtf8) {
+					parts.push(`## Untracked file: ${rel}${note}`, "```", data.toString("utf-8"), "```", "");
+				} else {
+					parts.push(`## Untracked file: ${rel}${note} (base64-encoded binary)`, "```base64", data.toString("base64"), "```", "");
+				}
 			} catch {
 				/* skip unreadable/unstat-able entry */
 			}
@@ -729,8 +766,8 @@ export function prepareTaskWorkspace(manifest: TeamRunManifest, task: TeamTaskSt
 		if (currentBranch !== branch) {
 			throw new Error(`Existing worktree branch mismatch at ${worktreePath}: expected '${branch}', got '${currentBranch}'.`);
 		}
-		// Check for uncommitted changes from previous run before reusing
-		const dirtyStatus = git(worktreePath, ["status", "--porcelain"]);
+		// ST-1: use -uall so untracked directories are expanded to individual files.
+		const dirtyStatus = git(worktreePath, ["status", "--porcelain", "-uall"]);
 		if (dirtyStatus.trim()) {
 			// Snapshot uncommitted work to a recovery artifact BEFORE discarding, so the
 			// previous run's changes are never silently destroyed on reuse.
@@ -889,7 +926,8 @@ export async function prepareTaskWorkspaceAsync(
 		if (currentBranch !== branch) {
 			throw new Error(`Existing worktree branch mismatch at ${worktreePath}: expected '${branch}', got '${currentBranch}'.`);
 		}
-		const dirtyStatus = await gitAsync(worktreePath, ["status", "--porcelain"]);
+		// ST-1: use -uall so untracked directories are expanded to individual files.
+		const dirtyStatus = await gitAsync(worktreePath, ["status", "--porcelain", "-uall"]);
 		if (dirtyStatus.trim()) {
 			const snapshotOk = snapshotDirtyWorktree(manifest, task, worktreePath, dirtyStatus);
 			if (snapshotOk) {
@@ -1045,52 +1083,78 @@ export async function captureWorktreeDiffAsync(worktreePath: string): Promise<st
  * assertCleanLeader, pruneStaleWorktrees, sanitizeBranchPart,
  * linkNodeModulesIfPresent) but with a minimal, task-free signature.
  *
- * Returns `undefined` when worktree creation is unavailable (no git repo, dirty
- * leader, git error) so the caller (`ctx.agent`) can fall back gracefully.
+ * Returns `undefined` when worktree isolation is genuinely unavailable (no git
+ * repo, dirty leader) so the caller (`ctx.agent`) can fall back gracefully.
+ * ST-15: when creation was attempted but failed (e.g. disk full), this THROWS
+ * instead of returning undefined so the caller never silently runs in the
+ * leader repo. The branch + path suffix is non-deterministic so a 2nd call for
+ * the same agentId always produces a distinct worktree.
  */
 export function prepareAgentWorktree(manifest: TeamRunManifest, agentId: string): PreparedTaskWorkspace | undefined {
+	// ST-15: Split preconditions from worktree creation.
+	// Precondition failures (no git repo, dirty leader) → return undefined so the
+	// caller falls back gracefully (worktree isolation is genuinely unavailable).
+	let repoRoot: string;
+	let loadedConfig: ReturnType<typeof loadConfig>;
 	try {
-		const repoRoot = findGitRoot(manifest.cwd);
-		const loadedConfig = loadConfig(manifest.cwd);
+		repoRoot = findGitRoot(manifest.cwd);
+		loadedConfig = loadConfig(manifest.cwd);
 		if (loadedConfig.config.requireCleanWorktreeLeader !== false) assertCleanLeader(repoRoot);
-		const sanitizedRunId = manifest.runId.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/^-+|-+$/g, "") || "run";
-		const worktreeRoot = path.join(projectCrewRoot(manifest.cwd), DEFAULT_PATHS.state.worktreesSubdir, sanitizedRunId);
-		fs.mkdirSync(worktreeRoot, { recursive: true });
-		const sanitizedAgentId = sanitizeBranchPart(agentId);
-		const worktreePath = path.join(worktreeRoot, sanitizedAgentId);
-		const branch = `pi-crew/${sanitizedRunId}/${sanitizedAgentId}`;
-		pruneStaleWorktrees(repoRoot);
-		git(repoRoot, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
-		const nodeModulesLinked =
-			loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
-		return { cwd: worktreePath, worktreePath, branch, nodeModulesLinked };
 	} catch {
-		// Graceful fallback: no git repo, dirty leader, or git error → run normally.
+		// Graceful fallback: no git repo or dirty leader → run normally in cwd.
 		return undefined;
 	}
+
+	// ST-15: NON-DETERMINISTIC branch + path suffix. The OLD deterministic name
+	// (`pi-crew/<runId>/<agentId>`) made a 2nd call for the same agent collide
+	// ("already exists") → catch → returned undefined → the run silently fell
+	// back to the leader repo (isolation lost, no error). The timestamp +
+	// short-uuid suffix makes every call produce a distinct worktree.
+	// Creation failures here THROW (not undefined) so callers never silently lose
+	// isolation when worktree creation was requested but failed.
+	const sanitizedRunId = manifest.runId.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/^-+|-+$/g, "") || "run";
+	const worktreeRoot = path.join(projectCrewRoot(manifest.cwd), DEFAULT_PATHS.state.worktreesSubdir, sanitizedRunId);
+	fs.mkdirSync(worktreeRoot, { recursive: true });
+	const sanitizedAgentId = sanitizeBranchPart(agentId);
+	const stamp = `${Date.now()}-${randomBytes(4).toString("hex")}`;
+	const worktreePath = path.join(worktreeRoot, `${sanitizedAgentId}-${stamp}`);
+	const branch = `pi-crew/${sanitizedRunId}/${sanitizedAgentId}-${stamp}`;
+	pruneStaleWorktrees(repoRoot);
+	git(repoRoot, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
+	const nodeModulesLinked =
+		loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
+	return { cwd: worktreePath, worktreePath, branch, nodeModulesLinked };
 }
 
 /** Async version of prepareAgentWorktree — yields the event loop during git operations. */
 export async function prepareAgentWorktreeAsync(manifest: TeamRunManifest, agentId: string): Promise<PreparedTaskWorkspace | undefined> {
+	// ST-15: Split preconditions from worktree creation (see prepareAgentWorktree).
+	let repoRoot: string;
+	let loadedConfig: ReturnType<typeof loadConfig>;
 	try {
-		const repoRoot = await findGitRootAsync(manifest.cwd);
-		const loadedConfig = loadConfig(manifest.cwd);
+		repoRoot = await findGitRootAsync(manifest.cwd);
+		loadedConfig = loadConfig(manifest.cwd);
 		if (loadedConfig.config.requireCleanWorktreeLeader !== false) await assertCleanLeaderAsync(repoRoot);
-		const sanitizedRunId = manifest.runId.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/^-+|-+$/g, "") || "run";
-		const worktreeRoot = path.join(projectCrewRoot(manifest.cwd), DEFAULT_PATHS.state.worktreesSubdir, sanitizedRunId);
-		fs.mkdirSync(worktreeRoot, { recursive: true });
-		const sanitizedAgentId = sanitizeBranchPart(agentId);
-		const worktreePath = path.join(worktreeRoot, sanitizedAgentId);
-		const branch = `pi-crew/${sanitizedRunId}/${sanitizedAgentId}`;
-		await pruneStaleWorktreesAsync(repoRoot);
-		await gitAsync(repoRoot, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
-		const nodeModulesLinked =
-			loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
-		return { cwd: worktreePath, worktreePath, branch, nodeModulesLinked };
 	} catch {
-		// Graceful fallback: no git repo, dirty leader, or git error → run normally.
+		// Graceful fallback: no git repo or dirty leader → run normally in cwd.
 		return undefined;
 	}
+
+	// ST-15: NON-DETERMINISTIC branch + path suffix — a 2nd call for the same
+	// agentId creates a DISTINCT worktree instead of colliding. Creation failures
+	// here THROW so callers never silently fall back to the leader repo.
+	const sanitizedRunId = manifest.runId.replace(/[^a-zA-Z0-9._-]/g, "-").replace(/^-+|-+$/g, "") || "run";
+	const worktreeRoot = path.join(projectCrewRoot(manifest.cwd), DEFAULT_PATHS.state.worktreesSubdir, sanitizedRunId);
+	fs.mkdirSync(worktreeRoot, { recursive: true });
+	const sanitizedAgentId = sanitizeBranchPart(agentId);
+	const stamp = `${Date.now()}-${randomBytes(4).toString("hex")}`;
+	const worktreePath = path.join(worktreeRoot, `${sanitizedAgentId}-${stamp}`);
+	const branch = `pi-crew/${sanitizedRunId}/${sanitizedAgentId}-${stamp}`;
+	await pruneStaleWorktreesAsync(repoRoot);
+	await gitAsync(repoRoot, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
+	const nodeModulesLinked =
+		loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;
+	return { cwd: worktreePath, worktreePath, branch, nodeModulesLinked };
 }
 
 /**

package/workflows/chain.workflow.md

@@ -6,7 +6,7 @@ topology: dynamic
 
 # Chain Workflow - Sequential execution with context passing
 
-**Source:** `docs/pi-boomerang-integration-plan.md`  
+**Source:** pi-boomerang integration plan  
 **Syntax:** `step1 -> step2 -> step3`  
 **Version:** 1.0.0
 
@@ -255,4 +255,4 @@ pi team run --chain "@step1 -> @step2" --continue-on-error
 
 ---
 
-*Generated from pi-boomerang integration plan. See `docs/pi-boomerang-integration-plan.md` for full specification.*
+*Generated from pi-boomerang integration plan.*