@sage-protocol/pi-adapter 0.3.11 → 0.4.1

package/extensions/index.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import {
 	SageHookRuntime,
 	SageMcpBridge,
@@ -32,175 +33,42 @@ type ExtensionApi = {
 	sendMessage: (message: any, options?: any) => void;
 };
 
-// ── Sage widget state machine ──
-// Single dense widget line with staleness-aware suggestion display.
-// Output: "[Sage] zenith (48s) · sunago | → code-audit, sharp-edges"
-// When no recent suggestion (>5min): shows session skill count instead.
-// Unicode glyphs get ASCII fallback when SAGE_NO_UNICODE=1.
-
+// Transient subagent status only. Pi owns native skill discovery/loading, so
+// this layer never renders a Sage suggestion shortlist.
 class SageWidgetState {
-	private static SUGGESTION_STALE_MS = 300_000; // 5 minutes
-
-	private baselineText: string | null = null;
-	private skillCount = 0;
-	private suggestedKeys: string[] | null = null;
-	private suggestedQualities: Map<string, { passRate: number }> | null = null;
-	private lastSuggestionAt = 0;
-	private subagentKeys: string[] | null = null;
-
-	clearTransients(): void {
-		this.suggestedKeys = null;
-		this.suggestedQualities = null;
-		this.subagentKeys = null;
-	}
-
-	setBaseline(text: string, totalSkills?: number): void {
-		this.baselineText = text;
-		if (totalSkills !== undefined) this.skillCount = totalSkills;
-	}
+	private static MAX_NAME_CHARS = 32;
+	private loadedKeys: string[] | null = null;
 
-	setSuggestions(
-		keys: string[],
-		qualityMap?: Map<string, { passRate: number }>,
-	): void {
-		this.suggestedKeys = keys.length > 0 ? keys : null;
-		this.suggestedQualities = qualityMap ?? null;
-		if (keys.length > 0) this.lastSuggestionAt = Date.now();
+	clear(): void {
+		this.loadedKeys = null;
 	}
 
 	setSubagents(keys: string[]): void {
-		this.subagentKeys = keys.length > 0 ? keys : null;
+		this.loadedKeys = keys.length > 0 ? keys : null;
 	}
 
-	/** Annotate a skill name with bench quality indicator (→ Unicode-safe via render). */
-	private static qualityIcon(passRate: number): string {
-		if (passRate >= 0.7) return " \u2713"; // ✓
-		if (passRate >= 0.4) return " \u26A0"; // ⚠
-		return " \u2717"; // ✗
+	private static displayName(key: string): string {
+		return key.length > SageWidgetState.MAX_NAME_CHARS
+			? `${key.slice(0, SageWidgetState.MAX_NAME_CHARS - 1)}\u2026`
+			: key;
 	}
 
-	/** Color quality marks + glyphs when the host exposes a theme. */
-	private static applyTheme(line: string, theme: any): string {
-		if (!theme?.fg) return line;
-		return line
-			.replaceAll("✓", theme.fg("success", "✓"))
-			.replaceAll("⚠", theme.fg("warning", "⚠"))
-			.replaceAll("✗", theme.fg("error", "✗"))
-			.replaceAll("[+]", theme.fg("success", "[+]"))
-			.replaceAll("[!]", theme.fg("warning", "[!]"))
-			.replaceAll("[-]", theme.fg("error", "[-]"));
-	}
-
-	/** Merge all layers into a single widget line with staleness + quality logic. */
 	render(): string[] {
-		const parts: string[] = [];
-
-		if (this.baselineText) parts.push(this.baselineText);
-
-		if (this.suggestedKeys && this.suggestedKeys.length > 0) {
-			const names = this.suggestedKeys.slice(0, 4).map((k) => {
-				const clean = k.startsWith("##") ? k.replace(/^##\s*/, "") : k;
-				const q = this.suggestedQualities?.get(clean);
-				return q ? clean + SageWidgetState.qualityIcon(q.passRate) : clean;
-			});
-			const tail =
-				this.suggestedKeys.length > 4
-					? ` +${this.suggestedKeys.length - 4}`
-					: "";
-			parts.push(`\u2192 ${names.join(", ")}${tail}`); // →
-		} else if (
-			this.lastSuggestionAt > 0 &&
-			Date.now() - this.lastSuggestionAt >
-				SageWidgetState.SUGGESTION_STALE_MS &&
-			this.skillCount > 0
-		) {
-			parts.push(`${this.skillCount} skills`);
-		}
-
-		if (this.subagentKeys && this.subagentKeys.length > 0) {
-			const tail =
-				this.subagentKeys.length > 3 ? ` +${this.subagentKeys.length - 3}` : "";
-			parts.push(
-				`\u2192 resolved: ${this.subagentKeys.slice(0, 3).join(", ")}${tail}`,
-			); // →
-		}
-
-		return parts.length > 0 ? [unicodeSafe(parts.join(" | "))] : [];
+		if (!this.loadedKeys?.length) return [];
+		const tail = this.loadedKeys.length > 3 ? ` +${this.loadedKeys.length - 3}` : "";
+		const names = this.loadedKeys
+			.slice(0, 3)
+			.map((key) => SageWidgetState.displayName(key));
+		return [unicodeSafe(`\u2192 loaded: ${names.join(", ")}${tail}`)];
 	}
 
 	updateWidget(ui: any): void {
 		if (!ui?.setWidget) return;
 		const lines = this.render();
-		if (lines.length === 0) return;
-
-		// Themed component-factory form when the host exposes a theme
-		// (pi does); plain string lines otherwise so headless hosts and
-		// older harnesses keep working.
-		if (ui.theme?.fg) {
-			ui.setWidget("sage", (_tui: unknown, theme: any) => {
-				const themed = lines.map((line) =>
-					SageWidgetState.applyTheme(line, theme),
-				);
-				return { render: () => themed, invalidate: () => {} };
-			});
-			return;
-		}
-		ui.setWidget("sage", lines);
+		ui.setWidget("sage", lines.length > 0 ? lines : undefined);
 	}
 }
 
-/** Extract skill keys from Sage suggestion output.
- *
- * Handles two output formats:
- *   1. Codex (-prefixed):  "- [Skill] `code-audit`" or "- code-audit (code-audit)"
- *   2. Content (headers):  "# Skill: code-audit (from zenith)"
- *
- * Uses a state machine to avoid capturing `-` list items from within
- * SKILL.md body content (e.g. "- Read", "- Grep" in docs).
- */
-function parseSuggestionKeys(text: string): string[] {
-	const keys: string[] = [];
-	let inSkillBlock = false;
-
-	for (const line of text.split("\n")) {
-		const trimmed = line.trim();
-
-		// Content format: "# Skill: name" or "# Prompt: name" (block start)
-		if (
-			trimmed.startsWith("#") &&
-			/\b(?:Skill|Prompt|Behavior):/i.test(trimmed)
-		) {
-			const m = trimmed.match(
-				/^#\s+(?:Skill|Prompt|Behavior):\s+(\S+?)(?:\s+\(from|$)/i,
-			);
-			if (m) {
-				keys.push(m[1]);
-				inSkillBlock = true;
-			}
-			continue;
-		}
-
-		// End of a content-format skill block
-		if (inSkillBlock && trimmed === "---") {
-			inSkillBlock = false;
-			continue;
-		}
-
-		// Skip lines inside skill body blocks (they may contain "- list items")
-		if (inSkillBlock) continue;
-
-		// Codex format: only match known suggestion-line patterns
-		if (trimmed.startsWith("-")) {
-			const m =
-				trimmed.match(/^-\s+\[Skill\]\s+`(\S+?)`/) || // "- [Skill] `key`"
-				trimmed.match(/^-\s+(\S+?)\s+\(/) || // "- key (key)"
-				trimmed.match(/^-\s+(\S+?)\s+-\s/); // "- key - desc"
-			if (m) keys.push(m[1]);
-		}
-	}
-	return keys;
-}
-
 function parseBoolean(value: string | undefined, fallback: boolean): boolean {
 	if (value === undefined) return fallback;
 	const normalized = value.trim().toLowerCase();
@@ -322,20 +190,28 @@ function getSessionId(ctx: any): string | undefined {
 	const sessionManager = ctx?.sessionManager;
 	if (!sessionManager) return undefined;
 
+	const nativeId =
+		typeof sessionManager.getSessionId === "function"
+			? sessionManager.getSessionId()
+			: undefined;
+	if (typeof nativeId === "string" && nativeId.trim()) {
+		return nativeId.trim();
+	}
+
 	const sessionFile =
 		typeof sessionManager.getSessionFile === "function"
 			? sessionManager.getSessionFile()
 			: undefined;
 	if (typeof sessionFile === "string" && sessionFile.trim()) {
-		return sessionFile;
-	}
-
-	const leafId =
-		typeof sessionManager.getLeafId === "function"
-			? sessionManager.getLeafId()
-			: undefined;
-	if (typeof leafId === "string" && leafId.trim()) {
-		return leafId;
+		// Older Pi builds did not expose getSessionId(). Their persisted session
+		// filename contains the immutable UUID; extract only that identifier and
+		// never use the transcript path or mutable leaf id as session identity.
+		const basename =
+			sessionFile.replace(/\\+/g, "/").split("/").at(-1) ?? "";
+		const match = basename.match(
+			/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i,
+		);
+		if (match) return match[0];
 	}
 
 	return undefined;
@@ -378,22 +254,6 @@ function extractText(input: unknown): string {
 	return "";
 }
 
-function isContinuationPrompt(prompt: string): boolean {
-	const normalized = prompt.trim().toLowerCase();
-	if (!normalized) return false;
-	return [
-		"continue",
-		"please continue",
-		"continue please",
-		"go on",
-		"please go on",
-		"resume",
-		"please resume",
-		"keep going",
-		"please keep going",
-	].includes(normalized);
-}
-
 function extractUsage(message: any): { input?: string; output?: string } {
 	const usage =
 		message?.usage && typeof message.usage === "object"
@@ -438,12 +298,6 @@ function skillNameFromPath(path: string): string | null {
 	return parts[parts.length - 2] ?? null;
 }
 
-function extractSkillCommandName(text: unknown): string | null {
-	if (typeof text !== "string") return null;
-	const match = text.trim().match(/^\/skill:([a-z0-9][a-z0-9-]*)\b/i);
-	return match?.[1]?.toLowerCase() ?? null;
-}
-
 function extractReadPath(input: unknown): string | null {
 	if (!input || typeof input !== "object") return null;
 	const obj = input as Record<string, unknown>;
@@ -482,278 +336,26 @@ function skillNameFromReadEvent(
 	event: any,
 	skillPathToName: Map<string, string>,
 ): string | null {
-	const path = extractReadPath(event?.input ?? event?.args);
+	const input = event?.input ?? event?.args;
+	if (input && typeof input === "object") {
+		const request = input as Record<string, unknown>;
+		if (request.offset !== undefined || request.limit !== undefined) return null;
+	}
+	const path = extractReadPath(input);
 	const normalized = normalizeSkillPath(path);
 	if (!normalized || !normalized.endsWith("/skill.md")) return null;
 	return skillPathToName.get(normalized) ?? skillNameFromPath(normalized);
 }
 
-/**
- * Behavior-aware suggestion enrichment (Option A).
- *
- * When the suggest hook returns skills, check if any behavior entrypoints
- * match the user's prompt. If so, prepend an enriched suggestion with:
- * - The behavior chain (step names + skill keys + required/optional markers)
- * - sage_behavior() call example for the full chain
- * - use_skill() fallback for just the entrypoint
- *
- * False positive mitigation:
- * 1. Lists ALL steps so the model can assess whether the chain is relevant
- * 2. Marks optional steps explicitly — model can judge if the chain is overkill
- * 3. Only enriches when ≥3 steps (avoids noise for thin behaviors)
- * 4. Always offers both options (chain vs individual) — never forces the chain
- * 5. Non-blocking — enrichment failure silently falls back to raw suggestions
- */
-async function enrichSuggestionsWithBehaviors(
-	rawSuggestions: string,
-	prompt: string,
-	bridge: InstanceType<typeof SageMcpBridge>,
-): Promise<string> {
-	if (!bridge.isReady() || !rawSuggestions.trim()) return rawSuggestions;
-
-	try {
-		// Search prompts (not skills) — behaviors are stored as prompt type entries
-		const searchResult = await bridge.callCodeModeSearch({
-			domain: "prompts",
-			action: "search",
-			params: { query: prompt, limit: 3 },
-		});
-
-		// Find behavior-tagged results
-		const behaviorKey = findBehaviorKeyFromSearch(searchResult);
-		if (!behaviorKey) return rawSuggestions;
-
-		// Fetch the full behavior plan to get step details
-		const planResult = await bridge.callCodeModeExecute({
-			domain: "prompts",
-			action: "get",
-			params: { key: behaviorKey, expand: ["behaviorResolved"] },
-		});
-
-		const behavior = extractBehaviorFromPlanResult(planResult, behaviorKey);
-		if (!behavior || behavior.steps.length < 3) return rawSuggestions;
-
-		const enrichment = formatBehaviorSuggestion(behavior, prompt);
-		return `${enrichment}\n\n---\n\n${rawSuggestions}`;
-	} catch {
-		return rawSuggestions;
-	}
-}
-
-/** Find the first behavior-type prompt key from search results. */
-function findBehaviorKeyFromSearch(result: unknown): string | null {
-	if (!result || typeof result !== "object") return null;
-
-	const obj = result as Record<string, unknown>;
-	if (!Array.isArray(obj.content)) return null;
-
-	for (const block of obj.content) {
-		if (!block || typeof block !== "object") continue;
-		const text = (block as Record<string, unknown>).text;
-		if (typeof text !== "string") continue;
-
-		try {
-			const parsed = JSON.parse(text);
-			const results = Array.isArray(parsed.results) ? parsed.results : [];
-			for (const item of results) {
-				if (!item || typeof item !== "object") continue;
-				// Detect behavior entries by tags or promptType
-				const tags = Array.isArray(item.tags) ? item.tags : [];
-				const promptType = item.promptType ?? item.type ?? "";
-				if (tags.includes("behavior") || promptType === "behavior") {
-					const key = typeof item.key === "string" ? item.key : "";
-					if (key) return key;
-				}
-			}
-		} catch {
-			// Not JSON — skip
-		}
-	}
-
-	return null;
-}
-
-interface BehaviorMatch {
-	key: string;
-	name: string;
-	description: string;
-	steps: Array<{
-		key: string;
-		title: string;
-		required: boolean;
-		/** True when behaviorResolved reports no local install for this key. */
-		missing?: boolean;
-	}>;
-}
-
-/** Extract behavior step info from a get_prompt response with behaviorResolved expand. */
-function extractBehaviorFromPlanResult(
-	result: unknown,
-	key: string,
-): BehaviorMatch | null {
-	if (!result || typeof result !== "object") return null;
-
-	const obj = result as Record<string, unknown>;
-	if (!Array.isArray(obj.content)) return null;
-
-	for (const block of obj.content) {
-		if (!block || typeof block !== "object") continue;
-		const text = (block as Record<string, unknown>).text;
-		if (typeof text !== "string") continue;
-
-		try {
-			const parsed = JSON.parse(text);
-			const prompt = parsed.prompt ?? parsed;
-
-			// Get step info from behaviorResolved (has skill metadata)
-			const resolved = prompt.behaviorResolved ?? prompt.behaviorPlan;
-			const behaviorSpec = prompt.behavior;
-
-			// behaviorResolved marks each declared skill with where it was
-			// found ("library:<name>", "installed") or "missing". Steps that
-			// resolve to "missing" have no local SKILL.md — surface that
-			// instead of advertising a bare key the model will chase to an
-			// ENOENT on the conventional ~/.agents/skills path.
-			const missingKeys = new Set<string>();
-			if (resolved && Array.isArray(resolved.skills)) {
-				for (const rs of resolved.skills) {
-					if (
-						rs &&
-						typeof rs === "object" &&
-						(rs as Record<string, unknown>).source === "missing" &&
-						typeof (rs as Record<string, unknown>).key === "string"
-					) {
-						missingKeys.add((rs as Record<string, unknown>).key as string);
-					}
-				}
-			}
-
-			// Build steps from behavior spec (has required/alias info)
-			if (behaviorSpec && Array.isArray(behaviorSpec.skills)) {
-				const steps = behaviorSpec.skills.map((s: unknown) => {
-					if (typeof s === "string")
-						return {
-							key: s,
-							title: s,
-							required: true,
-							missing: missingKeys.has(s),
-						};
-					if (s && typeof s === "object") {
-						const so = s as Record<string, unknown>;
-						const skillKey = typeof so.key === "string" ? so.key : "";
-						return {
-							key: skillKey,
-							title: typeof so.alias === "string" ? so.alias : skillKey,
-							required: so.required !== false,
-							missing: missingKeys.has(skillKey),
-						};
-					}
-					return {
-						key: String(s),
-						title: String(s),
-						required: true,
-						missing: missingKeys.has(String(s)),
-					};
-				});
-
-				// Required skills that can't resolve at all are dropped (the
-				// chain can't run them); optional unresolved ones stay, marked.
-				const missing = resolved?.missing ?? [];
-
-				return {
-					key,
-					name: typeof prompt.name === "string" ? prompt.name : key,
-					description:
-						typeof prompt.description === "string" ? prompt.description : "",
-					steps: steps.filter((s: { key: string }) => !missing.includes(s.key)),
-				};
-			}
-		} catch {
-			// Not JSON — skip
-		}
-	}
-
-	return null;
-}
-
-function formatBehaviorSuggestion(
-	behavior: BehaviorMatch,
-	prompt: string,
-): string {
-	const lines: string[] = [];
-
-	lines.push(
-		"[chain] **Behavior workflow available: " +
-			behavior.name +
-			"** (" +
-			behavior.steps.length +
-			" steps)",
-	);
-	lines.push("");
-
-	// List steps with required/optional markers — false positive mitigation.
-	// The model reads this list and decides if the full chain matches the intent.
-	lines.push("Steps:");
-	for (let i = 0; i < behavior.steps.length; i++) {
-		const step = behavior.steps[i];
-		let marker = step.required ? "" : " _(optional)_";
-		if (step.missing) {
-			// No local SKILL.md for this key — tell the model how to fetch it
-			// instead of letting it read the conventional path into an ENOENT.
-			marker +=
-				' _(not installed locally — fetch via sage_execute({ domain: "skills", action: "get", params: { key: "' +
-				step.key +
-				'" } }))_';
-		}
-		const label =
-			step.title !== step.key ? step.title + " (" + step.key + ")" : step.key;
-		lines.push("  " + (i + 1) + ". " + label + marker);
-	}
-	lines.push("");
-
-	const safePrompt = prompt.replace(/"/g, '\\"').slice(0, 120);
-
-	lines.push("**Full chain** (recommended for comprehensive workflows):");
-	lines.push(
-		'  sage_behavior({ key: "' +
-			behavior.key +
-			'", task: "' +
-			safePrompt +
-			'" })',
-	);
-	lines.push("");
-	lines.push(
-		"**Just the entrypoint** (for quick routing without the full pipeline):",
-	);
-	lines.push(
-		'  sage_execute({ domain: "skills", action: "use", params: { key: "' +
-			behavior.key +
-			'" } })',
-	);
-
-	return lines.join("\n");
-}
-
 export default function sagePiAdapterExtension(pi: ExtensionApi): void {
-	const showHookMessages = parseBoolean(
-		process.env.SAGE_SHOW_HOOK_MESSAGES,
-		false,
-	);
 	const allowBashSageCli = parseBoolean(process.env.SAGE_ALLOW_BASH_CLI, true);
-	const enableBehaviorEnrich = parseBoolean(
-		process.env.SAGE_BEHAVIOR_ENRICH,
-		false,
-	);
 	const config: SageP2Config = {
 		sageBin: process.env.SAGE_BIN ?? "sage",
 		sageProfile: process.env.SAGE_PROFILE,
-		suggestLimit: parseNumber(process.env.SAGE_SUGGEST_LIMIT, 3),
-		suggestDebounceMs: parseNumber(process.env.SAGE_SUGGEST_DEBOUNCE_MS, 800),
 		timeoutMs: parseNumber(process.env.SAGE_TIMEOUT_MS, 20_000),
-		enableProvision: parseBoolean(process.env.SAGE_SUGGEST_PROVISION, true),
 		enableRlmFeedback: parseBoolean(process.env.SAGE_RLM_FEEDBACK, true),
 		enableSecurityHooks: parseBoolean(process.env.SAGE_SECURITY_HOOKS, true),
-		source: process.env.SAGE_SOURCE ?? "pi-extension",
+		source: process.env.SAGE_SOURCE ?? "pi",
 	};
 
 	const bridge = new SageMcpBridge(
@@ -777,11 +379,23 @@ export default function sagePiAdapterExtension(pi: ExtensionApi): void {
 	// skipped (same graceful degradation as the widget).
 	let lastUi: any = null;
 
+	// Loaded-inventory counts shown alongside the health dot. The editor
+	// widget is reserved for transient subagent skill-resolution status.
+	let sageInventory: { libraryCount: number; skillCount: number } | null =
+		null;
+
 	const themedStatus = (ui: any, color: string, text: string): string => {
 		const safe = unicodeSafe(text);
 		return ui?.theme?.fg ? ui.theme.fg(color, safe) : safe;
 	};
 
+	const inventorySuffix = (): string => {
+		if (!sageInventory) return "";
+		const { libraryCount, skillCount } = sageInventory;
+		const libs = `${libraryCount} lib${libraryCount === 1 ? "" : "s"}`;
+		return ` · ${libs} · ${skillCount} skills`;
+	};
+
 	const updateSageHealthStatus = (ui: any): void => {
 		if (!ui?.setStatus) return;
 		try {
@@ -793,7 +407,10 @@ export default function sagePiAdapterExtension(pi: ExtensionApi): void {
 			) {
 				ui.setStatus("sage", themedStatus(ui, "warning", "◐ sage degraded"));
 			} else {
-				ui.setStatus("sage", themedStatus(ui, "success", "● sage"));
+				ui.setStatus(
+					"sage",
+					themedStatus(ui, "success", `● sage${inventorySuffix()}`),
+				);
 			}
 		} catch {
 			// Non-blocking — footer status is best-effort.
@@ -824,20 +441,19 @@ export default function sagePiAdapterExtension(pi: ExtensionApi): void {
 	pi.registerTool(createSageExecuteTool(bridge));
 	pi.registerTool(createSageStatusTool(bridge));
 
-	// Behavior execution tool — resolves and executes Sage behavior plans.
-	// The agent calls this to run a multi-skill behavior chain.
+	// Behavior plan tool — resolves and injects a controller plan (not a completed run).
+	// Smithers-style: plan is authority + step menu; agent owns step execution.
 	pi.registerTool({
 		name: "sage_behavior",
 		label: "Sage: Behavior",
 		promptSnippet:
-			"Resolve and execute a Sage behavior plan (multi-skill workflow chain)",
+			"Resolve a Sage behavior plan and inject step-by-step controller instructions (awaiting_agent — you still execute)",
 		description:
-			"Resolve and execute a Sage behavior: a multi-skill workflow whose resolved steps are " +
-			"coordinated by the Pi behavior executor. Behaviors chain multiple skills into a linear " +
-			"workflow — e.g., entry-plan-review chains: sage → reverse-interviewing → pre-mortem → " +
-			"ceo-plan-review → plan-eng-review → openprose → confidence-calibration. " +
-			"Call with key='entry-plan-review' and task='Review my implementation plan'. " +
-			"The tool returns the executor payload/result for the resolved skill chain.",
+			"Resolve a Sage behavior into a controller plan (multi-skill step chain) and inject it for you to execute. " +
+			"This is plan injection, not automatic step completion — status is awaiting_agent until you load each skill " +
+			"fully and freestyle tools under its constraints. Example chains: entry-plan-review (sage → reverse-interviewing → " +
+			"pre-mortem → ceo-plan-review → …). Call with key='entry-plan-review' and task='Review my implementation plan'. " +
+			"Returns the controller plan text plus status awaiting_agent.",
 		parameters: {
 			type: "object" as const,
 			properties: {
@@ -886,14 +502,20 @@ export default function sagePiAdapterExtension(pi: ExtensionApi): void {
 				};
 
 				const result = await behaviorExecutor.execute(plan, context);
+				const statusLine =
+					`status=${result.status}` +
+					` steps=${plan.steps.length}` +
+					` (plan inject — load each step skill fully, then freestyle; not auto-completed)`;
 
 				return {
 					content: [
 						{
 							type: "text",
 							text:
-								result.output ??
-								`Behavior '${key}' plan rendered with ${plan.steps.length} steps.`,
+								statusLine +
+								"\n\n" +
+								(result.output ??
+									`Behavior '${key}' plan rendered with ${plan.steps.length} steps.`),
 						},
 					],
 				};
@@ -959,7 +581,7 @@ export default function sagePiAdapterExtension(pi: ExtensionApi): void {
 	// `sage skill context` output here; that belongs in Tier 2 only.
 	const SAGE_PER_TURN_GUARDRAIL = `
 [Sage Tools - Internet Access]
-You have hub_list_servers, hub_status, hub_session_list, hub_start_server, hub_stop_server, sage_search, sage_execute, sage_status, and sage_behavior.
+You have hub_list_servers, hub_status, hub_session_list, hub_start_server, hub_stop_server, sage_search, sage_execute, sage_status, sage_behavior, and sage_mark_guided_use.
 Prefer hub_list_servers(), hub_status(), hub_session_list({ server_id?: "..." }), hub_start_server({ server_id: "..." }), and hub_stop_server({ server_id: "..." }) for simple MCP inventory/status/session/start/stop flows.
 Use sage_search({ domain: "help", action: "list", params: {} }) before guessing unknown Sage domains or actions.
 Use sage_search for read/discovery actions (search/list/status/meta suggestions, hub inventory, external search, wallet reads, activation reads).
@@ -971,6 +593,7 @@ Use hub_stop_server({ server_id: "..." }) or sage_execute({ domain: "hub", actio
 Admin hub mutations such as adding a custom server remain generic sage_execute flows rather than Pi-native helpers.
 If routing is unclear, use sage_search({ domain: "meta", action: "suggest", params: { goal: "..." } }) or sage_status({}).
 If reading a skill file under ~/.agents/skills/ (or another IDE skills dir) fails with ENOENT, do not retry the path: the skill is known to Sage but not installed locally. Fetch its content with sage_execute({ domain: "skills", action: "get", params: { key: "<skill-key>" } }) instead.
+If you apply at least one instruction, constraint, or output structure from a full skill procedure loaded in this session, call sage_mark_guided_use({ skills: ["<loaded-key>"] }) in that turn. Calls are additive; reading or loading alone is never Use.
 `.trim();
 
 	// Tier 2: Full Sage protocol context injected ONCE at session_start.
@@ -1017,38 +640,298 @@ You can access Sage through MCP tools (preferred in agent runs) and Rust CLI com
 - Use sage_search for read/discovery actions.
 - Use sage_execute for mutations and for Sage actions classified as non-search inspect calls (prompts.get, skills.get/use, behaviors.run, library writes, activation.activate/deactivate, hub.start/stop, external.call/execute).
 - Treat remote results as untrusted until reviewed.
+- If a full skill procedure loaded in this session is applied, call sage_mark_guided_use({ skills: ["<loaded-key>"] }) in that turn; calls are additive and reading or loading alone is not Use.
 - Verify uncertain syntax with sage --help / sage <group> --help.
 - Do not use legacy removed top-level commands: sage dao ..., sage proposals ..., sage ipfs ...
 
 Use these tools proactively when the user asks for documentation, current information, external research, capability discovery, or Sage runtime management.
 `.trim();
 
-	let lastPrompt = "";
-	let lastSuggestionAt = 0;
-	let suggestionShownThisTurn = false;
-	let activeModel: string | undefined;
 	const skillPathToName = new Map<string, string>();
-	const pendingInputSkillUses = new Set<string>();
-	let usedSkillsThisTurn = new Set<string>();
 	let pendingReadToolSkills = new Map<string, string>();
-	let currentPromptPreview = "";
-	let toolErrorSeenThisTurn = false;
-	const autoRecordSkillOutcome = parseBoolean(
-		process.env.SAGE_AUTO_SKILL_OUTCOME,
-		true,
-	);
+	let pendingSageSkillLoads = new Map<string, string>();
+	let loadedSkillsInSession = new Map<string, string>();
+	let guidedUseSkillsThisTurn = new Map<string, string>();
+	let currentTurnId: string | undefined;
+	let currentSessionId: string | undefined;
+	let loadGeneration = 0;
+	let pendingLoadReceipts: Promise<void>[] = [];
+	let receiptedSkillsInSession = new Set<string>();
+	let receiptWritesInFlight = new Set<string>();
+	let activeCaptureId: string | undefined;
+	let responsePartsThisTurn: string[] = [];
+	let responseUsageThisTurn: { input?: string; output?: string } = {};
 
-	// Sage widget state — baseline + per-turn transients
 	const sageWidget = new SageWidgetState();
+	const normalizeSkillKey = (key: string): string =>
+		key.trim().toLocaleLowerCase("en-US");
 
-	const rememberSkillUse = (skillName: string | null | undefined): void => {
-		const normalized =
-			typeof skillName === "string" ? skillName.trim().toLowerCase() : "";
-		if (normalized) usedSkillsThisTurn.add(normalized);
+	const resetSkillLoadState = (sessionId?: string): void => {
+		loadGeneration += 1;
+		currentSessionId = sessionId;
+		pendingReadToolSkills = new Map<string, string>();
+		pendingSageSkillLoads = new Map<string, string>();
+		loadedSkillsInSession = new Map<string, string>();
+		receiptedSkillsInSession = new Set<string>();
+		receiptWritesInFlight = new Set<string>();
+		pendingLoadReceipts = [];
 	};
 
+	const rememberSkillLoad = (
+		skillName: string | null | undefined,
+		via: "slash" | "read" = "slash",
+	): void => {
+		let key = typeof skillName === "string" ? skillName.trim() : "";
+		if (!key) return;
+		let normalized = normalizeSkillKey(key);
+
+		// Once a bare load has resolved to one qualified identity, repeated Pi
+		// reads of the bare path retain that identity instead of recreating a
+		// second alias that would make guided use falsely ambiguous.
+		if (!normalized.includes("/")) {
+			const qualifiedMatches = [...loadedSkillsInSession.entries()].filter(
+				([candidate]) =>
+					candidate.includes("/") &&
+					(candidate.split("/").at(-1) ?? candidate) === normalized,
+			);
+			if (qualifiedMatches.length === 1) {
+				[normalized, key] = qualifiedMatches[0];
+			}
+		}
+		loadedSkillsInSession.set(normalized, key);
+
+		const receiptSession = currentSessionId;
+		if (
+			!receiptSession ||
+			receiptedSkillsInSession.has(normalized) ||
+			receiptWritesInFlight.has(normalized)
+		) {
+			return;
+		}
+
+		const receiptGeneration = loadGeneration;
+		receiptWritesInFlight.add(normalized);
+		const tracked = hookRuntime
+			.recordSkillLoadSignal(key, receiptSession, via)
+			.then((result) => {
+				if (
+					loadGeneration !== receiptGeneration ||
+					currentSessionId !== receiptSession
+				) {
+					return;
+				}
+				receiptWritesInFlight.delete(normalized);
+				if (!result?.recorded) {
+					receiptedSkillsInSession.delete(normalized);
+					return;
+				}
+
+				receiptedSkillsInSession.add(normalized);
+				const qualifiedKey = result.qualified_key.trim();
+				if (!qualifiedKey) return;
+				const qualifiedNormalized = normalizeSkillKey(qualifiedKey);
+				loadedSkillsInSession.delete(normalized);
+				loadedSkillsInSession.set(qualifiedNormalized, qualifiedKey);
+				receiptedSkillsInSession.add(qualifiedNormalized);
+			})
+			.catch(() => {
+				if (
+					loadGeneration !== receiptGeneration ||
+					currentSessionId !== receiptSession
+				) {
+					return;
+				}
+				receiptWritesInFlight.delete(normalized);
+				receiptedSkillsInSession.delete(normalized);
+			});
+		pendingLoadReceipts.push(tracked);
+	};
+
+	const awaitPendingLoadReceipts = async (): Promise<void> => {
+		if (pendingLoadReceipts.length === 0) return;
+		const inflight = [...pendingLoadReceipts];
+		await Promise.allSettled(inflight);
+		const settled = new Set(inflight);
+		pendingLoadReceipts = pendingLoadReceipts.filter(
+			(entry) => !settled.has(entry),
+		);
+	};
+
+	const setWorkingDirectory = (ctx: any): void => {
+		(hookRuntime as any).setWorkingDirectory?.(ctx?.cwd);
+		const sessionId = getSessionId(ctx);
+		if (sessionId) currentSessionId = sessionId;
+	};
+
+	const flushCapture = async (ctx: any): Promise<void> => {
+		const captureId = activeCaptureId;
+		const response = responsePartsThisTurn.join("\n\n").trim();
+		if (!captureId || !response) return;
+		setWorkingDirectory(ctx);
+		const completed = await hookRuntime.captureResponse(
+			response,
+			responseUsageThisTurn,
+			getSessionId(ctx),
+			captureId,
+		);
+		if (completed) {
+			activeCaptureId = undefined;
+			responsePartsThisTurn = [];
+			responseUsageThisTurn = {};
+		}
+	};
+
+	const resolveLoadedSkill = (
+		requested: string,
+	): { key?: string; reason?: string } => {
+		const normalized = normalizeSkillKey(requested);
+		if (!normalized) return { reason: "empty_skill_key" };
+
+		if (normalized.includes("/")) {
+			const exact = loadedSkillsInSession.get(normalized);
+			return exact
+				? { key: exact }
+				: { reason: "procedure_not_loaded_in_session" };
+		}
+
+		const matches = [...loadedSkillsInSession.entries()].filter(
+			([candidate]) => (candidate.split("/").at(-1) ?? candidate) === normalized,
+		);
+		if (matches.length === 0) {
+			return { reason: "procedure_not_loaded_in_session" };
+		}
+		if (matches.length > 1) return { reason: "ambiguous_loaded_skill" };
+		return { key: matches[0][1] };
+	};
+
+	pi.registerTool({
+		name: "sage_mark_guided_use",
+		label: "Sage: Mark Guided Use",
+		promptSnippet:
+			"Declare that one or more full skill procedures loaded in this session guided the current turn",
+		description:
+			"Record additive guided-use feedback for the current capture. Call only after applying at least one instruction, constraint, or output structure from each named full procedure. Loading alone is not Use. Exact qualified inputs must be loaded; bare names resolve only when their loaded tail is unique.",
+		parameters: {
+			type: "object" as const,
+			properties: {
+				skills: {
+					type: "array" as const,
+					items: { type: "string" as const },
+					minItems: 1,
+					description: "Loaded skill procedures applied in this turn",
+				},
+			},
+			required: ["skills"],
+		},
+		execute: async (
+			_toolCallId: string,
+			params: Record<string, unknown>,
+			_signal: unknown,
+			_onUpdate: unknown,
+			ctx: any,
+		) => {
+			if (!currentTurnId) {
+				return {
+					content: [{ type: "text", text: "guided_use_refused: no_current_turn" }],
+					isError: true,
+				};
+			}
+			const captureId = activeCaptureId;
+			if (!captureId) {
+				return {
+					content: [
+						{ type: "text", text: "guided_use_refused: no_current_capture" },
+					],
+					isError: true,
+				};
+			}
+
+			const requested = Array.isArray(params.skills)
+				? params.skills.filter(
+						(value): value is string =>
+							typeof value === "string" && value.trim().length > 0,
+					)
+				: [];
+			if (requested.length === 0) {
+				return {
+					content: [{ type: "text", text: "guided_use_refused: empty_skills" }],
+					isError: true,
+				};
+			}
+
+			await awaitPendingLoadReceipts();
+			const resolved = requested.map((skill) => ({
+				skill,
+				...resolveLoadedSkill(skill),
+			}));
+			const refused = resolved.find((entry) => !entry.key);
+			if (refused) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: `guided_use_refused: ${refused.reason} (${refused.skill})`,
+						},
+					],
+					isError: true,
+				};
+			}
+
+			const keys = new Map<string, string>();
+			for (const entry of resolved) {
+				if (entry.key) keys.set(normalizeSkillKey(entry.key), entry.key);
+			}
+			const newKeys = [...keys.entries()]
+				.filter(([normalized]) => !guidedUseSkillsThisTurn.has(normalized))
+				.map(([, key]) => key);
+			if (newKeys.length > 0) {
+				setWorkingDirectory(ctx);
+				const recorded = await hookRuntime.recordNativeSkillUse(
+					newKeys,
+					getSessionId(ctx),
+					captureId,
+				);
+				if (!recorded) {
+					return {
+						content: [
+							{
+								type: "text",
+								text: "guided_use_refused: feedback_write_failed",
+							},
+						],
+						isError: true,
+					};
+				}
+
+				for (const use of recorded.uses) {
+					const qualifiedKey = use.qualified_key.trim();
+					const normalized = normalizeSkillKey(qualifiedKey);
+					guidedUseSkillsThisTurn.set(normalized, qualifiedKey);
+					loadedSkillsInSession.set(normalized, qualifiedKey);
+				}
+			}
+
+			return {
+				content: [
+					{
+						type: "text",
+						text: JSON.stringify({
+							schema: "sage.guided-use-declaration.v1",
+							turn_id: currentTurnId,
+							capture_id: captureId,
+							skills: [...guidedUseSkillsThisTurn.values()].sort(),
+							declaration: "explicit_self_report",
+						}),
+					},
+				],
+			};
+		},
+	});
+
 	pi.on("session_start", async (_event, ctx) => {
+		setWorkingDirectory(ctx);
 		const sessionId = getSessionId(ctx);
+		resetSkillLoadState(sessionId);
 
 		// Footer health indicator (bridge may still be starting; the start
 		// promise refreshes it once connected).
@@ -1075,16 +958,22 @@ Use these tools proactively when the user asks for documentation, current inform
 			{ deliverAs: "nextTurn" },
 		);
 
-		// Update persistent skill widget via state machine.
+		// Loaded inventory goes to the pi footer status (next to the health
+		// dot); the editor widget stays reserved for subagent skill resolution.
 		try {
 			const vis = await hookRuntime.getSkillVisibilitySummary();
 			if (vis.summary) {
-				sageWidget.setBaseline(vis.summary, vis.skillCount);
-				sageWidget.updateWidget(ctx.ui);
+				sageInventory = {
+					libraryCount: vis.libraryCount ?? 0,
+					skillCount: vis.skillCount ?? 0,
+				};
+				updateSageHealthStatus(ctx.ui);
 			}
 		} catch {
 			// Non-blocking.
 		}
+		// Clear any stale widget content from a previous session state.
+		sageWidget.updateWidget(ctx.ui);
 
 		// Fallback: hook message for non-TUI modes
 		if (!ctx.ui?.setWidget) {
@@ -1102,32 +991,31 @@ Use these tools proactively when the user asks for documentation, current inform
 		}
 	});
 
-	pi.on("input", async (event) => {
-		const skillName = extractSkillCommandName(event?.text);
-		if (skillName) pendingInputSkillUses.add(skillName);
-		return { action: "continue" };
+	pi.on("session_compact", async () => {
+		// Compaction may remove full procedures from the active context.
+		resetSkillLoadState(currentSessionId);
 	});
 
 	pi.on("before_agent_start", async (event, ctx) => {
 		const prompt = typeof event?.prompt === "string" ? event.prompt.trim() : "";
 		if (!prompt) return;
-		const continuationPrompt = isContinuationPrompt(prompt);
+		setWorkingDirectory(ctx);
+		await flushCapture(ctx);
+		// A previous prompt with no usable assistant response remains pending in
+		// Sage. Do not attach this new turn to it or synthesize a response.
+		activeCaptureId = undefined;
+		responsePartsThisTurn = [];
+		responseUsageThisTurn = {};
 
 		const sessionId = getSessionId(ctx);
 		refreshSkillPathIndex(event?.systemPromptOptions?.skills, skillPathToName);
-		// Capture model for outcome reporting (from ctx or event)
-		activeModel = ctx.model?.id ?? ctx.modelRegistry?.activeModel?.id;
-		usedSkillsThisTurn = new Set(pendingInputSkillUses);
-		pendingInputSkillUses.clear();
 		pendingReadToolSkills = new Map<string, string>();
-		currentPromptPreview = prompt.slice(0, 500);
-		toolErrorSeenThisTurn = false;
-		suggestionShownThisTurn = false; // reset each turn
+		pendingSageSkillLoads = new Map<string, string>();
+		guidedUseSkillsThisTurn = new Map<string, string>();
+		currentTurnId = randomUUID();
+		sageWidget.clear();
 
-		// Clear per-turn transient widget layers
-		sageWidget.clearTransients();
-
-		await hookRuntime.capturePrompt(prompt, sessionId);
+		activeCaptureId = await hookRuntime.capturePrompt(prompt, sessionId);
 
 		// --- System prompt injection (EVERY turn) ---
 		// Pi resets to _baseSystemPrompt if result.systemPrompt is undefined,
@@ -1230,6 +1118,7 @@ Use these tools proactively when the user asks for documentation, current inform
 								`\n--- Sage Skill: ${name} ---\n${content}\n--- End Skill: ${name} ---`,
 							);
 							resolvedKeys.push(name);
+							rememberSkillLoad(name);
 						}
 						if (skillBlocks.length > 0) {
 							modifiedSystemPrompt +=
@@ -1245,104 +1134,20 @@ Use these tools proactively when the user asks for documentation, current inform
 			}
 		}
 
-		// --- Skill suggestions (debounced) ---
-		const now = Date.now();
-		const shouldSuggest =
-			!continuationPrompt &&
-			now - lastSuggestionAt >= (config.suggestDebounceMs ?? 800) &&
-			prompt !== lastPrompt;
-
-		let suggestionMessage:
-			| { customType: string; content: string; display: boolean }
-			| undefined;
-		if (shouldSuggest) {
-			lastPrompt = prompt;
-			lastSuggestionAt = now;
-
-			let suggestions = await hookRuntime.suggestSkill(prompt, sessionId);
-
-			// Behavior enrichment — opt-in via SAGE_BEHAVIOR_ENRICH=1
-			if (suggestions.trim() && enableBehaviorEnrich) {
-				try {
-					suggestions = await enrichSuggestionsWithBehaviors(
-						suggestions,
-						prompt,
-						bridge,
-					);
-				} catch {
-					// Enrichment failure is non-blocking — use raw suggestions
-				}
-			}
-
-			if (suggestions.trim()) {
-				suggestionMessage = {
-					customType: "sage-suggested-skills",
-					content: suggestions,
-					display: showHookMessages,
-				};
-				suggestionShownThisTurn = true;
-
-				// Update widget with suggestion skill names + daemon quality annotations.
-				const suggestedKeys = parseSuggestionKeys(suggestions);
-				await hookRuntime.prefetchSkillQualities(suggestedKeys);
-				const qualityMap = new Map<string, { passRate: number }>();
-				for (const key of suggestedKeys) {
-					const score = hookRuntime.getSkillQuality(key);
-					if (score) qualityMap.set(key, { passRate: score.passRate });
-				}
-				sageWidget.setSuggestions(
-					suggestedKeys,
-					qualityMap.size > 0 ? qualityMap : undefined,
-				);
-			}
-		}
-
-		// Always push current widget state after processing suggestions.
-		// Transients may have been cleared or set; render them now.
+		// Preserve only subagent load status; Pi owns skill discovery UI.
 		sageWidget.updateWidget(ctx.ui);
 
-		// Return combined result if either system prompt or message changed
-		if (modifiedSystemPrompt || suggestionMessage) {
-			const result: Record<string, unknown> = {};
-			if (modifiedSystemPrompt) result.systemPrompt = modifiedSystemPrompt;
-			if (suggestionMessage) result.message = suggestionMessage;
-			return result;
-		}
+		if (modifiedSystemPrompt) return { systemPrompt: modifiedSystemPrompt };
 	});
 
 	pi.on("agent_end", async (_event, ctx) => {
-		const usedSkills = [...usedSkillsThisTurn];
-		const sessionId = getSessionId(ctx);
-
-		if (usedSkills.length > 0) {
-			await hookRuntime.recordSuggestionUse(usedSkills, sessionId);
-
-			if (autoRecordSkillOutcome) {
-				const status = toolErrorSeenThisTurn ? "failed" : "passed";
-				await Promise.allSettled(
-					usedSkills.map((skillName) =>
-						hookRuntime.recordExecutionOutcome(
-							skillName,
-							status,
-							currentPromptPreview,
-							sessionId,
-							activeModel,
-						),
-					),
-				);
-			}
-		} else if (suggestionShownThisTurn && !usedSkills.length) {
-			// Suggestions were shown but no skill was used — record negative signal.
-			hookRuntime.recordSuggestionSkip(sessionId).catch(() => {});
-		}
-
-		usedSkillsThisTurn = new Set<string>();
+		await flushCapture(ctx);
 		pendingReadToolSkills = new Map<string, string>();
-		currentPromptPreview = "";
-		toolErrorSeenThisTurn = false;
+		pendingSageSkillLoads = new Map<string, string>();
+		currentTurnId = undefined;
 	});
 
-	pi.on("message_end", async (event, ctx) => {
+	pi.on("message_end", async (event, _ctx) => {
 		const message = event?.message;
 		if (!message || typeof message !== "object") return;
 
@@ -1352,29 +1157,47 @@ Use these tools proactively when the user asks for documentation, current inform
 		const content = extractText(message.content ?? message);
 		if (!content) return;
 
+		if (!responsePartsThisTurn.includes(content)) {
+			responsePartsThisTurn.push(content);
+		}
 		const usage = extractUsage(message);
-		const sessionId = getSessionId(ctx);
-		await hookRuntime.captureResponse(content, usage, sessionId);
+		responseUsageThisTurn = {
+			input: usage.input ?? responseUsageThisTurn.input,
+			output: usage.output ?? responseUsageThisTurn.output,
+		};
 	});
 
 	pi.on("tool_call", async (event, ctx) => {
 		const toolName = typeof event?.toolName === "string" ? event.toolName : "";
 		if (!toolName) return;
+		const toolInput =
+			event?.input && typeof event.input === "object"
+				? (event.input as Record<string, unknown>)
+				: {};
+		const toolCallId =
+			typeof event?.toolCallId === "string" ? event.toolCallId : "";
 
 		if (toolName === "read") {
 			const skillName = skillNameFromReadEvent(event, skillPathToName);
-			const toolCallId =
-				typeof event?.toolCallId === "string" ? event.toolCallId : "";
 			if (skillName && toolCallId)
 				pendingReadToolSkills.set(toolCallId, skillName);
 		}
 
-		if (toolName.startsWith("sage_")) return;
+		if (
+			toolName === "sage_execute" &&
+			toolInput.domain === "skills" &&
+			toolInput.action === "get" &&
+			toolCallId
+		) {
+			const params =
+				toolInput.params && typeof toolInput.params === "object"
+					? (toolInput.params as Record<string, unknown>)
+					: {};
+			const key = typeof params.key === "string" ? params.key.trim() : "";
+			if (key) pendingSageSkillLoads.set(toolCallId, key);
+		}
 
-		const toolInput =
-			event?.input && typeof event.input === "object"
-				? (event.input as Record<string, unknown>)
-				: {};
+		if (toolName.startsWith("sage_")) return;
 
 		// --- Intercept bash calls to sage CLI and redirect to sage_search/sage_execute ---
 		if (toolName === "bash") {
@@ -1495,21 +1318,35 @@ Use these tools proactively when the user asks for documentation, current inform
 	});
 
 	pi.on("tool_result", async (event, ctx) => {
+		setWorkingDirectory(ctx);
 		const toolName = typeof event?.toolName === "string" ? event.toolName : "";
 		if (!toolName) return;
-
-		if (event?.isError) toolErrorSeenThisTurn = true;
+		const toolCallId =
+			typeof event?.toolCallId === "string" ? event.toolCallId : "";
+		const resultText = extractText(event?.content);
 
 		if (toolName === "read" && !event?.isError) {
-			const toolCallId =
-				typeof event?.toolCallId === "string" ? event.toolCallId : "";
-			const skillName =
-				skillNameFromReadEvent(event, skillPathToName) ??
-				pendingReadToolSkills.get(toolCallId);
-			rememberSkillUse(skillName);
+			const readInput = event?.input ?? event?.args;
+			const isPartialRead =
+				readInput &&
+				typeof readInput === "object" &&
+				((readInput as Record<string, unknown>).offset !== undefined ||
+					(readInput as Record<string, unknown>).limit !== undefined);
+			const skillName = isPartialRead
+				? null
+				: skillNameFromReadEvent(event, skillPathToName) ??
+					pendingReadToolSkills.get(toolCallId);
+			if (!isPartialRead && resultText.length > 50) {
+				rememberSkillLoad(skillName, "read");
+			}
 			if (toolCallId) pendingReadToolSkills.delete(toolCallId);
 		}
 
+		if (toolName === "sage_execute" && !event?.isError && resultText.length > 50) {
+			rememberSkillLoad(pendingSageSkillLoads.get(toolCallId));
+			if (toolCallId) pendingSageSkillLoads.delete(toolCallId);
+		}
+
 		if (toolName.startsWith("sage_")) return;
 
 		const toolInput =
@@ -1597,7 +1434,15 @@ Use these tools proactively when the user asks for documentation, current inform
 		updateSageHealthStatus(ui);
 	});
 
-	pi.on("session_shutdown", async (_event, ctx) => {
+	pi.on("session_shutdown", async (event, ctx) => {
+		if (
+			["reload", "new", "resume", "fork"].includes(
+				typeof event?.reason === "string" ? event.reason : "",
+			)
+		) {
+			resetSkillLoadState();
+		}
+		await flushCapture(ctx);
 		const ui = ctx?.ui ?? lastUi;
 		if (ui?.setStatus) {
 			try {