taskplane 0.29.0 → 0.29.2

package/extensions/taskplane/diagnostics.ts

@@ -52,7 +52,14 @@ export interface SessionTokenCounts {
  * | `session_vanished`   | Session disappeared without exit summary             |
  * | `stall_timeout`      | No STATUS.md progress for stall_timeout minutes      |
  * | `user_killed`        | User manually killed the session (e.g., forced process kill) |
+ * | `spawn_failure`      | Worker process never spawned (e.g., Pi CLI not findable, worktree provisioning) |
  * | `unknown`            | Could not determine cause                            |
+ *
+ * Note: `spawn_failure` (TP-190, #561) is set BEFORE any agent process exists —
+ * it is produced synchronously when `spawnAgent()` throws (resolvePiCliPath
+ * miss, file-system error, etc.). It is intentionally NOT in
+ * `TIER0_RETRYABLE_CLASSIFICATIONS` because spawn-stage failures are never
+ * transient; retrying without operator intervention only burns budget.
  */
 export type ExitClassification =
 	| "completed"
@@ -64,6 +71,7 @@ export type ExitClassification =
 	| "session_vanished"
 	| "stall_timeout"
 	| "user_killed"
+	| "spawn_failure"
 	| "unknown";
 
 /**
@@ -79,6 +87,7 @@ export const EXIT_CLASSIFICATIONS: readonly ExitClassification[] = [
 	"session_vanished",
 	"stall_timeout",
 	"user_killed",
+	"spawn_failure",
 	"unknown",
 ] as const;
 

package/extensions/taskplane/engine.ts

@@ -68,6 +68,114 @@ function emitTier0Escalation(
 /** Zero-token sentinel used for task/wave/batch aggregation. */
 const ZERO_TOKENS: TokenCounts = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, costUsd: 0 };
 
+/**
+ * TP-190 (#561): Determine whether a wave's failures are entirely
+ * Runtime V2 spawn-stage failures.
+ *
+ * Returns `true` only when:
+ *   - At least one task failed (`failedTaskIds.length > 0`)
+ *   - No task succeeded — checked via BOTH the wave's projected
+ *     `succeededTaskIds` (terminal task-level completion) AND a scan of
+ *     `laneResults[].tasks[]` for any per-task outcome with
+ *     `status === "succeeded"` (catches non-terminal segment successes
+ *     on multi-segment tasks that schedule a continuation round and
+ *     therefore don't appear in `succeededTaskIds`)
+ *   - Every failed outcome carries
+ *     `exitDiagnostic.classification === "spawn_failure"`
+ *
+ * The engine uses the result to transition `batchState.phase` to
+ * `"failed"` (not `"executing"` and not `"paused"`) so `orch_status()`
+ * and the dashboard surface an actionable answer for the operator.
+ * Spawn-stage errors (Pi CLI not findable, worktree provisioning
+ * failure, branch collision) are never transient — they require an
+ * external fix before re-running, so `"paused"` would be misleading.
+ *
+ * **Sage post-mortem note (multi-segment edge case, post-PR-#566):** the
+ * earlier version of this function checked only `succeededTaskIds.length
+ * !== 0` to gate the all-failed verdict. That field is the *projected*
+ * terminal-completion set: it's populated only when a task reaches its
+ * final segment. A wave that has a multi-segment task succeed on segment
+ * 1 (with a continuation segment in a later round) would have an empty
+ * `succeededTaskIds` even though work demonstrably succeeded. Combined
+ * with a single-segment spawn-failure on a different task, the wave
+ * would falsely trip the all-spawn-failed verdict. The added
+ * `laneResults` scan closes this gap by inspecting raw per-task outcome
+ * status before terminal projection.
+ *
+ * Pure function — exported for unit testing alongside the engine's
+ * post-wave handling logic.
+ *
+ * @since TP-190 (#561)
+ */
+export function isAllLanesSpawnFailedWave(
+	waveResult: {
+		failedTaskIds: string[];
+		succeededTaskIds: string[];
+		/**
+		 * Optional per-lane outcomes. When provided, the function additionally
+		 * checks whether ANY task outcome carried `status === "succeeded"`,
+		 * which covers non-terminal segment successes that don't appear in the
+		 * projected `succeededTaskIds`. Optional for backward compatibility
+		 * with the v0.29.0 callers and the existing TP-190 unit tests; the
+		 * production call site (engine.ts post-wave) always passes the full
+		 * `WaveExecutionResult` and gets the stricter check.
+		 */
+		laneResults?: ReadonlyArray<{ tasks: ReadonlyArray<{ status: string }> }>;
+	},
+	allTaskOutcomes: LaneTaskOutcome[],
+): boolean {
+	if (waveResult.failedTaskIds.length === 0) return false;
+	if (waveResult.succeededTaskIds.length !== 0) return false;
+	// TP-190 (#561) sage post-mortem: scan per-lane outcomes for any
+	// `status === "succeeded"`. This catches non-terminal segment successes
+	// that don't appear in `succeededTaskIds` (the latter is the terminal
+	// projection populated only when a multi-segment task reaches its final
+	// segment).
+	if (waveResult.laneResults) {
+		for (const laneResult of waveResult.laneResults) {
+			for (const taskOutcome of laneResult.tasks) {
+				if (taskOutcome.status === "succeeded") return false;
+			}
+		}
+	}
+	return waveResult.failedTaskIds.every((failedId) => {
+		const outcome = allTaskOutcomes.find((o) => o.taskId === failedId);
+		return outcome?.exitDiagnostic?.classification === "spawn_failure";
+	});
+}
+
+/**
+ * TP-190 (#561): Build the spawn-failure-specific extras layered onto a
+ * `task-failure` supervisor alert when the underlying outcome was a
+ * spawn-stage failure.
+ *
+ * Returns:
+ *   - `exitCategory`: the structured `ExitClassification` that the
+ *     supervisor playbook can branch on (e.g.,
+ *     `"spawn_failure"` → escalate immediately rather than retry).
+ *   - `summaryLine`: an extra `  Spawn failure: … escalate immediately…`
+ *     line for human-readable display, blank string when the outcome
+ *     is not a spawn failure (so the existing summary template renders
+ *     unchanged for non-spawn cases).
+ *
+ * Pure function — exported for unit testing alongside the alert-emission
+ * logic in `executeOrchBatch` and `resumeOrchBatch`. Both call sites
+ * read from `outcome.exitDiagnostic?.classification` so the helper takes
+ * the optional classification directly.
+ *
+ * @since TP-190 (#561)
+ */
+export function buildSpawnFailureAlertExtras(
+	outcome: { exitDiagnostic?: { classification?: string } | undefined } | undefined,
+): { exitCategory: import("./diagnostics.ts").ExitClassification | undefined; summaryLine: string } {
+	const raw = outcome?.exitDiagnostic?.classification;
+	const exitCategory = raw as import("./diagnostics.ts").ExitClassification | undefined;
+	const summaryLine = raw === "spawn_failure"
+		? `  Spawn failure: worker process never started — escalate immediately (do not retry)\n`
+		: "";
+	return { exitCategory, summaryLine };
+}
+
 /** Map embedded outcome telemetry to the batch-history TokenCounts shape. */
 export function taskTokensFromOutcomeTelemetry(outcome: LaneTaskOutcome): TokenCounts {
 	const telemetry = outcome.telemetry;
@@ -1282,6 +1390,20 @@ async function attemptWorkerCrashRetry(
 			continue;
 		}
 
+		// TP-190 (#561): Defense-in-depth — spawn-stage failures (Pi CLI not
+		// findable, worktree provisioning failure, branch collision) are NEVER
+		// transient. Retrying without operator intervention only burns the
+		// retry budget and delays the supervisor alert. The generic
+		// `TIER0_RETRYABLE_CLASSIFICATIONS.has()` gate below also catches this
+		// (spawn_failure is not in the set), but the explicit early-return
+		// here gives operators a clearer log message at the gate site.
+		if (classification === "spawn_failure") {
+			execLog("batch", batchState.batchId,
+				`tier0: task ${taskId} spawn_failure — operator action required, NOT auto-retrying (TP-190)`,
+			);
+			continue;
+		}
+
 		// Check if retryable
 		if (!TIER0_RETRYABLE_CLASSIFICATIONS.has(classification)) {
 			execLog("batch", batchState.batchId,
@@ -3084,11 +3206,17 @@ export async function executeOrchBatch(
 			const frontierSummary = segmentFrontier
 				? `  Segment frontier: ${segmentFrontier.terminalSegments}/${segmentFrontier.totalSegments} terminal\n`
 				: "";
+			// TP-190 (#561): Surface the structured exit category so the supervisor
+			// playbook can branch deterministically. In particular,
+			// `exitCategory === "spawn_failure"` signals an immediate-escalation
+			// failure (not a retry candidate) — the worker process never spawned.
+			const { exitCategory, summaryLine: spawnFailureLine } = buildSpawnFailureAlertExtras(outcome);
 			emitAlert({
 				category: "task-failure",
 				summary:
 					`⚠️ Task failure: ${taskId}\n` +
 					`  Exit reason: ${exitReason}\n` +
+					spawnFailureLine +
 					segmentSummary +
 					frontierSummary +
 					`  Lane: ${laneForTask?.laneId ?? "unknown"} (lane ${laneForTask?.laneNumber ?? "?"})\n` +
@@ -3108,6 +3236,7 @@ export async function executeOrchBatch(
 					laneNumber: laneForTask?.laneNumber,
 					waveIndex: waveIdx,
 					exitReason,
+					exitCategory,
 					partialProgress: hasPartialProgress,
 					batchProgress: buildBatchProgressSnapshot(batchState),
 				},
@@ -3137,6 +3266,34 @@ export async function executeOrchBatch(
 			}
 		}
 
+		// ── TP-190 (#561): All-lane spawn-failure phase transition ──
+		// When every task in this wave failed AND every failure is a
+		// `spawn_failure` (worker process never started), the operator cannot
+		// recover without changing something external (Pi CLI install, file
+		// permissions, branch state). Transition `phase` to `"failed"` so
+		// `orch_status()` and the dashboard surface an actionable answer
+		// (`failed`) instead of leaving the operator with `executing` while
+		// every lane is dead. We use `"failed"` rather than `"paused"` (per
+		// PROMPT design): `paused` implies an operator-flippable resume,
+		// which is wrong here — spawn failures require an external fix first.
+		// `isAllLanesSpawnFailedWave` is exported as a pure helper for unit
+		// testing.
+		const allFailedAreSpawnFailures = isAllLanesSpawnFailedWave(waveResult, allTaskOutcomes);
+		if (allFailedAreSpawnFailures) {
+			batchState.phase = "failed";
+			execLog("batch", batchState.batchId,
+				`phase → failed: every lane in wave ${waveIdx + 1} hit spawn_failure (TP-190 #561)`,
+				{ failedTasks: waveResult.failedTaskIds.join(",") },
+			);
+			onNotify(
+				ORCH_MESSAGES.orchBatchFailed(batchState.batchId, `all lanes in wave ${waveIdx + 1} failed to spawn (Runtime V2 spawn-failure — see task-failure alerts above)`),
+				"error",
+			);
+			persistRuntimeState("wave-spawn-failure", batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discoveryRef, stateRoot);
+			emitTerminalEvent(`All-lane spawn failure at wave ${waveIdx + 1}`);
+			break;
+		}
+
 		// ── TS-009: Persist state after wave execution ──
 		persistRuntimeState("wave-execution-complete", batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discoveryRef, stateRoot);
 

package/extensions/taskplane/execution.ts

@@ -8,9 +8,10 @@ import { join, dirname, basename, resolve, relative, delimiter as pathDelimiter
 import { userInfo } from "os";
 
 import { DONE_GRACE_MS, EXECUTION_POLL_INTERVAL_MS, ExecutionError, SESSION_SPAWN_RETRY_MAX } from "./types.ts";
-import type { AllocatedLane, AllocatedTask, DependencyGraph, LaneExecutionResult, LaneMonitorSnapshot, LaneTaskOutcome, LaneTaskStatus, MonitorState, MtimeTracker, OrchestratorConfig, ParsedTask, TaskMonitorSnapshot, WaveExecutionResult, WorkspaceConfig, ExecutionUnit, PacketPaths, RuntimeAgentId, RuntimeAgentRole, SupervisorAlertCallback } from "./types.ts";
+import type { AllocatedLane, AllocatedTask, DependencyGraph, LaneExecutionResult, LaneMonitorSnapshot, LaneTaskOutcome, LaneTaskStatus, MonitorState, MtimeTracker, OrchestratorConfig, ParsedTask, TaskMonitorSnapshot, WaveExecutionResult, WorkspaceConfig, ExecutionUnit, PacketPaths, RuntimeAgentId, RuntimeAgentRole, RuntimeLaneSnapshot, SupervisorAlertCallback } from "./types.ts";
 import { resolvePacketPaths, buildRuntimeAgentId } from "./types.ts";
-import { readRegistrySnapshot, readLaneSnapshot, isTerminalStatus, isProcessAlive, detectOrphans, markOrphansCrashed, buildRegistrySnapshot, writeRegistrySnapshot } from "./process-registry.ts";
+import type { TaskExitDiagnostic } from "./diagnostics.ts";
+import { readRegistrySnapshot, readLaneSnapshot, isTerminalStatus, isProcessAlive, detectOrphans, markOrphansCrashed, buildRegistrySnapshot, writeRegistrySnapshot, writeLaneSnapshot } from "./process-registry.ts";
 import { allocateLanes } from "./waves.ts";
 import { resolveOperatorId } from "./naming.ts";
 import { runGit, runGitWithEnv } from "./git.ts";
@@ -829,18 +830,31 @@ export async function resolveTaskMonitorState(
 			// Assume alive initially, but if stale for >30s consult the registry
 			// to avoid indefinite false "running" if the lane-runner died.
 			const staleMs = snap?.updatedAt ? (now - snap.updatedAt) : 0;
+			const trackerAgeMs = now - tracker.firstObservedAt;
 			if (staleMs > 30_000) {
 				// Snapshot hasn't been updated for 30s+ — check registry as fallback.
 				// But also check if the tracker just started (firstObservedAt within
 				// last 60s) — wave transitions can leave stale snapshots from the
 				// prior wave/task while the new worker is still spawning.
-				const trackerAgeMs = now - tracker.firstObservedAt;
 				if (trackerAgeMs < 60_000) {
 					// New task, stale snapshot — give the worker startup grace period
 					sessionAlive = true;
 				} else {
 					sessionAlive = isV2AgentAlive(sessionName, runtimeBackend, v2Context?.laneNumber);
 				}
+			} else if (snap == null && trackerAgeMs >= 60_000) {
+				// TP-190 (#561 sage post-mortem): when NO snapshot exists at all
+				// (not even stale) and the tracker has been observing this task
+				// for >= 60s, fall back to the registry liveness check. Without
+				// this branch, a snapshot-write failure in the spawn-failure catch
+				// (disk full, permission error, transient I/O hiccup) leaves
+				// `snap == null` AND `staleMs == 0`, which previously hit the
+				// unconditional-alive default below — reintroducing the same
+				// monitor hang the spawn-failure catch was supposed to fix.
+				// 60s tracker-age threshold matches the existing startup-grace
+				// boundary so we don't false-fail a slow-starting worker that
+				// hasn't yet written its first snapshot.
+				sessionAlive = isV2AgentAlive(sessionName, runtimeBackend, v2Context?.laneNumber);
 			} else {
 				sessionAlive = true;
 			}
@@ -2722,17 +2736,90 @@ export async function executeLaneV2(
 		} catch (err: unknown) {
 			const errMsg = err instanceof Error ? err.message : String(err);
 			execLog(laneId, task.taskId, `Runtime V2 execution error: ${errMsg}`);
+
+			// TP-190 (#561): Spawn-stage failures (Pi CLI not findable, worktree
+			// provisioning failure, etc.) reach this catch synchronously —
+			// `spawnAgent()` calls `resolvePiCliPath()` and other resolvers that
+			// throw before any process is registered. Tag the outcome with the
+			// `spawn_failure` ExitClassification so:
+			//   1. The retry classifier (TIER0_RETRYABLE_CLASSIFICATIONS) excludes
+			//      it deterministically — spawn errors are never transient.
+			//   2. The supervisor `task-failure` IPC alert can carry
+			//      `context.exitCategory = "spawn_failure"` so the playbook can
+			//      escalate immediately rather than retrying.
+			//   3. The engine's post-wave logic can transition `phase` to
+			//      `"failed"` when every lane in a wave spawn-failed.
+			const spawnExitDiagnostic: TaskExitDiagnostic = {
+				classification: "spawn_failure",
+				exitCode: null,
+				errorMessage: errMsg,
+				tokensUsed: null,
+				contextPct: null,
+				partialProgressCommits: 0,
+				partialProgressBranch: null,
+				durationSec: 0,
+				lastKnownStep: null,
+				lastKnownCheckbox: null,
+				repoId: lane.repoId ?? "default",
+			};
+			const workerAgentId = buildRuntimeAgentId(agentIdPrefix, lane.laneNumber, "worker");
 			outcomes.push({
 				taskId: task.taskId,
 				status: "failed",
 				segmentId: taskSegmentId,
 				startTime: Date.now(),
 				endTime: Date.now(),
-				exitReason: `Runtime V2 execution error: ${errMsg}`,
-				sessionName: buildRuntimeAgentId(agentIdPrefix, lane.laneNumber, "worker"),
+				exitReason: `spawn failure: ${errMsg}`,
+				sessionName: workerAgentId,
 				doneFileFound: false,
 				laneNumber: lane.laneNumber,
+				exitDiagnostic: spawnExitDiagnostic,
 			});
+
+			// TP-190 (#561): Write a synthetic terminal lane snapshot so the
+			// monitor (`monitorLanes` → `resolveTaskMonitorState`) reads
+			// `snap.taskId === taskId` AND `snap.status === "failed"`, which sets
+			// `sessionAlive = false` and triggers Priority 3 ("Session exited
+			// without .DONE → failed"). Without this, the monitor's
+			// `snap == null` startup-grace branch keeps `sessionAlive = true`
+			// indefinitely and `executeWave` blocks forever on `await
+			// monitorPromise`. Use the full `RuntimeLaneSnapshot` shape so
+			// dashboard consumers stay schema-consistent.
+			try {
+				const spawnFailureSnapshot: RuntimeLaneSnapshot = {
+					batchId,
+					laneNumber: lane.laneNumber,
+					laneId: `lane-${lane.laneNumber}`,
+					repoId: lane.repoId ?? "default",
+					taskId: task.taskId,
+					segmentId: taskSegmentId,
+					status: "failed",
+					worker: {
+						agentId: workerAgentId,
+						status: "crashed",
+						elapsedMs: 0,
+						toolCalls: 0,
+						contextPct: 0,
+						costUsd: 0,
+						lastTool: "",
+						inputTokens: 0,
+						outputTokens: 0,
+						cacheReadTokens: 0,
+						cacheWriteTokens: 0,
+					},
+					reviewer: null,
+					progress: null,
+					updatedAt: Date.now(),
+				};
+				writeLaneSnapshot(stateRoot, batchId, lane.laneNumber, spawnFailureSnapshot as unknown as Record<string, unknown>);
+			} catch (snapErr) {
+				// Best effort — if the snapshot write fails, the monitor's
+				// 30s-staleness fallback (snap with old updatedAt) eventually
+				// kicks in via the registry liveness check. Log so this is
+				// visible in operator diagnostics, but do NOT throw.
+				execLog(laneId, task.taskId, `spawn-failure snapshot write failed (non-fatal): ${snapErr instanceof Error ? snapErr.message : String(snapErr)}`);
+			}
+
 			shouldSkipRemaining = true;
 		}
 	}

package/extensions/taskplane/resume.ts

@@ -7,7 +7,7 @@ import { join } from "path";
 
 import { assembleDiagnosticInput, emitDiagnosticReports } from "./diagnostic-reports.ts";
 import { runDiscovery } from "./discovery.ts";
-import { executeOrchBatch, resolveDisplayWaveNumber } from "./engine.ts";
+import { executeOrchBatch, resolveDisplayWaveNumber, buildSpawnFailureAlertExtras } from "./engine.ts";
 import { buildReviewerEnv, buildWorkerEnv, buildWorkerExcludeEnv, computeTransitiveDependents, execLog, executeLaneV2, executeWave, resolveCanonicalTaskPaths } from "./execution.ts";
 import type { MonitorUpdateCallback, RuntimeBackend } from "./execution.ts";
 import { selectRuntimeBackend } from "./engine.ts";
@@ -2160,11 +2160,17 @@ export async function resumeOrchBatch(
 			const frontierSummary = segmentFrontier
 				? `  Segment frontier: ${segmentFrontier.terminalSegments}/${segmentFrontier.totalSegments} terminal\n`
 				: "";
+			// TP-190 (#561): Mirror engine.ts emission — propagate the structured
+			// exit category so /orch-resume task-failure alerts route through the
+			// same supervisor playbook branches as /orch. Shared helper enforces
+			// payload parity between the two emission sites.
+			const { exitCategory, summaryLine: spawnFailureLine } = buildSpawnFailureAlertExtras(outcome);
 			emitAlert({
 				category: "task-failure",
 				summary:
 					`⚠️ Task failure: ${taskId}\n` +
 					`  Exit reason: ${exitReason}\n` +
+					spawnFailureLine +
 					segmentSummary +
 					frontierSummary +
 					`  Lane: ${laneForTask?.laneId ?? "unknown"} (lane ${laneForTask?.laneNumber ?? "?"})\n` +
@@ -2184,6 +2190,7 @@ export async function resumeOrchBatch(
 					laneNumber: laneForTask?.laneNumber,
 					waveIndex: waveIdx,
 					exitReason,
+					exitCategory,
 					partialProgress: hasPartialProgress,
 					batchProgress: buildBatchProgressSnapshot(batchState),
 				},

package/extensions/taskplane/types.ts

@@ -1810,8 +1810,13 @@ export type Tier0RecoveryPattern =
  *
  * These are transient failures where re-running the task has a reasonable
  * chance of success. Classifications NOT in this set (e.g., user_killed,
- * stall_timeout, context_overflow) indicate persistent problems that
- * won't be fixed by retrying.
+ * stall_timeout, context_overflow, spawn_failure) indicate persistent
+ * problems that won't be fixed by retrying.
+ *
+ * **TP-190 (#561):** `spawn_failure` is intentionally excluded — spawn-stage
+ * errors (Pi CLI not findable, worktree provisioning failure, branch
+ * collision) are never transient and require operator action. Retrying
+ * silently would just burn the retry budget and delay the alert.
  *
  * @since TP-039
  */
@@ -2132,6 +2137,25 @@ export interface SupervisorAlertContext {
 	waveIndex?: number;
 	/** Exit reason string (for task-failure alerts) */
 	exitReason?: string;
+	/**
+	 * Structured exit category for task-failure alerts.
+	 *
+	 * Mirrors `LaneTaskOutcome.exitDiagnostic.classification` for IPC
+	 * consumption by the supervisor. Optional for backward compatibility
+	 * — absent when the engine produces a task-failure alert without
+	 * structured diagnostic data.
+	 *
+	 * Notable values consumed by the supervisor playbook:
+	 * - `"spawn_failure"` (TP-190, #561): worker process never spawned
+	 *   (Pi CLI not findable, worktree provisioning error, etc.). Never
+	 *   transient — the playbook MUST escalate immediately rather than
+	 *   retry. When the post-wave phase-transition logic detects an
+	 *   all-spawn-failed wave it also flips `batchState.phase` to
+	 *   `"failed"`; that transition is independent of this alert.
+	 *
+	 * @since TP-190 (#561)
+	 */
+	exitCategory?: ExitClassification;
 	/** Segment frontier snapshot for task-failure diagnosis */
 	segmentFrontier?: SupervisorSegmentFrontierSnapshot;
 	/** Agent ID (for agent-message alerts) */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskplane",
-  "version": "0.29.0",
+  "version": "0.29.2",
   "description": "AI agent orchestration for pi — parallel task execution with checkpoint discipline",
   "keywords": [
     "pi-package",
@@ -35,11 +35,22 @@
     "templates/"
   ],
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-tui": "*",
-    "@mariozechner/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "@earendil-works/pi-ai": "*",
     "@sinclair/typebox": "*"
   },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    },
+    "@earendil-works/pi-tui": {
+      "optional": true
+    },
+    "@earendil-works/pi-ai": {
+      "optional": true
+    }
+  },
   "dependencies": {
     "jiti": "^2.6.1",
     "yaml": "^2.4.0"