pi-crew 0.10.5 → 0.11.0

package/src/extension/crew-vibes/index.ts

@@ -1,15 +1,11 @@
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { requestRender, setFooter } from "../../ui/pi-ui-compat.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 
 /**
- * Wrap a pi UI call in try/catch. If the call throws (e.g. terminal doesn't
- * support PUA glyphs, theme helper returns undefined, or pi's API signature
- * changed), log it and silently fall back to pi's default behavior — which
- * is simply "do nothing", letting pi show its own built-in indicator.
- *
- * Crew-vibes must NEVER break the user's session. A broken spinner is not
- * worth a crashed pi.
+ * Wrap a pi UI call in try/catch. If the call throws (e.g. theme helper
+ * returns undefined or pi's API signature changed), log it and silently fall
+ * back to pi's default behavior. Crew-vibes must NEVER break the user's
+ * session.
  */
 function safeUiCall(scope: string, fn: () => void): void {
 	try {
@@ -19,155 +15,39 @@ function safeUiCall(scope: string, fn: () => void): void {
 	}
 }
 
-import { setFooterDockSinkActive } from "../../ui/dock-footer.ts";
 import { type CrewVibesConfig, loadConfig, saveConfig } from "./config.ts";
-import { intervalForSpeed } from "./figures.ts";
-import { type CrewVibesFooterSource, createCrewVibesFooter } from "./footer.ts";
 import { clearProviderUsageCache, fetchProviderUsage, type ProviderUsage } from "./provider-usage.ts";
-import {
-	asCrewTheme,
-	clearVibesStatus,
-	crewIndicatorFrames,
-	formatSpeed,
-	getCapacityUsage,
-	renderSpeedFooter,
-	renderWorkingMessage,
-	setSpeedStatus,
-} from "./render.ts";
-import { SpeedAnimator, SpeedTracker } from "./speed.ts";
+import { asCrewTheme, clearVibesStatus, renderProviderUsage, setProviderStatus } from "./render.ts";
 
 export const CREW_VIBES_STATUS_KEY = "pi-crew-vibes";
 
-function isAssistantMessage(message: unknown): boolean {
-	return typeof message === "object" && message !== null && (message as { role?: string }).role === "assistant";
-}
-
-function assistantUsageOutput(message: unknown): number | undefined {
-	const usage = (message as { usage?: { output?: unknown } }).usage;
-	const output = usage?.output;
-	return typeof output === "number" && Number.isFinite(output) ? output : undefined;
-}
-
-function assistantStopReason(message: unknown): string | undefined {
-	const reason = (message as { stopReason?: unknown }).stopReason;
-	return typeof reason === "string" ? reason : undefined;
-}
-
-function assistantEventType(event: unknown): string | undefined {
-	return typeof (event as { type?: string }).type === "string" ? (event as { type: string }).type : undefined;
-}
-
+/**
+ * crew-vibes — provider rate-limit quota publisher.
+ *
+ * Maintainer decisions 2026-09-13/14 (UI review follow-ups) stripped this
+ * module down to its one remaining job: fetching the current provider's
+ * rate-limit usage and publishing it as a STATUS entry on pi's NATIVE
+ * footer. Removed entirely: the custom footer replacement (it had drifted
+ * from native) and the tok/s speed UI (custom spinner + "Working N tok/s")
+ * — pi's built-ins are always used.
+ */
 export function registerCrewVibes(pi: ExtensionAPI): void {
 	let config: CrewVibesConfig = loadConfig();
-	let lastRenderedAt = 0;
-	let currentIntervalMs = 0;
-	const speedTracker = new SpeedTracker(config.speed);
-	const footerAnimator = new SpeedAnimator(config.speed.renderIntervalMs);
-	let liveTimer: ReturnType<typeof setInterval> | undefined;
-	let footerTimer: ReturnType<typeof setInterval> | undefined;
-	let capacityTimer: ReturnType<typeof setInterval> | undefined;
 	let providerTimer: ReturnType<typeof setInterval> | undefined;
 	let lastProviderUsage: ProviderUsage | null = null;
 	let currentProvider: string | undefined;
-	let currentThinkingLevel: string | undefined;
 
 	function themeOf(ctx: ExtensionContext) {
 		return asCrewTheme(ctx.hasUI ? ctx.ui.theme : undefined);
 	}
 
-	const footerSource: CrewVibesFooterSource = {
-		getConfig: () => config,
-		getQuotaUsage: () => lastProviderUsage,
-		getThinkingLevel: () => currentThinkingLevel,
-	};
-
-	/** Whether the custom footer has crew-vibes meters to add on top of pi's stats. */
-	function metersActive(): boolean {
-		return config.enabled && (config.capacity.enabled || config.capacity.providerUsage);
-	}
-
-	/** Install our custom footer, or restore pi's built-in footer when idle.
-	 * Unlike setStatus (joined + right-truncated), the footer's render(width)
-	 * gets the real width and owns line layout, so the quota is never chopped. */
-	function installFooter(ctx: ExtensionContext): void {
-		if (!ctx?.hasUI) return;
-		if (!metersActive()) {
-			safeUiCall("clear-footer", () => {
-				// The crew dock can no longer render at the very bottom — the
-				// widget falls back to pi's belowEditor slot automatically.
-				setFooterDockSinkActive(false);
-				setFooter(ctx, undefined);
-			});
-			return;
-		}
-		safeUiCall("install-footer", () => {
-			setFooter(ctx, (tui, theme, footerData) => createCrewVibesFooter({ tui, theme, footerData, ctx, source: footerSource }));
-			// The footer can now host the crew dock below the quota lines.
-			setFooterDockSinkActive(true);
-			requestRender(ctx);
-		});
-	}
-
-	/** Trigger a footer repaint; the footer recomputes capacity/quota on render.
-	 *
-	 *  Wrapped wholly in safeUiCall because fetchProviderAndRefresh is async: after
-	 *  its `await` the session may have shut down (session_shutdown clears the
-	 *  timers, but an in-flight fetchProviderAndRefresh still resumes), making ctx
-	 *  stale. Accessing the `hasUI` getter on a stale ctx throws — catch it so
-	 *  crew-vibes never crashes pi. Matches the file's core philosophy: "must
-	 *  NEVER break the user's session". */
-	function refreshFooter(ctx: ExtensionContext): void {
-		safeUiCall("refresh-footer", () => {
-			if (ctx?.hasUI) requestRender(ctx);
-		});
-	}
-
-	function publishSpeedFooter(ctx: ExtensionContext, speed = footerAnimator.value()): void {
-		if (!config.enabled || !config.speed.enabled || !config.speed.footer) {
-			safeUiCall("clear-speed-status", () => setSpeedStatus(ctx, config, undefined));
-			return;
-		}
-		safeUiCall("publish-speed-status", () => setSpeedStatus(ctx, config, renderSpeedFooter(themeOf(ctx), config.speed, speed)));
-	}
-
-	function applyIndicator(ctx: ExtensionContext, speed: number | null, force = false): void {
-		if (!ctx.hasUI || !ctx.ui.setWorkingIndicator) return;
-		if (!config.enabled || !config.speed.enabled || !config.speed.indicator) {
-			safeUiCall("reset-indicator", () => ctx.ui.setWorkingIndicator?.());
-			return;
-		}
-		const next = intervalForSpeed(config.speed, speed);
-		if (!force && Math.abs(next - currentIntervalMs) < 10) return;
-		safeUiCall("set-indicator", () =>
-			ctx.ui.setWorkingIndicator?.({
-				frames: crewIndicatorFrames(themeOf(ctx)),
-				intervalMs: next,
-			}),
+	/** Publish the provider rate-limit quota as a STATUS entry (joined into
+	 * pi's NATIVE footer status line; right-truncates on very narrow
+	 * terminals — pi's documented behavior, accepted). */
+	function publishQuotaStatus(ctx: ExtensionContext): void {
+		safeUiCall("publish-quota-status", () =>
+			setProviderStatus(ctx, config, lastProviderUsage ? renderProviderUsage(themeOf(ctx), lastProviderUsage) : undefined),
 		);
-		currentIntervalMs = next;
-	}
-
-	function renderWorking(ctx: ExtensionContext, speed: number | null): void {
-		if (!config.enabled || !config.speed.enabled || !ctx.hasUI) return;
-		safeUiCall("set-working-message", () => ctx.ui.setWorkingMessage?.(renderWorkingMessage(themeOf(ctx), config.speed, speed)));
-	}
-
-	function stopLiveTimer(): void {
-		if (!liveTimer) return;
-		clearInterval(liveTimer);
-		liveTimer = undefined;
-	}
-
-	function stopFooterTimer(): void {
-		if (!footerTimer) return;
-		clearInterval(footerTimer);
-		footerTimer = undefined;
-	}
-
-	function stopCapacityTimer(): void {
-		if (!capacityTimer) return;
-		clearInterval(capacityTimer);
-		capacityTimer = undefined;
 	}
 
 	function stopProviderTimer(): void {
@@ -176,48 +56,14 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 		providerTimer = undefined;
 	}
 
-	function startLiveTimer(ctx: ExtensionContext): void {
-		if (liveTimer || !ctx.hasUI) return;
-		liveTimer = setInterval(() => {
-			if (!config.enabled || !config.speed.enabled || !speedTracker.isStreaming) {
-				stopLiveTimer();
-				return;
-			}
-			const speed = speedTracker.liveTokS();
-			applyIndicator(ctx, speed);
-			renderWorking(ctx, speed);
-		}, config.speed.renderIntervalMs);
-		liveTimer.unref?.();
-	}
-
-	function startFooterTimer(ctx: ExtensionContext): void {
-		if (footerTimer || !ctx.hasUI) return;
-		footerTimer = setInterval(() => {
-			if (!config.enabled || !config.speed.enabled) {
-				stopFooterTimer();
-				return;
-			}
-			publishSpeedFooter(ctx);
-			if (!footerAnimator.isAnimating()) stopFooterTimer();
-		}, config.speed.renderIntervalMs);
-		footerTimer.unref?.();
-	}
-
-	function startCapacityTimer(ctx: ExtensionContext): void {
-		if (capacityTimer) return;
-		const interval = Math.max(250, config.capacity.refreshIntervalMs);
-		capacityTimer = setInterval(() => refreshFooter(ctx), interval);
-		capacityTimer.unref?.();
-	}
-
-	/** Fetch provider usage for currentProvider and refresh the footer.
+	/** Fetch provider usage for currentProvider and publish the quota status.
 	 *  Called on start, on each timer tick, and immediately when the
 	 *  provider changes (model_select) so the quota reflects the new
-	 *  provider without waiting for the next 5-minute tick. */
+	 *  provider without waiting for the next tick. */
 	async function fetchProviderAndRefresh(ctx: ExtensionContext): Promise<void> {
 		if (!config.enabled || !config.capacity.providerUsage) {
 			lastProviderUsage = null;
-			refreshFooter(ctx);
+			publishQuotaStatus(ctx);
 			return;
 		}
 		try {
@@ -226,7 +72,7 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 			// Never crash on provider fetch failure
 			lastProviderUsage = null;
 		}
-		refreshFooter(ctx);
+		publishQuotaStatus(ctx);
 	}
 
 	function startProviderTimer(ctx: ExtensionContext): void {
@@ -239,204 +85,66 @@ export function registerCrewVibes(pi: ExtensionAPI): void {
 		providerTimer.unref?.();
 	}
 
-	function resetWorking(ctx: ExtensionContext): void {
-		applyIndicator(ctx, null, true);
-		renderWorking(ctx, speedTracker.lastTokS);
-	}
-
 	function applyConfig(ctx: ExtensionContext): void {
 		saveConfig(config);
-		speedTracker.updateConfig(config.speed);
-		footerAnimator.updateDuration(config.speed.renderIntervalMs);
 		if (!config.enabled) {
-			stopLiveTimer();
-			stopFooterTimer();
-			stopCapacityTimer();
 			stopProviderTimer();
-			setFooterDockSinkActive(false);
-			setFooter(ctx, undefined);
 			clearVibesStatus(ctx);
 			return;
 		}
-		installFooter(ctx);
-		publishSpeedFooter(ctx);
-		startCapacityTimer(ctx);
 		if (config.capacity.providerUsage) startProviderTimer(ctx);
+		else publishQuotaStatus(ctx); // clears the stale status when disabled
 	}
 
 	pi.on("session_start", (_event, ctx) => {
-		stopLiveTimer();
-		stopFooterTimer();
-		stopCapacityTimer();
 		stopProviderTimer();
 		config = loadConfig();
-		speedTracker.updateConfig(config.speed);
-		footerAnimator.updateDuration(config.speed.renderIntervalMs);
-		speedTracker.resetSession();
-		footerAnimator.reset(null);
 		clearProviderUsageCache();
 		// Initialize provider from current model — model_select only fires on manual switch
 		currentProvider = (ctx.model as { provider?: string } | undefined)?.provider;
-		currentThinkingLevel = undefined;
 		if (!config.enabled) {
-			setFooter(ctx, undefined);
 			clearVibesStatus(ctx);
 			return;
 		}
-		installFooter(ctx);
-		publishSpeedFooter(ctx);
-		startCapacityTimer(ctx);
 		startProviderTimer(ctx);
-		// Set the working indicator early (matches pi's official working-indicator
-		// example) so pi has the custom frames configured before streaming begins.
-		// Calls before the loading animation exists are ignored, so we re-apply on
-		// agent_start/message_update as well.
-		applyIndicator(ctx, null, true);
-	});
-
-	pi.on("agent_start", (_event, ctx) => {
-		if (!config.enabled) return;
-		resetWorking(ctx);
-	});
-
-	pi.on("turn_start", (_event, ctx) => {
-		if (!config.enabled) return;
-		resetWorking(ctx);
-	});
-
-	pi.on("message_start", (event, ctx) => {
-		if (!config.enabled || !config.speed.enabled || !isAssistantMessage(event.message)) return;
-		speedTracker.startMessage();
-		footerAnimator.reset(speedTracker.lastTokS);
-		startLiveTimer(ctx);
-		lastRenderedAt = 0;
-	});
-
-	pi.on("message_update", (event, ctx) => {
-		if (!config.enabled || !config.speed.enabled || !isAssistantMessage(event.message) || !speedTracker.isStreaming) return;
-
-		const ev = event.assistantMessageEvent;
-		const type = assistantEventType(ev);
-		if (type === "text_delta" || type === "thinking_delta") {
-			const delta = (ev as { delta?: string }).delta ?? "";
-			speedTracker.recordDelta(delta, assistantUsageOutput(event.message));
-		}
-		if (type === "start") resetWorking(ctx);
-
-		const now = Date.now();
-		if (now - lastRenderedAt < config.speed.renderIntervalMs && type !== "done") return;
-		lastRenderedAt = now;
-
-		const speed = speedTracker.liveTokS();
-		applyIndicator(ctx, speed);
-		renderWorking(ctx, speed);
-	});
-
-	pi.on("message_end", (event, ctx) => {
-		if (!isAssistantMessage(event.message)) return;
-		refreshFooter(ctx);
-		if (!config.enabled || !config.speed.enabled || !speedTracker.isStreaming) return;
-
-		const completed = speedTracker.finishMessage(assistantUsageOutput(event.message) ?? 0, assistantStopReason(event.message));
-		if (!completed) return;
-
-		footerAnimator.setTarget(speedTracker.sessionAvgTokS());
-		publishSpeedFooter(ctx);
-		startFooterTimer(ctx);
-		applyIndicator(ctx, speedTracker.lastTokS);
-	});
-
-	pi.on("turn_end", () => {
-		speedTracker.stopMessage();
-		stopLiveTimer();
-	});
-
-	pi.on("agent_end", (_event, ctx) => {
-		speedTracker.stopMessage();
-		stopLiveTimer();
-		if (ctx && config.enabled && ctx.hasUI) {
-			applyIndicator(ctx, speedTracker.lastTokS);
-			safeUiCall("clear-working-message", () => ctx.ui.setWorkingMessage?.());
-		}
 	});
 
 	pi.on("model_select", (event, ctx) => {
 		currentProvider = (event as { model?: { provider?: string } }).model?.provider;
 		clearProviderUsageCache();
 		// Fetch immediately so the quota reflects the new provider without
-		// waiting for the next 5-minute timer tick.
+		// waiting for the next timer tick.
 		fetchProviderAndRefresh(ctx);
 	});
-	pi.on("thinking_level_select", (event, ctx) => {
-		currentThinkingLevel = (event as { level?: unknown }).level as string | undefined;
-		refreshFooter(ctx);
-	});
-	pi.on("session_compact", (_event, ctx) => refreshFooter(ctx));
-	pi.on("session_tree", (_event, ctx) => refreshFooter(ctx));
 
 	pi.on("session_shutdown", (_event, ctx) => {
-		stopLiveTimer();
-		stopFooterTimer();
-		stopCapacityTimer();
 		stopProviderTimer();
-		setFooterDockSinkActive(false);
-		setFooter(ctx, undefined);
 		clearVibesStatus(ctx);
 	});
 
 	async function handleCommand(args: string, ctx: ExtensionCommandContext): Promise<void> {
-		const tokens = args.trim().split(/\s+/).filter(Boolean);
-		const [first, second] = tokens;
-
-		const mutate = (next: CrewVibesConfig): void => {
-			config = next;
-			applyConfig(ctx);
-		};
+		const [first] = args.trim().split(/\s+/).filter(Boolean);
 
 		if (!first) {
-			const speed = speedTracker.liveTokS();
-			const usage = getCapacityUsage(ctx);
-			const stage = config.capacity.icons.length
-				? config.capacity.labels[
-						Math.max(
-							0,
-							Math.min(
-								config.capacity.labels.length - 1,
-								Math.floor(((usage.percent ?? 0) / 100) * config.capacity.labels.length),
-							),
-						)
-					]
-				: "?";
-			ctx.ui.notify(
-				`crew-vibes: ${config.enabled ? "on" : "off"} · speed ${config.speed.enabled ? "on" : "off"} (${formatSpeed(config.speed, speed)}) · capacity ${config.capacity.enabled ? "on" : "off"} (${stage})`,
-				"info",
-			);
+			const quota = lastProviderUsage
+				? `${lastProviderUsage.providerName} 5h ${Math.round(lastProviderUsage.fiveHourPercent)}% · Wk ${Math.round(lastProviderUsage.weeklyPercent)}%`
+				: "no data yet";
+			ctx.ui.notify(`crew-vibes: ${config.enabled ? "on" : "off"} · quota ${quota}`, "info");
 			return;
 		}
 
 		if (first === "on" || first === "off") {
-			mutate({ ...config, enabled: first === "on" });
+			config = { ...config, enabled: first === "on" };
+			applyConfig(ctx);
 			ctx.ui.notify(`crew-vibes ${first === "on" ? "enabled" : "disabled"}`, "info");
 			return;
 		}
 
-		if (first === "speed" && (second === "on" || second === "off")) {
-			mutate({ ...config, speed: { ...config.speed, enabled: second === "on" } });
-			ctx.ui.notify(`crew-vibes speed ${second === "on" ? "enabled" : "disabled"}`, "info");
-			return;
-		}
-
-		if (first === "capacity" && (second === "on" || second === "off")) {
-			mutate({ ...config, capacity: { ...config.capacity, enabled: second === "on" } });
-			ctx.ui.notify(`crew-vibes capacity ${second === "on" ? "enabled" : "disabled"}`, "info");
-			return;
-		}
-
-		ctx.ui.notify("Usage: /team-vibes [on|off|speed on|off|capacity on|off]", "error");
+		ctx.ui.notify("Usage: /team-vibes [on|off]", "error");
 	}
 
 	pi.registerCommand("team-vibes", {
-		description: "Toggle crew-vibes speed + context meters (on/off, speed, capacity)",
+		description: "Toggle the provider-quota status (on/off)",
 		handler: handleCommand,
 	});
 }

package/src/extension/crew-vibes/render.ts

@@ -1,16 +1,7 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { CrewTheme } from "../../ui/theme-adapter.ts";
-import {
-	CAPACITY_STATUS_ID,
-	type CapacityConfig,
-	type CrewVibesConfig,
-	capacityIcons,
-	PROVIDER_STATUS_ID,
-	SPEED_STATUS_ID,
-	type SpeedConfig,
-	type TokenDisplay,
-} from "./config.ts";
-import { capacityIndex, crewFrames, isDangerStage } from "./figures.ts";
+import { type CapacityConfig, type CrewVibesConfig, capacityIcons, PROVIDER_STATUS_ID, type TokenDisplay } from "./config.ts";
+import { capacityIndex, isDangerStage } from "./figures.ts";
 
 export type CapacityUsage = {
 	tokens: number | null;
@@ -41,31 +32,6 @@ export function getCapacityUsage(ctx: ExtensionContext): CapacityUsage {
 	};
 }
 
-export function formatSpeed(config: SpeedConfig, speed: number | null): string {
-	return speed === null ? `-- ${config.label}` : `${speed.toFixed(1)} ${config.label}`;
-}
-
-export function renderSpeedFooter(theme: CrewTheme | undefined, config: SpeedConfig, speed: number | null): string {
-	const value = speed === null ? "--" : speed.toFixed(1);
-	const valueTone = speed === null ? "dim" : "accent";
-	const styled = theme ? `${theme.fg(valueTone, value)} ${theme.fg("dim", config.label)}` : `${value} ${config.label}`;
-	return styled;
-}
-
-export function renderWorkingMessage(theme: CrewTheme | undefined, config: SpeedConfig, speed: number | null): string {
-	const left = "Working";
-	const speedText = theme
-		? `${theme.fg(speed === null ? "dim" : "accent", speed === null ? "--" : speed.toFixed(1))} ${theme.fg("dim", config.label)}`
-		: `${speed === null ? "--" : speed.toFixed(1)} ${config.label}`;
-	return theme ? `${theme.fg("muted", left)}  ${speedText}` : `${left}  ${speedText}`;
-}
-
-export function crewIndicatorFrames(theme: CrewTheme | undefined): string[] {
-	const frames = crewFrames();
-	if (!theme) return [...frames];
-	return frames.map((frame) => theme.fg("accent", frame));
-}
-
 function formatCapacityPrefix(config: CapacityConfig, usage: CapacityUsage): string {
 	const display: TokenDisplay = config.tokenDisplay;
 	if (display === "off") return "";
@@ -92,31 +58,9 @@ export function renderCapacity(theme: CrewTheme | undefined, config: CapacityCon
 	return `${prefix}${coloredIcon}${afterIcon}`;
 }
 
-export function setSpeedStatus(ctx: ExtensionContext, config: CrewVibesConfig, text: string | undefined): void {
-	if (!ctx?.hasUI) return;
-	if (!config.enabled || !config.speed.enabled || !config.speed.footer) {
-		ctx.ui.setStatus(SPEED_STATUS_ID, undefined);
-		return;
-	}
-	ctx.ui.setStatus(SPEED_STATUS_ID, text);
-}
-
-export function setCapacityStatus(ctx: ExtensionContext, config: CrewVibesConfig, text: string | undefined): void {
-	if (!ctx?.hasUI) return;
-	if (!config.enabled || !config.capacity.enabled) {
-		ctx.ui.setStatus(CAPACITY_STATUS_ID, undefined);
-		return;
-	}
-	ctx.ui.setStatus(CAPACITY_STATUS_ID, text);
-}
-
 export function clearVibesStatus(ctx: ExtensionContext): void {
 	if (!ctx?.hasUI) return;
-	ctx.ui.setStatus(SPEED_STATUS_ID, undefined);
-	ctx.ui.setStatus(CAPACITY_STATUS_ID, undefined);
 	ctx.ui.setStatus(PROVIDER_STATUS_ID, undefined);
-	if (ctx.ui.setWorkingIndicator) ctx.ui.setWorkingIndicator();
-	if (ctx.ui.setWorkingMessage) ctx.ui.setWorkingMessage();
 }
 
 // Provider rate-limit usage snapshot (mirrors provider-usage.ts interface).

package/src/extension/help.ts

@@ -19,6 +19,7 @@ export function piTeamsHelp(): string {
 		"- /team-worktrees <runId>",
 		"- /team-api <runId> <operation> [taskId=<taskId>] [body=<message>]",
 		"- /team-dashboard",
+		"- /schedules [log <jobId-or-name>] — list scheduled jobs / tail latest run output",
 		"- /team-mascot",
 		"- /team-transcript <runId> [taskId]",
 		"- /team-result <runId> [taskId]",

package/src/extension/knowledge-injection.ts

@@ -437,13 +437,21 @@ export function buildKnowledgeFragment(cwd: string, query?: KnowledgeQuery): str
 
 /**
  * Register the knowledge-injection hook. Appends project knowledge to the
- * MAIN session's system prompt on `before_agent_start`. This hook does NOT
- * fire for crew workers: they are spawned with `--no-extensions`, so the
- * extension layer (and this hook) never loads in their process. Workers
- * instead receive knowledge via `buildKnowledgeFragment(task.cwd)` injected
- * into their prompt stablePrefix by `prompt-builder.ts`. Do NOT "fix" this
- * perceived gap by making the hook reach workers — it would cause
- * double-injection. (Verified by research workflow 2026-06-28.)
+ * MAIN session's system prompt on `before_agent_start`.
+ *
+ * Worker knowledge path (ARCH-2 corrected): children are NOT spawned with
+ * `--no-extensions` anymore — `pi-args.ts` runs extension discovery like
+ * the main session, but a child only loads an extension when the agent's
+ * frontmatter declares it (`extensions:`; builtin pi-crew agents declare
+ * none, so in practice workers never load pi-crew). Workers instead receive
+ * knowledge via `buildKnowledgeFragment(task.cwd)` injected into their
+ * prompt stablePrefix by `prompt-builder.ts`.
+ *
+ * Defense-in-depth: if an agent DOES declare the pi-crew extension, this
+ * hook would fire in the worker process and double-inject knowledge (once
+ * here, once via prompt-builder). The `PI_CREW_KIND=subagent` early-return
+ * below keeps main-session hooks main-session-only regardless of how the
+ * child was spawned. Do NOT remove it.
  *
  * The hook calls buildKnowledgeFragment(cwd) with NO query — so the main
  * session gets conventions-only (no session-log noise), which is the right
@@ -452,6 +460,10 @@ export function buildKnowledgeFragment(cwd: string, query?: KnowledgeQuery): str
  */
 export function registerKnowledgeInjection(pi: ExtensionAPI): void {
 	pi.on("before_agent_start", (event: BeforeAgentStartEvent) => {
+		// ARCH-2: never fire in child worker processes — knowledge reaches
+		// workers via prompt-builder's stablePrefix fragment; firing here too
+		// would double-inject.
+		if (process.env.PI_CREW_KIND === "subagent") return;
 		const options =
 			(
 				event as BeforeAgentStartEvent & {

package/src/extension/post-init-skill-check.ts

@@ -0,0 +1,32 @@
+import { renderSkillInstructions } from "../runtime/skill-instructions.ts";
+
+export type SkillCheckResult = {
+	total: number;
+	resolved: number;
+	missing: string[];
+	severity: "ok" | "warn" | "error";
+	message: string;
+};
+
+export async function runPostInitSkillCheck(cwd: string): Promise<SkillCheckResult> {
+	const result = renderSkillInstructions({ cwd, role: "executor" });
+	const total = result.names.length;
+	const missingMatches = result.block.match(/Skill '([^']+)' was selected but no SKILL\.md file was found/g);
+	const missing = missingMatches ? missingMatches.map((m) => m.match(/'([^']+)'/)![1]) : [];
+	const resolved = total - missing.length;
+
+	let severity: "ok" | "warn" | "error";
+	let message: string;
+	if (resolved === total) {
+		severity = "ok";
+		message = `All ${total} default skills resolved`;
+	} else if (resolved === 0) {
+		severity = "error";
+		message = `0/${total} default skills resolved — likely bundle stale. Run \`npm run build:bundle\`.`;
+	} else {
+		severity = "warn";
+		message = `${resolved}/${total} default skills resolved — degraded: ${missing.join(", ")}`;
+	}
+
+	return { total, resolved, missing, severity, message };
+}

package/src/extension/register.ts

@@ -32,6 +32,7 @@ import { registerCrewShortcuts } from "./crew-shortcuts.ts";
 import { registerCrewVibes } from "./crew-vibes/index.ts";
 import { registerKnowledgeInjection } from "./knowledge-injection.ts";
 import { registerCrewMessageRenderers } from "./message-renderers.ts";
+import { runPostInitSkillCheck } from "./post-init-skill-check.ts";
 import { registerPiCommands } from "./registration/command-registration.ts";
 import { buildRegistrationContext } from "./registration/context-builder.ts";
 import { importCrashRecovery, purgeStaleActiveRunIndexSyncIfLoaded } from "./registration/crash-recovery-cache.ts";
@@ -50,7 +51,7 @@ export { __test__subagentSpawnParams };
 /**
  * Pi extension entry point. See module-level docstring for the full pipeline.
  */
-export function registerPiTeams(pi: ExtensionAPI): void {
+export async function registerPiTeams(pi: ExtensionAPI): Promise<void> {
 	resetTimings();
 	time("register:start");
 
@@ -127,6 +128,13 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	} catch (err) {
 		console.warn("[pi-crew] crew-vibes initialization failed:", err instanceof Error ? err.message : err);
 	}
+
+	const skillCheck = await runPostInitSkillCheck(process.cwd());
+	if (skillCheck.severity === "error") {
+		console.error(`[pi-crew] ${skillCheck.message}`);
+	} else if (skillCheck.severity === "warn") {
+		console.warn(`[pi-crew] ${skillCheck.message}`);
+	}
 }
 
 // Bottom-of-file import: keeps compaction-guard out of the top-level