pi-crew 0.6.4 → 0.7.2

package/CHANGELOG.md

@@ -1,5 +1,67 @@
 # Changelog
 
+## [0.7.2] — Fix: Knowledge Injection into Workers + HITL for All Workflows (2026-06-15)
+
+### Bug Fixes
+
+- **Knowledge injection into crew workers (O4)** — crew workers are spawned with `--no-extensions` and only load `prompt-runtime.ts`; they do **not** load the pi-crew extension. So the `before_agent_start` hook in `knowledge-injection.ts` never fired for workers — `.crew/knowledge.md` was invisible to every crew worker. **Fix**: inject `buildKnowledgeFragment(task.cwd)` directly into `renderTaskPrompt()` in `prompt-builder.ts` (where all worker context is assembled). The main session still gets knowledge via the hook; workers now get it via the prompt path.
+
+  **Live-verified**: all 3 workers (explorer, executor, verifier) in a fast-fix run confirmed seeing the knowledge section verbatim (`"Use TABS for indentation"`, `"Tests run via npm test"`).
+
+- **Plan-level HITL for all workflows (T1.2)** — the post-batch approval re-check in the team-runner main loop only checked `hasPendingMutatingAdaptiveTask(tasks)` (adaptive/implementation workflows only). The boundary detector `hasPendingMutatingTaskAtBoundary(tasks)` was added to the initial build but **not** to the loop's re-check. So for non-adaptive workflows (`default`, `fast-fix`), the approval gate never fired after read-only tasks completed. **Fix**: add `hasPendingMutatingTaskAtBoundary(tasks)` to the loop's post-batch re-check (line 835), matching the initial-build logic.
+
+  **Verified** via 6 new unit tests + full flow trace. When `runtime.requirePlanApproval: true`, the run now blocks at the plan→execute boundary (`status: blocked`, "Plan approval required") until approved via `team api op=approve-plan`.
+
+## [0.7.1] — Fix: Auto-Continue After Compaction (2026-06-15)
+
+### Bug Fix
+
+- **`a??`** — **Compaction resilience actually works now.** The v0.7.0 fix (O10) only *appended a resume-directive entry* after compaction, but appending an entry does **not trigger an agent turn** — the session still waited for user input, so the user still had to type "continue". The real root cause: Pi's threshold auto-compaction (`_runAutoCompaction` reason=`threshold` willRetry=`false`) returns `this.agent.hasQueuedMessages()`, which is `false` when nothing is queued → the agent loop ends → Pi waits for input (documented: "NO auto-retry, user continues manually").
+
+  **Fix**: after `session_compact` fires, call `pi.sendUserMessage(continuationPrompt)`. Per Pi's API, `sendUserMessage` *always triggers a turn*. The agent automatically runs a new turn, sees the resume directive, calls `team status`, and continues the in-flight crew task — **zero manual intervention**.
+
+  - `buildContinuationPrompt()`: action-oriented prompt ("Context was compacted while crew tasks were in-flight. Continue the work — do not wait for me.")
+  - `triggerContinuation(pi, ctx, runs)`: fire-and-forget `sendUserMessage`, best-effort error handling
+  - Wired in both the reactive path (`session_compact` handler) and proactive path (`startCompact.onComplete`)
+  - Only fires when in-flight crew runs exist; non-crew compaction unaffected
+  - 6 new unit tests
+
+## [0.7.0] — Long-Term Roadmap: Compaction Resilience, Cost Visibility, Trust Trinity (2026-06-15)
+
+This release implements Phase 0 + Phase 1 of the pi-crew long-term roadmap (a 10-round research synthesis), plus the single-agent cliff hedge. The organizing principle: **build trust and cliff-resilience, stay lean, delete before adding.**
+
+### Highlights
+
+- **🛡️ Compaction resilience (O10)** — the #1 user pain ("after auto-compact, the task stops midway") is fixed. pi-crew now detects in-flight runs, injects an explicit resume directive into the compaction summary, and re-attaches after compaction. Tasks survive context compaction.
+- **💰 Cost visibility (O1)** — `team summary <runId>` now shows a full cost report with per-role attribution and token breakdown. Multi-agent's #1 barrier is cost; now it's visible.
+- **✋ Plan-level HITL for any workflow (O5)** — plan approval was locked to the `implementation` workflow; now any workflow honors `config.runtime.requirePlanApproval`, gating at the read-only→mutating (plan→execute) boundary.
+- **🧠 Cross-run memory (O4)** — `.crew/knowledge.md` is auto-read and injected into every agent's system prompt. pi-crew "gets better the longer you use it." Radically downsized (~80 LOC) replacement for the deleted MemoryStore.
+- **🎯 Single-agent cliff hedge (T0.5/T2.2)** — any workflow can be composed into a single sequential prompt (`team plan singleAgent=true`). Proves pi-crew's mission survives even if multi-agent is obsoleted by 1M+ token models.
+- **🧹 2,335 LOC of dead code removed** — grep-verified unused BudgetTracker, MemoryStore, `.bak` files, disabled brief-mode.
+- **🔌 Pi-api seam** — centralizes the 8-symbol Pi coupling surface in one file, hedging against Pi API churn.
+
+### Features (Phase 0 — Stabilize & Clean)
+
+- **`dbb4b6c`** — Deleted `budget-tracker.ts` (353 LOC), `memory-store.ts` (244 LOC), `brief-tool-overrides.ts` (400 LOC, disabled since 0.6.4), 3× `.bak` files (1,338 LOC), and their tests. Net −2,918 LOC including tests.
+- **`42c1442`** — **Compaction resilience (O10)**: `compaction-guard.ts` gained `collectInFlightRuns()`, `formatResumeDirective()`, and a new `session_compact` handler that re-injects a `crew:resume-directive` entry into the fresh post-compaction context + notifies the user. Covers both the proactive path and Pi's reactive auto-compact path.
+- **`40caf9e`** — `src/extension/pi-api.ts`: a type-level seam re-exporting the 8 public-API symbols pi-crew uses (ExtensionAPI, ExtensionContext, ExtensionCommandContext, ToolDefinition, defineTool, createBashTool, AgentSessionEvent, BeforeAgentStartEvent) + `BUILT_AGAINST_PI_VERSION` constant for version-drift diagnostics.
+- **`8f40b07`** — **Single-agent cliff hedge v0**: `single-agent-compose.ts` (~95 LOC). `orderSteps()` topologically sorts by dependsOn; `composeSingleAgentPrompt()` turns a workflow into one sequential execution prompt.
+
+### Features (Phase 1 — Trust Trinity)
+
+- **`3184303`** — **Cost visibility (O1)**: `state/usage.ts` gained `formatTokens()`, `formatCost()`, `aggregateUsageByRole()`, and `formatCostReport()`. The `summary` action now includes a multi-line report with token split + per-role % breakdown.
+- **`198994e`** — **Plan-level HITL (O5)**: `team-runner.ts` `requiresPlanApproval()` dropped the `workflow.name === "implementation"` constraint; `hasPendingMutatingTaskAtBoundary()` (new) gates at the plan→execute boundary for any workflow; `ensurePlanApprovalRequested()` is robust to a missing `assess` step and gives clearer approval guidance.
+- **`0272d77`** — **Cross-run memory (O4)**: `knowledge-injection.ts` (~80 LOC) registers a `before_agent_start` hook that appends `.crew/knowledge.md` (truncated to 16KB) to every agent's system prompt — main session + each crew worker.
+
+### Features (Phase 2 — Lean Power)
+
+- **`eeefe0a`** — **Single-agent runtime mode (T2.2)**: `singleAgent` boolean param on the `team plan` action. A Pi agent calling `team plan singleAgent=true` receives the full composed sequential prompt for any workflow. MCP tool consumption (T2.1) already existed for live-session workers (`mcp-proxy.ts`); verified and left in place rather than duplicated.
+
+### Upgrade Notes
+- New config: `runtime.requirePlanApproval = true` enables plan-level approval gates on any workflow.
+- New file: `.crew/knowledge.md` (optional) — write durable project knowledge; it's injected into every run.
+- Cost report appears automatically in `team summary`. Budget *enforcement* (auto-stop) is intentionally deferred until cost-data accuracy is validated.
+
 ## [0.6.4] — Visually Rich Tool Rendering: Merged Frames, Live Progress Bars (2026-06-14)
 
 ### Highlights

package/README.md

@@ -11,6 +11,17 @@ repo: https://github.com/baphuongna/pi-crew
 
 **v0.6.4**: See [CHANGELOG.md](CHANGELOG.md).
 
+### Highlights (v0.6.4 → v0.7.0)
+
+This release implements **Phase 0 + Phase 1** of the long-term roadmap (synthesized from a 10-round research process), plus the **single-agent cliff hedge**. Principle: *build trust and cliff-resilience, stay lean, delete before adding.*
+
+- **🛡️ Compaction resilience (O10)** — the #1 user pain ("after auto-compact, the task stops midway") is fixed. In-flight crew runs are detected, a resume directive is injected into the compaction summary, and tasks re-attach after compaction.
+- **💰 Cost visibility (O1)** — `team summary <runId>` now shows a full cost report with per-role attribution and token breakdown (`$0.77 — executor 79%, reviewer 14%...`).
+- **✋ Plan-level HITL for any workflow (O5)** — set `runtime.requirePlanApproval = true` to gate any workflow at the plan→execute boundary; approve via `team api op=approve-plan`.
+- **🧠 Cross-run memory (O4)** — `.crew/knowledge.md` is auto-injected into every run's system prompt. pi-crew remembers project context across runs.
+- **🎯 Single-agent cliff hedge** — `team plan singleAgent=true` composes any workflow into one sequential prompt, so pi-crew's mission survives even if multi-agent is obsoleted by large-context models.
+- **🧹 2,335 LOC of dead code removed** + **Pi-api seam** centralizing the coupling surface.
+
 ### Highlights (v0.6.3 → v0.6.4)
 
 - **Visually rich tool rendering** — `team` and `Agent` tool calls now render as framed cards in the Pi TUI with box-drawing borders, colored status badges, and structured layouts
@@ -260,6 +271,63 @@ If preconditions are not met, a friendly error message is returned instead of cr
 
 ---
 
+## Reliability & Trust
+
+### Compaction resilience
+
+pi-crew survives Pi's context compaction. When the context is compacted (auto or manual), in-flight crew runs are detected and a **resume directive** is injected into the post-compaction context, so tasks continue instead of stalling. You'll see a notification like:
+
+```
+Context compacted. 1 pi-crew run(s) still in-flight — use team status to continue.
+```
+
+### Plan-level human-in-the-loop (HITL)
+
+Set `runtime.requirePlanApproval = true` to gate **any workflow** at the plan→execute boundary. After the read-only (planning) phases complete, the run pauses for explicit approval before mutating tasks run:
+
+```
+team api op=approve-plan runId=<runId>   # approve → execute
+  team api op=cancel-plan runId=<runId>    # cancel
+```
+
+This is plan-level (not per-step) — per-step gates would kill the parallelism that's pi-crew's point.
+
+### Cross-run memory (`.crew/knowledge.md`)
+
+Create `.crew/knowledge.md` in your project root with durable learnings (code style, test commands, common pitfalls, past refactors). It's auto-read (up to 16KB) and injected into **every** agent's system prompt — the main session and each crew worker. pi-crew gets better the longer you use it.
+
+```markdown
+# Project Knowledge
+- Tests: run with `npm test` (not jest directly)
+- Style: tabs, not spaces
+- Auth refactor (2026-06): split auth.ts into session.ts + api.ts
+```
+
+### Cost visibility
+
+Every `team summary <runId>` includes a per-role cost report:
+
+```
+═══ Cost Report ═══
+Tokens: 134k (in 112k, out 5.7k, cache-write 16k)
+Cost: $0.7700 across 18 turn(s)
+By role:
+  executor (2 tasks): $0.6100 — 79%, 98k tok, 13 turns
+  reviewer (1 task): $0.1100 — 14%, 23k tok, 3 turns
+```
+
+### Single-agent mode (cliff hedge)
+
+Any workflow can run single-agent instead of multi-agent — composing all phases into one sequential prompt:
+
+```
+team plan team=default workflow=default goal="..." singleAgent=true
+```
+
+This is pi-crew's cliff-resilient mode: the workflow definitions, phase structure, and artifact contracts survive even if a single large-context model outperforms multi-agent teams.
+
+---
+
 ## Tool Actions
 
 ```json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-crew",
-  "version": "0.6.4",
+  "version": "0.7.2",
   "description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
   "author": "baphuongna",
   "license": "MIT",
@@ -33,6 +33,7 @@
     "teams/",
     "workflows/",
     "skills/**/SKILL.md",
+    "themes/",
     "README.md",
     "AGENTS.md",
     "docs/",

package/src/errors.ts

@@ -1,6 +1,24 @@
+// pi-crew structured error module — taxonomy mapping E001–E006.
 /**
- * Error code taxonomy for pi-crew.
- * Maps to semantic categories matching fallow's E001-E004 pattern.
+ * @fileoverview Error types and structured error handling for pi-crew.
+ *
+ * This module defines pi-crew's error taxonomy, mapping to semantic categories
+ * matching fallow's E001-E004 pattern. It exports three main constructs:
+ *
+ * - {@link ErrorCode} — a `const` object and string-literal union type alias
+ *   enumerating machine-readable error codes (E001–E006). Implemented as a
+ *   `const` object rather than a TypeScript `enum` so that Node's
+ *   `--experimental-strip-types` can load this module (enum syntax is not
+ *   supported in strip-only mode).
+ *
+ * - {@link CrewError} — a structured `Error` subclass that carries an
+ *   {@link ErrorCode}, an optional human-readable `help` hint, and an optional
+ *   `context` string. Its `toString()` renders the display format:
+ *   `error[E001]: Failed to read manifest.json: not found`.
+ *
+ * - {@link errors} — a factory object exposing convenience constructors
+ *   (e.g. `errors.fileRead`, `errors.taskNotFound`) that build `CrewError`
+ *   instances with sensible defaults and pre-attached context.
  */
 // Implemented as const object + type alias (not `enum`) so that Node's
 // `--experimental-strip-types` can load this module. TypeScript `enum`

package/src/extension/knowledge-injection.ts

@@ -0,0 +1,71 @@
+/**
+ * knowledge-injection.ts — Project knowledge that accumulates across runs (O4).
+ *
+ * ROADMAP Phase 1 / T1.3 ("downsized memory"): a deliberately minimal
+ * replacement for the deleted 244-LOC MemoryStore. Crews and the main
+ * session read `.crew/knowledge.md` and have it injected into the system
+ * prompt, so pi-crew "remembers" project context across runs.
+ *
+ * Philosophy (Round 6 stress-test): radically downsized. Just a Markdown
+ * file the user can edit, surfaced into every run. No vector DB, no
+ * embeddings, no graph. Simple = trustworthy.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { BeforeAgentStartEvent, ExtensionAPI } from "./pi-api.ts";
+import { projectCrewRoot } from "../utils/paths.ts";
+
+/** The knowledge file, relative to the project crew root. */
+export const KNOWLEDGE_FILENAME = "knowledge.md";
+/** Cap injected knowledge to avoid unbounded system-prompt growth. */
+const MAX_KNOWLEDGE_BYTES = 16_000;
+
+/** Resolve the knowledge file path for a cwd (may not exist yet). */
+export function knowledgePath(cwd: string): string {
+	return path.join(projectCrewRoot(cwd), KNOWLEDGE_FILENAME);
+}
+
+/** Read knowledge content, truncated to a safe size. "" if absent/empty. */
+export function readKnowledge(cwd: string): string {
+	try {
+		const p = knowledgePath(cwd);
+		if (!fs.existsSync(p)) return "";
+		let content = fs.readFileSync(p, "utf8").trim();
+		if (content.length > MAX_KNOWLEDGE_BYTES) {
+			content = `${content.slice(0, MAX_KNOWLEDGE_BYTES)}\n\n<!-- knowledge.md truncated at ${MAX_KNOWLEDGE_BYTES} bytes -->`;
+		}
+		return content;
+	} catch {
+		return "";
+	}
+}
+
+/** Build the injected prompt fragment (empty if no knowledge). */
+export function buildKnowledgeFragment(cwd: string): string {
+	const content = readKnowledge(cwd);
+	if (!content) return "";
+	return [
+		"",
+		"# Project knowledge (from .crew/knowledge.md)",
+		"The following project knowledge was captured by pi-crew from prior runs.",
+		"Use it to avoid repeating past mistakes and to respect project conventions.",
+		"You may update .crew/knowledge.md when you learn something durable.",
+		"",
+		content,
+	].join("\n");
+}
+
+/**
+ * Register the knowledge-injection hook. Appends project knowledge to the
+ * system prompt on every agent start (main session + each crew worker,
+ * since workers are child Pi processes that also fire before_agent_start).
+ */
+export function registerKnowledgeInjection(pi: ExtensionAPI): void {
+	pi.on("before_agent_start", (event: BeforeAgentStartEvent) => {
+		const options = (event as BeforeAgentStartEvent & { systemPromptOptions?: { cwd?: unknown } }).systemPromptOptions ?? {};
+		const cwd = typeof options.cwd === "string" ? options.cwd : process.cwd();
+		const fragment = buildKnowledgeFragment(cwd);
+		if (!fragment) return undefined;
+		return { systemPrompt: `${event.systemPrompt}${fragment}` };
+	});
+}

package/src/extension/pi-api.ts

@@ -0,0 +1,47 @@
+/**
+ * pi-api.ts — pi-crew's stable seam against the Pi extension API.
+ *
+ * PURPOSE (roadmap Phase 0 / Pillar 4 "Pi-Native, Protocol-Aware"):
+ * Centralize every symbol pi-crew imports from
+ * `@earendil-works/pi-coding-agent` so that:
+ *   1. The coupling surface is auditable in ONE file (8 symbols today).
+ *   2. A Pi API rename/restructure requires updating only this seam.
+ *   3. New code imports from here ("./pi-api") rather than the raw package,
+ *      establishing the indirection that hedges Pi-coupling risk.
+ *
+ * COUpling SURFACE (kept intentionally small — public extension API only):
+ *   - ExtensionAPI              the registration entry point (pi)
+ *   - ExtensionContext          per-event/session context (ctx)
+ *   - ExtensionCommandContext   slash-command context
+ *   - ToolDefinition            tool schema type
+ *   - defineTool                tool factory
+ *   - createBashTool            built-in bash tool (for custom tooling)
+ *   - AgentSessionEvent         session event type
+ *   - BeforeAgentStartEvent     pre-turn system-prompt hook event
+ *
+ * NEW code should `import { ExtensionAPI, ExtensionContext } from "./pi-api"`.
+ * Existing files may keep their direct imports; migrate opportunistically
+ * (no big-bang refactor — see roadmap Phase 0 T0.3/T0.4 notes).
+ *
+ * Note: these are TYPE-level re-exports (erased at runtime). Runtime coupling
+ * to Pi is via the `pi` and `ctx` objects passed by Pi's loader — that is
+ * unavoidable and correct (pi-crew IS a Pi extension). This seam documents
+ * and centralizes the type-level surface.
+ */
+export type {
+	ExtensionAPI,
+	ExtensionContext,
+	ExtensionCommandContext,
+	ToolDefinition,
+	AgentSessionEvent,
+	BeforeAgentStartEvent,
+} from "@earendil-works/pi-coding-agent";
+
+export { defineTool, createBashTool } from "@earendil-works/pi-coding-agent";
+
+/**
+ * The Pi package version pi-crew was built against. Used for diagnostics
+ * and to surface version-drift if Pi upgrades introduce breaking changes.
+ * Update this when bumping the pi-coding-agent dependency.
+ */
+export const BUILT_AGAINST_PI_VERSION = "0.79.3";

package/src/extension/register.ts

@@ -17,6 +17,7 @@ import {
 	stopAsyncRunNotifier,
 } from "./async-notifier.ts";
 import { registerAutonomousPolicy } from "./autonomous-policy.ts";
+import { registerKnowledgeInjection } from "./knowledge-injection.ts";
 import { registerCleanupHandler } from "./crew-cleanup.ts";
 import type { ScheduledJob } from "../runtime/scheduler.ts";
 import { clearHooksScoped } from "../hooks/registry.ts";
@@ -63,6 +64,7 @@ import {
 	updateCrewWidget,
 } from "../ui/widget/index.ts";
 import { summarizeHeartbeats } from "../ui/heartbeat-aggregator.ts";
+import { deployBundledThemes } from "../ui/deploy-bundled-themes.ts";
 import {
 	requestRender,
 	setExtensionWidget,
@@ -100,7 +102,6 @@ import {
 import { createJsonlSink, type NotificationSink } from "./notification-sink.ts";
 import { runArtifactCleanup } from "./registration/artifact-cleanup.ts";
 import { registerTeamCommands } from "./registration/commands.ts";
-import { registerBriefToolOverrides } from "./registration/brief-tool-overrides.ts";
 import { registerCompactionGuard } from "./registration/compaction-guard.ts";
 import {
 	__test__subagentSpawnParams,
@@ -188,6 +189,9 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	const disposeI18n = initI18n(pi);
 	resetTimings();
 	time("register:start");
+	// Deploy bundled themes (crew-dark, crew-dracula, etc.) to ~/.pi/agent/themes/
+	// so Pi's theme loader discovers them. Best-effort, idempotent.
+	deployBundledThemes();
 	const globalStore = globalThis as Record<string | symbol, unknown>;
 	const runtimeCleanupStoreKey = Symbol("__piCrewRuntimeCleanup");
 	const previousRuntimeCleanup = globalStore[runtimeCleanupStoreKey];
@@ -982,6 +986,8 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	};
 	time("register.policy");
 	registerAutonomousPolicy(pi);
+	registerKnowledgeInjection(pi);
+	time("register.knowledge");
 	time("register.rpc");
 	function getPiEvents():
 		| Parameters<typeof registerPiCrewRpc>[0]
@@ -1986,11 +1992,18 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 
 	registerCleanupHandler(pi);
 
-	// Brief tool overrides DISABLED: re-registering built-in tools replaced Pi's
-	// superior native renderers (syntax highlighting, diff views, full file
-	// content) with inferior custom ones, and caused renderCall/renderResult
-	// to duplicate path/command info. Pi's native rendering is better.
-	// To re-enable, uncomment: registerBriefToolOverrides(pi, process.cwd());
+
+	// Resilient edit (Phase 2): OPT-IN via CREW_RESILIENT_EDIT=1.
+	// Wraps the native edit tool with the cascading replace() fallback so that
+	// slightly-wrong oldText (indentation drift, whitespace) still matches.
+	// Auto-disables if pi-diff is loaded (it has its own replace integration).
+	if (process.env.CREW_RESILIENT_EDIT === "1") {
+		import("../runtime/resilient-edit.ts")
+			.then(({ wrapEditWithResilientReplace }) => {
+				wrapEditWithResilientReplace(pi);
+			})
+			.catch(() => { /* non-critical */ });
+	}
 
 	registerTeamCommands(pi, {
 		startForegroundRun,

package/src/extension/registration/commands.ts

@@ -364,13 +364,52 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 					} catch (error) {
 						ctx.ui.notify(`Failed to save: ${error instanceof Error ? error.message : String(error)}`, "error");
 					}
-				}, () => done(undefined));
+				}, () => done(undefined), async (action: string, value: unknown) => {
+					// Action callbacks (Pi theme switch) write to a different store
+					// than pi-crew config (e.g. ~/.pi/agent/settings.json).
+					try {
+						if (action === "piTheme" && typeof value === "string") {
+							// Live theme switch: ctx.ui.setTheme() swaps the global theme,
+							// persists it to settings.json, and triggers a UI redraw — no
+							// restart needed. Falls back to file-write + restart hint if
+							// the live API is unavailable (e.g. non-TUI mode).
+							if (typeof ctx.ui.setTheme === "function") {
+								const res = ctx.ui.setTheme(value);
+								if (res.success) {
+									ctx.ui.notify(`Theme: ${value} (applied live)`, "info");
+								} else {
+									const { setPiTheme } = await import("../../ui/theme-discovery.ts");
+									setPiTheme(value);
+									ctx.ui.notify(`Theme saved as '${value}' but failed to apply: ${res.error ?? "unknown"}. Restart Pi.`, "warning");
+								}
+							} else {
+								const { setPiTheme } = await import("../../ui/theme-discovery.ts");
+								setPiTheme(value);
+								ctx.ui.notify(`Pi theme set to '${value}'. Restart Pi to apply.`, "info");
+							}
+						}
+					} catch (error) {
+						ctx.ui.notify(`Failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+					}
+				});
 				return overlay;
 			}, { overlay: true, overlayOptions: { width: "90%", maxHeight: "85%", anchor: "center" } });
 			return;
 		}
 		const result = await handleTeamTool({ action: "settings", config: { args: args.trim() } }, teamCommandContext(ctx));
 		await notifyCommandResult(ctx, commandText(result));
+		// Live-switch hook: when the text subcommand 'theme <name>' succeeds,
+		// also apply the theme live via ctx.ui.setTheme() (no restart). The
+		// handler above only writes to settings.json.
+		const trimmed = args.trim();
+		if (trimmed.startsWith("theme ")) {
+			const themeName = trimmed.slice(6).trim();
+			if (themeName && typeof ctx.ui.setTheme === "function") {
+				const res = ctx.ui.setTheme(themeName);
+				if (res.success) ctx.ui.notify(`Theme: ${themeName} (applied live)`, "info");
+				else ctx.ui.notify(`Saved but live-switch failed: ${res.error ?? "unknown"}. Restart Pi.`, "warning");
+			}
+		}
 	},
 })
 

package/src/extension/registration/compaction-guard.ts

@@ -12,6 +12,8 @@ const HARD_RATIO = 0.95;
 const DEFAULT_CONTEXT_WINDOW = 200_000;
 const MAX_ARTIFACT_INDEX_RUNS = 10;
 const MAX_ARTIFACT_INDEX_ITEMS = 80;
+/** Run statuses that mean the run is still in-flight and may need resuming. */
+const IN_FLIGHT_RUN_STATUSES = new Set(["queued", "planning", "running"]);
 
 function contextWindow(ctx: { model?: { contextWindow?: number } }): number {
 	const value = ctx.model?.contextWindow;
@@ -66,6 +68,99 @@ function formatCrewArtifactIndex(entries: CrewArtifactIndexEntry[]): string {
 	return lines.join("\n");
 }
 
+/**
+ * Collect in-flight (non-terminal) crew runs that must be resumable after
+ * compaction. These are runs the agent was actively working on or awaiting.
+ */
+export function collectInFlightRuns(cwd: string): TeamRunManifest[] {
+	return listRecentRuns(cwd, MAX_ARTIFACT_INDEX_RUNS).filter((run) =>
+		IN_FLIGHT_RUN_STATUSES.has(run.status),
+	);
+}
+
+/**
+ * Build an explicit resume directive that survives compaction. This is the
+ * core of O10 (compaction resilience): after compaction, the agent MUST know
+ * what crew tasks were in-flight and how to continue them.
+ */
+function formatResumeDirective(runs: TeamRunManifest[]): string {
+	if (!runs.length) return "";
+	const lines = [
+		"",
+		"# pi-crew in-flight task resume directive (CRITICAL — do not drop)",
+		"The following pi-crew runs were in progress when the context was compacted.",
+		"After compaction, you MUST continue these tasks — do NOT consider them finished.",
+	];
+	for (const run of runs) {
+		const wf = run.workflow ? `, workflow=${run.workflow}` : "";
+		lines.push(
+			`- runId=${run.runId} (status=${run.status}, team=${run.team}${wf}): ${run.goal}`,
+		);
+	}
+	lines.push("");
+	lines.push("To resume: call the `team` tool with action='status' to check progress, then");
+	lines.push("action='wait' (to join a still-running task) or action='summary' / action='get'");
+	lines.push("to retrieve results. If a task was mid-execution and the worker is still alive,");
+	lines.push("it continues independently — just re-attach. Do not restart completed work.");
+	return lines.join("\n");
+}
+
+/**
+ * Build a short continuation prompt for sendUserMessage. This is what actually
+ * makes the agent resume after compaction — Pi's threshold compaction does NOT
+ * auto-retry (it stops and waits for user input). By injecting this as a user
+ * message that triggers a turn, the agent automatically continues the in-flight
+ * crew task instead of stalling until the user types "continue".
+ */
+export function buildContinuationPrompt(runs: TeamRunManifest[]): string {
+	if (!runs.length) return "";
+	const lines = [
+		"[pi-crew] Context was compacted while crew tasks were still in-flight. Continue the work — do not wait for me.",
+	];
+	for (const run of runs) {
+		const wf = run.workflow ? `, workflow=${run.workflow}` : "";
+		lines.push(`- runId=${run.runId} (status=${run.status}, team=${run.team}${wf}): ${run.goal}`);
+	}
+	lines.push("");
+	lines.push("Resume: call `team` with action='status' to check progress, then action='wait' (join a running task), action='summary', or action='get' as appropriate. If a worker is still alive it continues independently — just re-attach. Do NOT restart completed work.");
+	return lines.join("\n");
+}
+
+/**
+ * Trigger automatic agent continuation after compaction. Fire-and-forget the
+ * promise — never block the compaction flow. The sendUserMessage type is
+ * declared `void` but the runtime returns a Promise (it triggers an agent turn).
+ */
+export function triggerContinuation(pi: ExtensionAPI, ctx: ExtensionContext, runs: TeamRunManifest[]): void {
+	if (!runs.length) return;
+	const prompt = buildContinuationPrompt(runs);
+	try {
+		const result = pi.sendUserMessage(prompt) as unknown;
+		Promise.resolve(result).catch(() => {
+			// best-effort: if continuation fails, at least notify
+			try {
+				ctx.ui.notify("pi-crew: auto-continuation after compaction failed — use team status to resume manually.", "warning");
+			} catch {
+				// swallow
+			}
+		});
+	} catch {
+		// best-effort
+	}
+}
+
+/** Combined customInstructions injected into proactive compaction summaries. */
+function buildCompactionInstructions(cwd: string): string {
+	const artifactIndex = collectCrewArtifactIndex(cwd);
+	const inFlight = collectInFlightRuns(cwd);
+	const parts = [
+		"Prioritize keeping pi-crew run state, task results, artifact references, run IDs, and next actions. Keep completed-task detail concise.",
+	];
+	if (artifactIndex.length > 0) parts.push(formatCrewArtifactIndex(artifactIndex));
+	if (inFlight.length > 0) parts.push(formatResumeDirective(inFlight));
+	return parts.join("\n");
+}
+
 export function registerCompactionGuard(pi: ExtensionAPI, options: RegisterCompactionGuardOptions): void {
 	let pendingCompactReason: string | null = null;
 	let compactionInProgress = false;
@@ -73,18 +168,32 @@ export function registerCompactionGuard(pi: ExtensionAPI, options: RegisterCompa
 	const startCompact = (ctx: ExtensionContext, reason: string): void => {
 		if (compactionInProgress) return;
 		compactionInProgress = true;
-		const artifactIndex = collectCrewArtifactIndex(ctx.cwd);
-		if (artifactIndex.length > 0) {
-			pi.appendEntry("crew:artifact-index", {
+		const customInstructions = buildCompactionInstructions(ctx.cwd);
+		// Append a durable resume entry so it appears in the post-compaction
+		// context regardless of how summarization treats customInstructions.
+		const inFlight = collectInFlightRuns(ctx.cwd);
+		if (inFlight.length > 0) {
+			pi.appendEntry("crew:resume-directive", {
 				reason,
 				createdAt: new Date().toISOString(),
-				artifacts: artifactIndex,
+				runs: inFlight.map((r) => ({
+					runId: r.runId,
+					status: r.status,
+					team: r.team,
+					workflow: r.workflow,
+					goal: r.goal,
+				})),
 			});
 		}
 		ctx.compact({
-			customInstructions: `Prioritize keeping pi-crew run state, task results, artifact references, run IDs, and next actions. Keep completed-task detail concise.${formatCrewArtifactIndex(artifactIndex)}`,
+			customInstructions,
 			onComplete: () => {
 				compactionInProgress = false;
+				// O10 FIX: Pi's threshold compaction does NOT auto-retry — it
+				// stops and waits for user input. Trigger automatic
+				// continuation so the agent resumes the in-flight crew task.
+				const runs = collectInFlightRuns(ctx.cwd);
+				triggerContinuation(pi, ctx, runs);
 				ctx.ui.notify(reason === "deferred" ? "Deferred compaction completed" : "Auto-compacted context during team run", "info");
 			},
 			onError: (error) => {
@@ -94,17 +203,49 @@ export function registerCompactionGuard(pi: ExtensionAPI, options: RegisterCompa
 		});
 	};
 
-	// Phase 1.2: Always allow compaction to proceed.
-	// Previously this deferred compaction during foreground runs, but that prevented
-	// context-mode's PreCompact hook from running (which needs compaction to build resume snapshots).
-	// pi-crew state is preserved via customInstructions and artifactIndex appended above.
-	pi.on("session_before_compact", async (_event, ctx) => {
-		// Always allow compaction - context-mode needs it for resume snapshots
+	// Allow compaction to proceed. pi-crew state is preserved via the
+	// customInstructions + resume-directive entry appended in startCompact,
+	// and re-injected post-compaction by the session_compact handler below.
+	pi.on("session_before_compact", async (_event, _ctx) => {
 		return;
 	});
 
-	// Phase 2.1: Proactive compaction with dynamic threshold.
-	// Only trigger compaction when context usage >=75%, or when deferred from a previous high-usage turn.
+	// O10: After ANY compaction (proactive OR reactive/Pi-triggered), detect
+	// in-flight crew runs and trigger automatic continuation. This is the
+	// critical fix: Pi's threshold compaction does NOT auto-retry — it stops
+	// and waits for user input. By injecting a continuation user message that
+	// triggers a turn, the agent automatically resumes the in-flight crew task.
+	// This covers the common case where Pi auto-compacts without going through
+	// our proactive startCompact path.
+	pi.on("session_compact", (_event, ctx) => {
+		try {
+			const inFlight = collectInFlightRuns(ctx.cwd);
+			if (inFlight.length === 0) return;
+			// Re-append the resume directive entry for durable record.
+			pi.appendEntry("crew:resume-directive", {
+				reason: "post-compaction-continuation",
+				createdAt: new Date().toISOString(),
+				runs: inFlight.map((r) => ({
+					runId: r.runId,
+					status: r.status,
+					team: r.team,
+					workflow: r.workflow,
+					goal: r.goal,
+				})),
+			});
+			ctx.ui.notify(
+				`Context compacted. ${inFlight.length} pi-crew run(s) still in-flight — auto-resuming.`,
+				"info",
+			);
+			// THE FIX: trigger automatic continuation. Without this, Pi stops
+			// after threshold compaction and the user must type "continue".
+			triggerContinuation(pi, ctx, inFlight);
+		} catch {
+			// best-effort: never block compaction completion
+		}
+	});
+
+	// Proactive compaction with dynamic threshold.
 	pi.on("turn_end", (_event, ctx) => {
 		if (compactionInProgress) return;
 		const hasActiveForeground = options.foregroundControllers.size > 0 || options.foregroundTeamRunControllers.size > 0;
@@ -112,7 +253,6 @@ export function registerCompactionGuard(pi: ExtensionAPI, options: RegisterCompa
 		// If deferred compaction is pending and foreground just ended, check if still needed
 		if (!hasActiveForeground && pendingCompactReason) {
 			pendingCompactReason = null;
-			// Only compact if ratio still >= TRIGGER_RATIO, otherwise skip
 			if (ratio === undefined || ratio < TRIGGER_RATIO) return;
 			startCompact(ctx, "deferred");
 			return;