pi-crew 0.9.57 → 0.9.59

package/src/utils/paths.ts

@@ -3,7 +3,14 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 
+// NEW-P1/NEW-P2 (perf): packageRoot() and userPiRoot() are invariant for a
+// process lifetime but each call did statSync/readFileSync/lstatSync (10-15+
+// call sites, including at MODULE-LOAD time). Memoize both: compute on first
+// call, return the cached value thereafter. Resolution logic is unchanged.
+let cachedPackageRoot: string | undefined;
+
 export function packageRoot(): string {
+	if (cachedPackageRoot !== undefined) return cachedPackageRoot;
 	// Phase 5 H2 follow-up: this function is called from both src/ paths
 	// (e.g. src/utils/paths.ts) AND from dist/index.mjs after bundling.
 	// The original 2-level walk only worked for src/ paths:
@@ -22,6 +29,7 @@ export function packageRoot(): string {
 			try {
 				const pkg = JSON.parse(fs.readFileSync(candidate, "utf-8")) as { name?: string };
 				if (pkg.name === "pi-crew") {
+					cachedPackageRoot = dir;
 					return dir;
 				}
 			} catch {
@@ -35,9 +43,12 @@ export function packageRoot(): string {
 	// Fallback: 2-level walk (matches original src/ semantics). Bundles
 	// that don't ship a package.json (very unusual) will get a wrong path
 	// here, but that's a build-pipeline bug we want to surface, not hide.
-	return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+	cachedPackageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+	return cachedPackageRoot;
 }
 
+let cachedUserPiRoot: { home: string; value: string } | undefined;
+
 export function userPiRoot(): string {
 	// F4: a misconfigured PI_TEAMS_HOME can be the literal string "undefined"
 	// (e.g. PI_TEAMS_HOME=$UNSET_VAR in a shell), which would build paths like
@@ -46,6 +57,12 @@ export function userPiRoot(): string {
 	// os.homedir().
 	const rawHome = (process.env.PI_TEAMS_HOME ?? process.env.PI_CREW_HOME)?.trim();
 	const home = rawHome && rawHome !== "undefined" ? rawHome : os.homedir();
+	// NEW-P2: memoize but KEY ON HOME. Tests (withIsolatedHome / isolateHome)
+	// change PI_TEAMS_HOME mid-process; an unkeyed cache would leak the first
+	// test's root across the suite (broken isolation — surfaced by active-run-
+	// registry / health-monitor run counts). In production home is stable, so
+	// this still collapses ~15 lstatSync call sites to one stat per distinct home.
+	if (cachedUserPiRoot?.home === home) return cachedUserPiRoot.value;
 	const resolved = path.join(home, ".pi", "agent");
 
 	// Reject symlinks to prevent confusion attacks where PI_TEAMS_HOME points to
@@ -59,6 +76,7 @@ export function userPiRoot(): string {
 	} catch (err: unknown) {
 		if (err instanceof Error && "code" in err && err.code !== "ENOENT") throw err;
 		// Path doesn't exist yet — caller will create it. Skip further validation.
+		cachedUserPiRoot = { home, value: resolved };
 		return resolved;
 	}
 	if (isSymlink) {
@@ -88,6 +106,7 @@ export function userPiRoot(): string {
 		// (race condition). This is acceptable — caller will handle.
 	}
 
+	cachedUserPiRoot = { home, value: resolved };
 	return resolved;
 }
 

package/src/utils/redaction.ts

@@ -63,6 +63,17 @@ export const SLACK_TOKEN_PATTERN = /(?<![A-Za-z0-9_-])xox[baprs]-[A-Za-z0-9-]{10
 export const GOOGLE_API_KEY_PATTERN = /(?<![A-Za-z0-9_-])AIza[0-9A-Za-z_-]{35}(?![0-9A-Za-z_-])/g;
 export const STRIPE_KEY_PATTERN = /(?<![A-Za-z0-9_])sk_live_[0-9a-zA-Z]{24}(?![0-9a-zA-Z])/g;
 
+// DI-2: Anthropic + OpenAI API key value formats. These mirror the same
+// ReDoS-safe shape as the OQ13 set: a single bounded {20,} quantifier on a
+// plain char class, anchored by a negative lookbehind (no nested quantifiers,
+// no alternation). The lookbehind prevents matching inside a longer identifier
+// (e.g. "mysk-ant-api03..."), and the 20+ char tail keeps short "sk-"
+// prefixes (a common legit abbreviation) from being over-redacted. NOTE: the
+// lookbehind is a fixed-width zero-width assertion — linear, safe.
+export const ANTHROPIC_KEY_PATTERN = /(?<![A-Za-z0-9_-])sk-ant-[A-Za-z0-9_-]{20,}/g;
+export const OPENAI_PROJECT_KEY_PATTERN = /(?<![A-Za-z0-9_-])sk-proj-[A-Za-z0-9_-]{20,}/g;
+export const OPENAI_KEY_PATTERN = /(?<![A-Za-z0-9_-])sk-[A-Za-z0-9_-]{20,}/g;
+
 // Linear-time secret key detection
 // IMPORTANT: This function must maintain linear-time guarantees.
 // The fast-path regex uses simple string alternatives with anchors only (no quantifiers),
@@ -236,6 +247,12 @@ const SECRET_MARKERS_CASE_SENSITIVE = [
 	"AIza",
 	"sk_live_",
 	"xox",
+	// DI-2: Anthropic (sk-ant-) and OpenAI (sk-proj-) API key prefixes. The
+	// bare "sk-" prefix is NOT a marker (too common as a short word/abbrev and
+	// would defeat the pre-filter skip); OPENAI_KEY_PATTERN's {20,} tail still
+	// catches bare sk-... keys via the value-pattern pass.
+	"sk-ant-",
+	"sk-proj-",
 	// GitHub PAT prefixes (gh[pousr]_) — exact, not the over-broad "gh" which
 	// matched "though"/"highlight"/"might" and defeated the pre-filter skip.
 	"ghp_",
@@ -296,7 +313,11 @@ export function redactSecretString(value: string): string {
 		.replace(AWS_ACCESS_KEY_PATTERN, "***")
 		.replace(SLACK_TOKEN_PATTERN, "***")
 		.replace(GOOGLE_API_KEY_PATTERN, "***")
-		.replace(STRIPE_KEY_PATTERN, "***");
+		.replace(STRIPE_KEY_PATTERN, "***")
+		// DI-2: Anthropic + OpenAI API keys (value-based formats).
+		.replace(ANTHROPIC_KEY_PATTERN, "***")
+		.replace(OPENAI_PROJECT_KEY_PATTERN, "***")
+		.replace(OPENAI_KEY_PATTERN, "***");
 
 	// Replace inline secrets: key=value or key:value patterns
 	result = redactInlineSecrets(result);

package/src/utils/session-utils.ts

@@ -49,34 +49,57 @@ export function safeToPiSessionId(runId: string): string | undefined {
 	}
 }
 
+/**
+ * Module-level cache for resolved session ids, keyed by the stable
+ * `sessionManager` reference (NOT by `ctx` — `ctx` is recreated per event by
+ * `createContext()` on the runner, so keying on `ctx` would never hit the
+ * cache). The `sessionManager` object persists across events within a session.
+ */
+const sessionIdCache = new WeakMap<object, string>();
+
 /**
  * Extract the current Pi session id from an ExtensionContext.
  *
- * `ExtensionContext` does not declare `sessionId` in its type, but the runtime
- * attaches it as an own property. We read it via `getOwnPropertyDescriptor`
- * to safely bypass any Proxy traps, then validate it as a non-empty string.
+ * On Pi 0.83.0 the `ExtensionContext` has NO top-level `sessionId` property —
+ * the id is reachable only via `ctx.sessionManager.getSessionId()`. This is
+ * the canonical accessor: every site that filters the SHARED per-project
+ * `.crew/state/` tree down to the current session MUST use this, otherwise
+ * cross-session state leaks (e.g. compaction-guard resuming another session's
+ * runs, ambient-status injecting another session's runs).
  *
- * This is the canonical accessor — every site that filters the SHARED
- * per-project `.crew/state/` tree down to the current session MUST use this,
- * otherwise cross-session state leaks (e.g. compaction-guard resuming another
- * session's runs, ambient-status injecting another session's runs).
+ * Strategy (primary → fallback):
+ *   1. `ctx.sessionManager?.getSessionId?.()` — the working accessor on
+ *      Pi 0.83.0. The result is cached by `sessionManager` ref so the method
+ *      lookup runs at most once per session-manager instance, keeping the hot
+ *      path (called on every `context` event) cheap.
+ *   2. `Object.getOwnPropertyDescriptor(ctx, "sessionId")` — for test mocks
+ *      and older Pi versions that attach `sessionId` as an own property.
  *
  * Returns undefined when the session id is absent or unparseable — callers
  * must decide whether to treat that as "no filter" (back-compat) or "no runs".
  */
 export function extractSessionId(ctx: unknown): string | undefined {
 	if (typeof ctx !== "object" || ctx === null) return undefined;
-	let raw: unknown;
 	try {
-		raw = Object.getOwnPropertyDescriptor(ctx, "sessionId")?.value;
+		const sm = (ctx as { sessionManager?: { getSessionId?: () => unknown } }).sessionManager;
+		if (sm && typeof sm === "object") {
+			const cached = sessionIdCache.get(sm as object);
+			if (cached) return cached;
+			const id = (sm as { getSessionId?: () => unknown }).getSessionId?.();
+			if (typeof id === "string" && id.length > 0) {
+				sessionIdCache.set(sm as object, id);
+				return id;
+			}
+		}
+		const direct = Object.getOwnPropertyDescriptor(ctx, "sessionId")?.value;
+		if (typeof direct === "string" && direct.length > 0) return direct;
 	} catch {
-		// Defensive: a hostile Proxy or exotic object may trap descriptor
-		// access. Real Pi ExtensionContext objects are plain, so this is
-		// only hit by adversarial/degenerate inputs — treat as no session id.
+		// Defensive: a hostile Proxy or exotic object may trap property or
+		// descriptor access. Real Pi ExtensionContext objects are plain, so
+		// this is only hit by adversarial/degenerate inputs — treat as no id.
 		return undefined;
 	}
-	if (typeof raw !== "string" || raw.length === 0) return undefined;
-	return raw;
+	return undefined;
 }
 
 /**
@@ -86,11 +109,11 @@ export function extractSessionId(ctx: unknown): string | undefined {
  * its public surface — the id is reachable via `ctx.sessionManager.getSessionId()`.
  * This helper is only called from `installCrewBrokerLifecycleController.setSessionId`
  * (once per session_start), so the extra method invocation is safe here. It is
- * INTENTIONALLY a separate function from `extractSessionId`, which is called on
- * every `context` event (before every LLM call) from `context-status-injection.ts`
- * — extending that hot path with method calls was observed to freeze the TUI
- * (dashboard opens but is unresponsive, footer does not render) during smoke
- * testing, so it stays on the trivial property lookup.
+ * INTENTIONALLY a separate function from `extractSessionId`: both now read
+ * `sessionManager.getSessionId()` first, but `extractSessionId` memoises the
+ * result in a WeakMap keyed by the `sessionManager` ref (it is called on every
+ * `context` event from `context-status-injection.ts`), whereas this broker
+ * helper is called only once per `session_start`, so caching is unnecessary.
  *
  * Tries the sessionManager path first, then falls back to a direct
  * `ctx.sessionId` for test mock compatibility.

package/src/worktree/worktree-manager.ts

@@ -767,7 +767,7 @@ export function prepareTaskWorkspace(manifest: TeamRunManifest, task: TeamTaskSt
 			throw new Error(`Existing worktree branch mismatch at ${worktreePath}: expected '${branch}', got '${currentBranch}'.`);
 		}
 		// ST-1: use -uall so untracked directories are expanded to individual files.
-		const dirtyStatus = git(worktreePath, ["status", "--porcelain", "-uall"]);
+		const dirtyStatus = git(worktreePath, ["-c", "core.quotePath=false", "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.
@@ -927,7 +927,7 @@ export async function prepareTaskWorkspaceAsync(
 			throw new Error(`Existing worktree branch mismatch at ${worktreePath}: expected '${branch}', got '${currentBranch}'.`);
 		}
 		// ST-1: use -uall so untracked directories are expanded to individual files.
-		const dirtyStatus = await gitAsync(worktreePath, ["status", "--porcelain", "-uall"]);
+		const dirtyStatus = await gitAsync(worktreePath, ["-c", "core.quotePath=false", "status", "--porcelain", "-uall"]);
 		if (dirtyStatus.trim()) {
 			const snapshotOk = snapshotDirtyWorktree(manifest, task, worktreePath, dirtyStatus);
 			if (snapshotOk) {