pi-crew 0.9.56 → 0.9.57

package/src/runtime/{dynamic-workflow-context.ts → goal-workflow/dynamic-workflow-context.ts}

@@ -24,23 +24,23 @@
 
 import { randomBytes } from "node:crypto";
 import type { TSchema } from "@sinclair/typebox";
-import type { AgentConfig } from "../agents/agent-config.ts";
-import { allAgents, discoverAgents } from "../agents/discover-agents.ts";
-import { writeArtifact } from "../state/artifact-store.ts";
-import { appendEvent } from "../state/event-log.ts";
-import { appendMailboxMessage, readMailbox } from "../state/mailbox.ts";
-import type { TeamRunManifest } from "../state/types.ts";
-import type { TeamConfig } from "../teams/team-config.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import { cleanupAgentWorktreeAsync, prepareAgentWorktreeAsync } from "../worktree/worktree-manager.ts";
-import type { DwfCheckpointState } from "./dwf-state-store.ts";
-import { mapConcurrent } from "./parallel-utils.ts";
-import { parsePiJsonOutput } from "./pi-json-output.ts";
+import type { AgentConfig } from "../../agents/agent-config.ts";
+import { allAgents, discoverAgents } from "../../agents/discover-agents.ts";
+import { appendMailboxMessage, readMailbox } from "../../state/coordination/mailbox.ts";
+import { appendEvent } from "../../state/event-log/event-log.ts";
+import { writeArtifact } from "../../state/stores/artifact-store.ts";
+import type { TeamRunManifest } from "../../state/types.ts";
+import type { TeamConfig } from "../../teams/team-config.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { cleanupAgentWorktreeAsync, prepareAgentWorktreeAsync } from "../../worktree/worktree-manager.ts";
+import type { DwfCheckpointState } from "../dwf-state-store.ts";
+import { parsePiJsonOutput } from "../output/pi-json-output.ts";
+import { extractStructuredResult } from "../output/result-extractor.ts";
+import { executeWithRetry } from "../recovery/retry-executor.ts";
+import { runWorker } from "../run-worker.ts";
+import { mapConcurrent } from "../scheduling/parallel-utils.ts";
+import { Semaphore } from "../scheduling/semaphore.ts";
 import { renderPlanTemplate } from "./plan-templates.ts";
-import { extractStructuredResult } from "./result-extractor.ts";
-import { executeWithRetry } from "./retry-executor.ts";
-import { runWorker } from "./run-worker.ts";
-import { Semaphore } from "./semaphore.ts";
 
 export interface AgentCallOpts {
 	prompt: string;

package/src/runtime/{dynamic-workflow-runner.ts → goal-workflow/dynamic-workflow-runner.ts}

@@ -20,22 +20,22 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { transformSync } from "esbuild";
-import { writeArtifact } from "../state/artifact-store.ts";
-import { appendEvent } from "../state/event-log.ts";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import { packageRoot, projectCrewRoot, userPiRoot } from "../utils/paths.ts";
-import { resolveRealContainedPath } from "../utils/safe-paths.ts";
-import type { DynamicWorkflowConfig } from "../workflows/workflow-config.ts";
-import { assertDeterministicScript, isDeterminismCheckEnabled } from "./deterministic-ast.ts";
-import { DwfStore } from "./dwf-state-store.ts";
+import { appendEvent } from "../../state/event-log/event-log.ts";
+import { writeArtifact } from "../../state/stores/artifact-store.ts";
+import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { packageRoot, projectCrewRoot, userPiRoot } from "../../utils/paths.ts";
+import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
+import type { DynamicWorkflowConfig } from "../../workflows/workflow-config.ts";
+import { assertDeterministicScript, isDeterminismCheckEnabled } from "../deterministic-ast.ts";
+import { DwfStore } from "../dwf-state-store.ts";
 import { getWorkflowFinalResult, getWorkflowPhaseState, makeWorkflowCtx } from "./dynamic-workflow-context.ts";
 
 export interface RunDynamicWorkflowInput {
 	manifest: TeamRunManifest;
 	workflow: DynamicWorkflowConfig;
 	/** Optional team for role resolution (G4 tier 2). */
-	team?: import("../teams/team-config.ts").TeamConfig;
+	team?: import("../../teams/team-config.ts").TeamConfig;
 	signal: AbortSignal;
 	concurrency?: number;
 	modelOverride?: string;

package/src/runtime/{goal-achievement.ts → goal-workflow/goal-achievement.ts}

@@ -18,9 +18,9 @@
  *     without breaking a legitimately-no-op run.
  */
 import { spawnSync } from "node:child_process";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import { findRepoRoot } from "../utils/paths.ts";
-import type { WorkflowConfig } from "../workflows/workflow-config.ts";
+import type { TeamRunManifest, TeamTaskState } from "../../state/types.ts";
+import { findRepoRoot } from "../../utils/paths.ts";
+import type { WorkflowConfig } from "../../workflows/workflow-config.ts";
 
 /**
  * Roles whose job is to EDIT project source/test files (changes that appear in

package/src/runtime/{goal-evaluator.ts → goal-workflow/goal-evaluator.ts}

@@ -24,14 +24,14 @@
  */
 
 import { existsSync, readFileSync } from "node:fs";
-import type { AgentConfig } from "../agents/agent-config.ts";
-import type { GoalVerdict } from "../state/types.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import { redactSecretString } from "../utils/redaction.ts";
-import { collectToolCallsFromEvent } from "./completion-guard.ts";
-import { parsePiJsonOutput } from "./pi-json-output.ts";
-import { extractStructuredResult } from "./result-extractor.ts";
-import { runWorker } from "./run-worker.ts";
+import type { AgentConfig } from "../../agents/agent-config.ts";
+import type { GoalVerdict } from "../../state/types.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { redactSecretString } from "../../utils/redaction.ts";
+import { parsePiJsonOutput } from "../output/pi-json-output.ts";
+import { extractStructuredResult } from "../output/result-extractor.ts";
+import { runWorker } from "../run-worker.ts";
+import { collectToolCallsFromEvent } from "../verification/completion-guard.ts";
 
 export interface GoalEvidence {
 	/** Tail slice of the turn's worker transcript (bounded ~8 KiB). */

package/src/runtime/{goal-loop-runner.ts → goal-workflow/goal-loop-runner.ts}

@@ -17,23 +17,23 @@
 import { randomBytes } from "node:crypto";
 import { existsSync, readdirSync } from "node:fs";
 import { createRequire } from "node:module";
-import type { AgentConfig } from "../agents/agent-config.ts";
-import { loadConfig } from "../config/config.ts";
-import { effectiveRunConfig } from "../extension/team-tool/config-patch.ts";
-import { registerActiveRun, unregisterActiveRun } from "../state/active-run-registry.ts";
-import { appendEvent } from "../state/event-log.ts";
-import { collectRunMetrics } from "../state/run-metrics.ts";
-import { createRunManifest, saveRunTasks } from "../state/state-store.ts";
-import type { GoalLoopState, GoalLoopStatus, GoalVerdict, TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import type { TeamConfig } from "../teams/team-config.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import type { WorkflowConfig } from "../workflows/workflow-config.ts";
+import type { AgentConfig } from "../../agents/agent-config.ts";
+import { loadConfig } from "../../config/config.ts";
+import { effectiveRunConfig } from "../../extension/team-tool/config-patch.ts";
+import { appendEvent } from "../../state/event-log/event-log.ts";
+import { registerActiveRun, unregisterActiveRun } from "../../state/stores/active-run-registry.ts";
+import { collectRunMetrics } from "../../state/stores/run-metrics.ts";
+import { createRunManifest, saveRunTasks } from "../../state/stores/state-store.ts";
+import type { GoalLoopState, GoalLoopStatus, GoalVerdict, TeamRunManifest, TeamTaskState } from "../../state/types.ts";
+import type { TeamConfig } from "../../teams/team-config.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import type { WorkflowConfig } from "../../workflows/workflow-config.ts";
+import { resolveCrewRuntime } from "../model/runtime-resolver.ts";
+import { executeTeamRun } from "../team-runner.ts";
+import { compareSnapshot, snapshotManifests } from "../verification/verification-integrity.ts";
+import { acquireWorkspaceLock, type WorkspaceLockHandle } from "../workspace-lock.ts";
 import { bundleEvidence, evaluateGoal } from "./goal-evaluator.ts";
 import { GoalStore } from "./goal-state-store.ts";
-import { resolveCrewRuntime } from "./runtime-resolver.ts";
-import { executeTeamRun } from "./team-runner.ts";
-import { compareSnapshot, snapshotManifests } from "./verification-integrity.ts";
-import { acquireWorkspaceLock, type WorkspaceLockHandle } from "./workspace-lock.ts";
 
 /** Required minimal shape for the worker + agents discovery (P0 uses the goal's workerAgent). */
 export interface GoalLoopRuntimeDeps {
@@ -62,8 +62,8 @@ export interface RunGoalLoopResult {
 export const stubGoalEvaluator = async (
 	goal: GoalLoopState,
 	_turnRunId: string,
-	_m?: import("../state/types.ts").TeamRunManifest,
-	_t?: import("../state/types.ts").TeamTaskState[],
+	_m?: import("../../state/types.ts").TeamRunManifest,
+	_t?: import("../../state/types.ts").TeamTaskState[],
 	_s?: AbortSignal,
 ): Promise<GoalEvaluatorResult> => ({
 	verdict: {
@@ -84,8 +84,8 @@ export type GoalEvaluatorResult = {
 export type GoalEvaluatorFn = (
 	goal: GoalLoopState,
 	turnRunId: string,
-	turnManifest: import("../state/types.ts").TeamRunManifest,
-	turnTasks: import("../state/types.ts").TeamTaskState[],
+	turnManifest: import("../../state/types.ts").TeamRunManifest,
+	turnTasks: import("../../state/types.ts").TeamTaskState[],
 	signal: AbortSignal,
 ) => Promise<GoalEvaluatorResult>;
 
@@ -98,8 +98,8 @@ export type GoalEvaluatorFn = (
 export const realGoalEvaluator = async (
 	goal: GoalLoopState,
 	turnRunId: string,
-	turnManifest: import("../state/types.ts").TeamRunManifest,
-	turnTasks: import("../state/types.ts").TeamTaskState[],
+	turnManifest: import("../../state/types.ts").TeamRunManifest,
+	turnTasks: import("../../state/types.ts").TeamTaskState[],
 	signal: AbortSignal,
 ): Promise<GoalEvaluatorResult> => {
 	const transcriptPath = deriveTranscriptPath(turnManifest.artifactsRoot, turnTasks);
@@ -138,7 +138,7 @@ export const realGoalEvaluator = async (
 		if (!verificationCompromised) {
 			try {
 				// LAZY: defer dynamic import of ./verification-gates.ts to its call site.
-				const { executeVerificationCommands } = await import("./verification-gates.ts");
+				const { executeVerificationCommands } = await import("../verification/verification-gates.ts");
 				const contract = {
 					requiredGreenLevel: "none" as const,
 					commands: goal.verification.commands,
@@ -154,7 +154,9 @@ export const realGoalEvaluator = async (
 				try {
 					// LAZY: defer dynamic import of ./verification-worktree.ts to its call site.
 					// LAZY: defer dynamic import of ./verification-worktree.ts to its call site. Multi-line form breaks scripts/check-lazy-imports.mjs (which does `lines[lineNum - 2]`), so keep destructuring + await import on one line.
-					const { checkWorktreeSandboxAvailable, prepareVerificationWorktree } = await import("./verification-worktree.ts");
+					const { checkWorktreeSandboxAvailable, prepareVerificationWorktree } = await import(
+						"../verification/verification-worktree.ts"
+					);
 					const availability = checkWorktreeSandboxAvailable(goal.cwd);
 					if (availability.available) {
 						const wt = prepareVerificationWorktree(goal.cwd, availability.commitSha);
@@ -272,7 +274,7 @@ function resolveGoalTurnWorkflow(goal: GoalLoopState): WorkflowConfig {
 		const requireFromHere = createRequire(import.meta.url);
 		const { discoverWorkflows, allWorkflows } = requireFromHere(
 			"../workflows/discover-workflows.ts",
-		) as typeof import("../workflows/discover-workflows.ts");
+		) as typeof import("../../workflows/discover-workflows.ts");
 		const found = allWorkflows(discoverWorkflows(goal.cwd)).find((w) => w.name === wrapName && w.source === "builtin");
 		if (found) return found;
 		logInternalError(
@@ -474,7 +476,7 @@ function jaccardSimilarity(a: Set<string>, b: Set<string>): number {
 
 /** Derive the worker transcript path from the turn's tasks (Fix P0-2). Falls back to dir scan.
  *  Exported for unit testing the path-derivation fix. */
-export function deriveTranscriptPath(artifactsRoot: string, tasks: import("../state/types.ts").TeamTaskState[]): string | undefined {
+export function deriveTranscriptPath(artifactsRoot: string, tasks: import("../../state/types.ts").TeamTaskState[]): string | undefined {
 	const transcriptsDir = `${artifactsRoot}/transcripts`;
 	// Primary: use the first task's id + attempt-0 (task-runner writes ${task.id}.attempt-${i}.jsonl).
 	const firstTask = tasks[0];

package/src/runtime/{goal-state-store.ts → goal-workflow/goal-state-store.ts}

@@ -6,7 +6,7 @@
  * goal loop owns OUTER state) + §0c C10 (hardening: assertSafePathId + UUID goalId).
  *
  * Stores GoalLoopState as atomic JSON at <crewRoot>/state/goals/<goalId>.json.
- * Modeled on ScheduleStore (state/schedule.ts:86) but with atomicWriteJson +
+ * Modeled on ScheduleStore (state/coordination/schedule.ts:86) but with atomicWriteJson +
  * path-traversal defense (assertSafePathId on every public method).
  *
  * Per §0c C2: budget lives here (budgetUsed accumulates collectRunMetrics across turns);
@@ -15,13 +15,13 @@
 
 import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
 import { dirname } from "node:path";
-import { atomicWriteJson } from "../state/atomic-write.ts";
-import { appendEvent } from "../state/event-log.ts";
-import type { GoalLoopState, GoalLoopStatus } from "../state/types.ts";
-import { createRunId } from "../utils/ids.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import { projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
-import { assertSafePathId } from "../utils/safe-paths.ts";
+import { atomicWriteJson } from "../../state/atomic-write.ts";
+import { appendEvent } from "../../state/event-log/event-log.ts";
+import type { GoalLoopState, GoalLoopStatus } from "../../state/types.ts";
+import { createRunId } from "../../utils/ids.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { projectCrewRoot, userCrewRoot } from "../../utils/paths.ts";
+import { assertSafePathId } from "../../utils/safe-paths.ts";
 
 /** Default state-root resolver: project scope if a project crew-root exists, else user scope. */
 function resolveGoalsRoot(cwd: string): string {

package/src/runtime/{plan-templates.ts → goal-workflow/plan-templates.ts}

@@ -9,7 +9,7 @@
  * deterministic scaffolding + LLM refinement.
  */
 
-import { logInternalError } from "../utils/internal-error.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
 
 // ── Types ────────────────────────────────────────────────────────────────
 

package/src/runtime/group-join.ts

@@ -1,7 +1,7 @@
 import type { CrewRuntimeConfig } from "../config/config.ts";
-import { writeArtifact } from "../state/artifact-store.ts";
-import { appendEvent } from "../state/event-log.ts";
-import { appendMailboxMessage, findMailboxMessageByRequestId, readDeliveryState } from "../state/mailbox.ts";
+import { appendMailboxMessage, findMailboxMessageByRequestId, readDeliveryState } from "../state/coordination/mailbox.ts";
+import { appendEvent } from "../state/event-log/event-log.ts";
+import { writeArtifact } from "../state/stores/artifact-store.ts";
 import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { aggregateTaskOutputs } from "./task-output-context.ts";
 

package/src/runtime/handoff-manager.ts

@@ -50,8 +50,6 @@ export function isValidHandoffSummary(value: unknown): value is HandoffSummary {
  * - Detects task completion via agent_end hook
  * - Generates structured summaries with token metrics, artifacts, decisions
  * - Optionally collapses context to reduce token usage
- *
- * @see docs/pi-boomerang-integration-plan.md
  */
 
 /**

package/src/runtime/{heartbeat-watcher.ts → heartbeat/heartbeat-watcher.ts}

@@ -1,13 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { NotificationDescriptor } from "../extension/notification-router.ts";
-import type { MetricRegistry } from "../observability/metric-registry.ts";
-import { appendEvent } from "../state/event-log.ts";
-import { loadRunManifestById } from "../state/state-store.ts";
-import type { TeamRunManifest } from "../state/types.ts";
-import { logInternalError } from "../utils/internal-error.ts";
+import type { NotificationDescriptor } from "../../extension/notification-router.ts";
+import type { MetricRegistry } from "../../observability/metric-registry.ts";
+import { appendEvent } from "../../state/event-log/event-log.ts";
+import { loadRunManifestById } from "../../state/stores/state-store.ts";
+import type { TeamRunManifest } from "../../state/types.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import type { ManifestCache } from "../manifest-cache.ts";
 import { DEFAULT_GRADIENT_THRESHOLDS, type GradientThresholds, type HeartbeatLevel, heartbeatAgeMs } from "./heartbeat-gradient.ts";
-import type { ManifestCache } from "./manifest-cache.ts";
 
 export interface HeartbeatWatcherRouter {
 	enqueue(notification: NotificationDescriptor): boolean;

package/src/runtime/iteration-hooks.ts

@@ -10,7 +10,7 @@ import * as path from "node:path";
 import { WINDOWS_ESSENTIAL_ENV_VARS } from "../utils/env-allowlist.ts";
 import { sanitizeEnvSecrets } from "../utils/env-filter.ts";
 import { resolveShellForScript } from "../utils/resolve-shell.ts";
-import { HeadSnapStage } from "./compact-stages/index.ts";
+import { HeadSnapStage } from "./compaction/compact-stages/index.ts";
 import { DENIED_METRIC_NAMES } from "./metric-parser.ts";
 
 /** Hook execution stage. */

package/src/runtime/{live-agent-control.ts → live-session/live-agent-control.ts}

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { TeamRunManifest } from "../state/types.ts";
-import { agentStateFile, ensureAgentStateDir } from "./crew-agent-records.ts";
+import type { TeamRunManifest } from "../../state/types.ts";
+import { agentStateFile, ensureAgentStateDir } from "../crew-agent-records.ts";
 
 export type LiveAgentControlOperation = "steer" | "follow-up" | "stop" | "resume";
 

package/src/runtime/{live-agent-manager.ts → live-session/live-agent-manager.ts}

@@ -1,8 +1,8 @@
-import type { appendEvent } from "../state/event-log.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import type { CrewAgentRecord } from "./crew-agent-runtime.ts";
+import type { appendEvent } from "../../state/event-log/event-log.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import type { CrewAgentRecord } from "../crew-agent-runtime.ts";
+import { checkProcessLiveness } from "../process-status.ts";
 import type { IrcMessage } from "./live-irc.ts";
-import { checkProcessLiveness } from "./process-status.ts";
 
 const MAX_PENDING_MESSAGES = 1000;
 

package/src/runtime/{live-session-runtime.ts → live-session/live-session-runtime.ts}

@@ -1,17 +1,41 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { AgentConfig } from "../agents/agent-config.ts";
-import { resolveToolPolicy } from "../agents/agent-config.ts";
-import type { CrewRuntimeConfig } from "../config/config.ts";
-import { loadConfig } from "../config/config.ts";
-import { DEFAULT_LIVE_SESSION } from "../config/defaults.ts";
-import { appendEvent, appendEventFireAndForget } from "../state/event-log.ts";
-import type { TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
-import { logInternalError } from "../utils/internal-error.ts";
-import { redactSecrets } from "../utils/redaction.ts";
-import type { WorkflowStep } from "../workflows/workflow-config.ts";
-import { createIrcTool } from "./custom-tools/irc-tool.ts";
-import { createSubmitResultTool } from "./custom-tools/submit-result-tool.ts";
+import type { AgentConfig } from "../../agents/agent-config.ts";
+import { resolveToolPolicy } from "../../agents/agent-config.ts";
+import type { CrewRuntimeConfig } from "../../config/config.ts";
+import { loadConfig } from "../../config/config.ts";
+import { DEFAULT_LIVE_SESSION } from "../../config/defaults.ts";
+import { appendEvent, appendEventFireAndForget } from "../../state/event-log/event-log.ts";
+import type { TeamRunManifest, TeamTaskState, UsageState } from "../../state/types.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { redactSecrets } from "../../utils/redaction.ts";
+import type { WorkflowStep } from "../../workflows/workflow-config.ts";
+import { createIrcTool } from "../custom-tools/irc-tool.ts";
+import { createSubmitResultTool } from "../custom-tools/submit-result-tool.ts";
+import { buildMcpProxyFromSession } from "../mcp-proxy.ts";
+import { buildConfiguredModelRouting } from "../model/model-fallback.ts";
+import { readEnabledModelsPatterns } from "../model/model-scope.ts";
+import { isLiveSessionRuntimeAvailable } from "../model/runtime-resolver.ts";
+import { awaitRuntimeWarmup } from "../model/runtime-warmup.ts";
+import { eventToSidechainType, sidechainOutputPath, writeSidechainEntry } from "../output/sidechain-output.ts";
+// NOTE: buildMemoryBlock is intentionally NOT imported here. The agent memory
+// block is injected via renderTaskPrompt().full (the USER prompt), which is
+// shared by both the child-pi path (no system prompt) and the live-session
+// path. Adding it to liveSystemPrompt() too duplicated the entire memory
+// block (up to 200 lines) in both the user and system prompts. Keep memory
+// in a single place: the shared user prompt. See G3 fix.
+import { createStreamingOutput, type StreamingOutputHandle } from "../output/streaming-output.ts";
+import { buildSensitivePathConstraint } from "../sensitive-paths.ts";
+import { trackTaskUsage } from "../usage-tracker.ts";
+import {
+	buildYieldReminder,
+	DEFAULT_YIELD_CONFIG,
+	extractYieldResult,
+	hasYieldInOutput,
+	isYieldEvent,
+	validateYieldData,
+	type YieldResult,
+} from "../yield-handler.ts";
 import { applyLiveAgentControlRequest, applyLiveAgentControlRequests, type LiveAgentControlCursor } from "./live-agent-control.ts";
 import {
 	disposeLiveAgentSession,
@@ -28,32 +52,6 @@ import {
 import { subscribeLiveControlRealtime } from "./live-control-realtime.ts";
 import { buildExtensionBridge } from "./live-extension-bridge.ts";
 import { collectLiveSessionHealth, formatLiveSessionDiagnostics } from "./live-session-health.ts";
-import { buildMcpProxyFromSession } from "./mcp-proxy.ts";
-import { buildConfiguredModelRouting } from "./model-fallback.ts";
-import { readEnabledModelsPatterns } from "./model-scope.ts";
-import { isLiveSessionRuntimeAvailable } from "./runtime-resolver.ts";
-import { awaitRuntimeWarmup } from "./runtime-warmup.ts";
-// prose-compressor imported for custom tool descriptions below;
-// tool description compression for SDK-managed tools awaits SDK support.
-import { buildSensitivePathConstraint } from "./sensitive-paths.ts";
-import { eventToSidechainType, sidechainOutputPath, writeSidechainEntry } from "./sidechain-output.ts";
-// NOTE: buildMemoryBlock is intentionally NOT imported here. The agent memory
-// block is injected via renderTaskPrompt().full (the USER prompt), which is
-// shared by both the child-pi path (no system prompt) and the live-session
-// path. Adding it to liveSystemPrompt() too duplicated the entire memory
-// block (up to 200 lines) in both the user and system prompts. Keep memory
-// in a single place: the shared user prompt. See G3 fix.
-import { createStreamingOutput, type StreamingOutputHandle } from "./streaming-output.ts";
-import { trackTaskUsage } from "./usage-tracker.ts";
-import {
-	buildYieldReminder,
-	DEFAULT_YIELD_CONFIG,
-	extractYieldResult,
-	hasYieldInOutput,
-	isYieldEvent,
-	validateYieldData,
-	type YieldResult,
-} from "./yield-handler.ts";
 
 /**
  * Module-scoped latch for the optional peer dependency import. When N
@@ -537,9 +535,9 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 			},
 		};
 		const mockSession = {
-			steer: async () => {},
-			prompt: async () => {},
-			abort: async () => {},
+			steer: async () => undefined,
+			prompt: async () => undefined,
+			abort: async () => undefined,
 		};
 		registerLiveAgent(
 			{

package/src/runtime/manifest-cache.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { DEFAULT_CACHE, DEFAULT_PATHS } from "../config/defaults.ts";
-import { activeRunEntries } from "../state/active-run-registry.ts";
+import { activeRunEntries } from "../state/stores/active-run-registry.ts";
 import type { TeamRunManifest } from "../state/types.ts";
 import { closeWatcher, watchWithErrorHandler } from "../utils/fs-watch.ts";
 import { findRepoRoot, projectCrewRoot, userCrewRoot } from "../utils/paths.ts";

package/src/runtime/{model-fallback.ts → model/model-fallback.ts}

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { errors } from "../errors.ts";
+import { errors } from "../../errors.ts";
 import { fuzzyResolveModelId } from "./model-resolver.ts";
 import { checkModelScope } from "./model-scope.ts";
 

package/src/runtime/{pi-args.ts → model/pi-args.ts}

@@ -1,10 +1,10 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import type { AgentConfig } from "../agents/agent-config.ts";
-import { resolveToolPolicy } from "../agents/agent-config.ts";
-import { atomicWriteFile } from "../state/atomic-write.ts";
-import { packageRoot, userPiRoot } from "../utils/paths.ts";
+import type { AgentConfig } from "../../agents/agent-config.ts";
+import { resolveToolPolicy } from "../../agents/agent-config.ts";
+import { atomicWriteFile } from "../../state/atomic-write.ts";
+import { packageRoot, userPiRoot } from "../../utils/paths.ts";
 
 const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
 // FIX (2026-07-02): use packageRoot() instead of import.meta.url-relative path.
@@ -308,7 +308,22 @@ export function buildPiWorkerArgs(input: BuildPiWorkerArgsInput): BuildPiWorkerA
 		// would be nice but this path is sync and minimal — keeping parity
 		// with the rest of the agent loader's best-effort semantics).
 		const excluded = new Set((input.agent.excludeExtensions ?? []).map((name) => path.basename(name).toLowerCase()));
-		const allowed = input.agent.extensions.filter((ext) => !excluded.has(path.basename(ext).toLowerCase()));
+		let allowed = input.agent.extensions.filter((ext) => !excluded.has(path.basename(ext).toLowerCase()));
+		// SEC-1: Defense-in-depth — deny untrusted project-sourced extensions
+		// unless explicitly trusted via PI_CREW_TRUST_PROJECT_AGENT_EXTENSIONS=1.
+		// Even if parseAgentFile missed the strip (e.g., agent was constructed
+		// at runtime), buildPiWorkerArgs must never emit --extension
+		// <attacker-path> for a project / project-pi agent. Both `project`
+		// (.crew/agents/) and `project-pi` (.pi/agents/) are repo-adjacent /
+		// untrusted sources. Only the trusted PROMPT_RUNTIME_EXTENSION_PATH is
+		// allowed through.
+		const extEnv = input.env ?? process.env;
+		if (
+			(input.agent.source === "project" || input.agent.source === "project-pi") &&
+			extEnv.PI_CREW_TRUST_PROJECT_AGENT_EXTENSIONS !== "1"
+		) {
+			allowed = allowed.filter((ext) => path.resolve(ext) === path.resolve(PROMPT_RUNTIME_EXTENSION_PATH));
+		}
 		for (const extension of [PROMPT_RUNTIME_EXTENSION_PATH, ...allowed]) args.push("--extension", extension);
 	} else {
 		args.push("--extension", PROMPT_RUNTIME_EXTENSION_PATH);

package/src/runtime/model/provider-extensions.ts

@@ -0,0 +1,116 @@
+/**
+ * provider-extensions.ts — discover Pi provider extensions automatically.
+ *
+ * WHY: pi-crew spawns child-pi workers with `--no-extensions` (security
+ * posture: prevent untrusted user extensions from auto-loading). But that
+ * made extension-registered PROVIDERS (e.g. pi-commandcode-provider, installed
+ * via `pi install npm:...`) unresolvable inside subagents — every model from
+ * those providers fell back and died with 429s. Pi DOES load explicitly-passed
+ * `--extension <path>` even after `--no-extensions`, so the fix is to discover
+ * the user's installed provider packages and pass them explicitly.
+ *
+ * This module reads Pi's own package registry (`~/.pi/agent/settings.json`
+ * `packages` field + the npm install dir) and resolves each package to its
+ * extension entry point. That's the SANCTIONED channel — the user explicitly
+ * installed these via `pi install`, so they are trusted (unlike arbitrary
+ * `~/.pi/agent/extensions/*.ts` which may be tool extensions with deps that
+ * fail in child contexts).
+ *
+ * SECURITY: only packages the USER installed are auto-loaded. Project-local
+ * packages and `.pi/agent/extensions/*.ts` are NOT auto-discovered here (the
+ * existing SEC-1 gate in discover-agents.ts still strips project agents).
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { userPiRoot } from "../../utils/paths.ts";
+
+export interface DiscoveredProviderExtension {
+	/** Package specifier as written in settings.json packages (e.g. "npm:pi-commandcode-provider"). */
+	spec: string;
+	/** Resolved absolute path to the extension entry point. */
+	entryPath: string;
+}
+
+/**
+ * Resolve the extension entry point for an installed Pi package.
+ * Order: package.json `pi.extensions` (array) → `index.ts` → `index.mjs` → `index.js` → `src/index.ts`.
+ * Returns undefined when the package has no resolvable entry point.
+ */
+function resolvePackageEntry(pkgDir: string): string | undefined {
+	const pkgJsonPath = path.join(pkgDir, "package.json");
+	if (fs.existsSync(pkgJsonPath)) {
+		try {
+			const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8")) as {
+				pi?: { extensions?: string[] };
+				type?: string;
+				main?: string;
+			};
+			const piExts = pkg.pi?.extensions;
+			if (Array.isArray(piExts) && piExts.length > 0) {
+				for (const rel of piExts) {
+					const abs = path.resolve(pkgDir, rel);
+					if (fs.existsSync(abs)) return abs;
+				}
+			}
+			// Fall back to `main` when it points at a loadable entry (rare for extensions).
+			if (pkg.main?.endsWith(".ts")) {
+				const abs = path.resolve(pkgDir, pkg.main);
+				if (fs.existsSync(abs)) return abs;
+			}
+		} catch {
+			/* malformed package.json — fall through to filename probes */
+		}
+	}
+	for (const name of ["index.ts", "index.mjs", "index.js", "src/index.ts"]) {
+		const abs = path.join(pkgDir, name);
+		if (fs.existsSync(abs)) return abs;
+	}
+	return undefined;
+}
+
+/**
+ * Discover provider extension entry points from Pi's installed package registry.
+ * Reads `~/.pi/agent/settings.json` → `packages` (npm: specs only — local
+ * relative paths are the pi-crew extension itself and other local work, which
+ * children already handle) and resolves each against `~/.pi/agent/npm/node_modules/`.
+ *
+ * Non-npm specs (local paths, git URLs) are skipped: they are not part of the
+ * npm registry dir and resolving them is outside this module's scope.
+ */
+export function discoverProviderExtensions(settingsPath?: string): DiscoveredProviderExtension[] {
+	const root = userPiRoot();
+	const settingsFile = settingsPath ?? path.join(root, "settings.json");
+	const out: DiscoveredProviderExtension[] = [];
+	if (!fs.existsSync(settingsFile)) return out;
+	let settings: { packages?: string[] };
+	try {
+		settings = JSON.parse(fs.readFileSync(settingsFile, "utf8")) as { packages?: string[] };
+	} catch {
+		return out;
+	}
+	// The npm registry dir lives beside settings.json (same agent root). When a
+	// custom settingsPath is supplied (tests), derive npmBase from IT so the
+	// package resolution stays consistent with the settings file being read.
+	const baseDir = path.dirname(settingsFile);
+	const npmBase = path.join(baseDir, "npm", "node_modules");
+	for (const spec of settings.packages ?? []) {
+		if (typeof spec !== "string") continue;
+		// Only npm: specs resolve into the npm registry dir. Skip local path
+		// packages (e.g. "../../source/my_pi/pi-crew") and git specs.
+		if (!spec.startsWith("npm:")) continue;
+		const pkgName = spec.slice(4);
+		// Scoped packages: "@scope/name" → "@scope/name"; plain: "name".
+		const pkgDir = path.join(npmBase, pkgName);
+		if (!fs.existsSync(pkgDir)) continue;
+		const entryPath = resolvePackageEntry(pkgDir);
+		if (entryPath) out.push({ spec, entryPath });
+	}
+	return out;
+}
+
+/**
+ * Convenience: absolute entry paths of all discovered provider extensions.
+ */
+export function discoverProviderExtensionPaths(settingsPath?: string): string[] {
+	return discoverProviderExtensions(settingsPath).map((e) => e.entryPath);
+}