@juicesharp/rpiv-advisor 1.6.0 → 1.7.0

package/advisor.ts

@@ -22,10 +22,10 @@ import { completeSimple, getSupportedThinkingLevels, type Message, type Thinking
 import {
 	type AgentToolResult,
 	type AgentToolUpdateCallback,
+	buildSessionContext,
 	convertToLlm,
 	type ExtensionAPI,
 	type ExtensionContext,
-	type SessionEntry,
 	type ToolInfo,
 } from "@earendil-works/pi-coding-agent";
 import type { SelectItem } from "@earendil-works/pi-tui";
@@ -84,6 +84,10 @@ const msgAdvisorEnabled = (label: string, effort: ThinkingLevel | undefined) =>
 	`Advisor: ${label}${effort ? `, ${effort}` : ""}`;
 const msgAdvisorRestored = (label: string, effort: ThinkingLevel | undefined) =>
 	`Advisor restored: ${label}${effort ? `, ${effort}` : ""}`;
+const msgAdvisorRestoredInactive = (label: string, effort: ThinkingLevel | undefined) =>
+	`Advisor restored: ${label}${effort ? `, ${effort}` : ""} (inactive for current executor)`;
+const msgAdvisorEnabledInactive = (label: string, effort: ThinkingLevel | undefined) =>
+	`Advisor: ${label}${effort ? `, ${effort}` : ""} (inactive for current executor)`;
 const msgConsulting = (label: string, effort: ThinkingLevel | undefined) =>
 	`Consulting advisor (${label}${effort ? `, ${effort}` : ""})…`;
 
@@ -100,6 +104,7 @@ interface AdvisorConfig {
 	modelKey?: string;
 	effort?: ThinkingLevel;
 	guidance?: GuidanceFields;
+	disabledForModels?: string[];
 }
 
 export function loadAdvisorConfig(): AdvisorConfig {
@@ -128,6 +133,11 @@ function validateGuidanceFields(fields: unknown): GuidanceFields {
 	return result;
 }
 
+function validateDisabledForModels(value: unknown): string[] {
+	if (!Array.isArray(value)) return [];
+	return value.filter((entry): entry is string => typeof entry === "string" && entry.length > 0);
+}
+
 export function saveAdvisorConfig(key: string | undefined, effort: ThinkingLevel | undefined): void {
 	const existing = loadAdvisorConfig();
 	const config: AdvisorConfig = { ...existing };
@@ -297,12 +307,21 @@ export function setAdvisorEffort(effort: ThinkingLevel | undefined): void {
 	selectedAdvisorEffort = effort;
 }
 
+let disabledForModelsCache: string[] = [];
+
+export function setDisabledForModels(models: string[]): void {
+	disabledForModelsCache = models;
+}
+
 // ---------------------------------------------------------------------------
 // Session restoration — called from index.ts session_start handler
 // ---------------------------------------------------------------------------
 
 export function restoreAdvisorState(ctx: ExtensionContext, pi: ExtensionAPI): void {
 	const config = loadAdvisorConfig();
+
+	setDisabledForModels(validateDisabledForModels(config.disabledForModels));
+
 	if (!config.modelKey) return;
 
 	const parsed = parseModelKey(config.modelKey);
@@ -321,6 +340,14 @@ export function restoreAdvisorState(ctx: ExtensionContext, pi: ExtensionAPI): vo
 		setAdvisorEffort(config.effort);
 	}
 
+	if (isExecutorBlocked(ctx)) {
+		if (ctx.hasUI) {
+			const advisorLabel = `${model.provider}:${model.id}`;
+			ctx.ui.notify(msgAdvisorRestoredInactive(advisorLabel, config.effort), "info");
+		}
+		return;
+	}
+
 	const active = pi.getActiveTools();
 	if (!active.includes(ADVISOR_TOOL_NAME)) {
 		pi.setActiveTools([...active, ADVISOR_TOOL_NAME]);
@@ -377,14 +404,16 @@ async function executeAdvisor(
 	}
 
 	// Live-read every call — advisor runs mid-turn so any message_end snapshot
-	// is always one turn stale. convertToLlm is pass-through for user/assistant/
-	// toolResult (messages.js:111-114), so element refs are stable across calls
-	// via the session store — content-stable output without a snapshot layer.
-	const branch = ctx.sessionManager.getBranch();
-	const agentMessages = branch
-		.filter((e): e is SessionEntry & { type: "message" } => e.type === "message")
-		.map((e) => e.message);
-	const branchMessages = ensureUserTailForAdvisor(stripInflightAdvisorCall(convertToLlm(agentMessages)));
+	// is always one turn stale. buildSessionContext() preserves Pi's resolved
+	// LLM context, including compaction summaries and branch summaries, instead
+	// of replaying raw pre-compaction branch messages. convertToLlm is
+	// pass-through for user/assistant/toolResult (messages.js:111-114), so
+	// element refs are stable across calls via the session store.
+	const { messages: sessionMessages } = buildSessionContext(
+		ctx.sessionManager.getEntries(),
+		ctx.sessionManager.getLeafId(),
+	);
+	const branchMessages = ensureUserTailForAdvisor(stripInflightAdvisorCall(convertToLlm(sessionMessages)));
 	const inventoryMessage = getInventoryMessage(pi.getAllTools());
 	const messages: Message[] = inventoryMessage ? [inventoryMessage, ...branchMessages] : branchMessages;
 
@@ -509,8 +538,9 @@ export function registerAdvisorTool(pi: ExtensionAPI): void {
 // ---------------------------------------------------------------------------
 
 export function registerAdvisorBeforeAgentStart(pi: ExtensionAPI): void {
-	pi.on("before_agent_start", async () => {
-		if (!getAdvisorModel()) {
+	pi.on("before_agent_start", async (_event, ctx) => {
+		const shouldStrip = !getAdvisorModel() || isExecutorBlocked(ctx);
+		if (shouldStrip) {
 			const active = pi.getActiveTools();
 			if (active.includes(ADVISOR_TOOL_NAME)) {
 				pi.setActiveTools(active.filter((n) => n !== ADVISOR_TOOL_NAME));
@@ -519,6 +549,38 @@ export function registerAdvisorBeforeAgentStart(pi: ExtensionAPI): void {
 	});
 }
 
+// ---------------------------------------------------------------------------
+// model_select handler — mid-session model switches strip/re-add advisor
+// ---------------------------------------------------------------------------
+
+export function registerModelSelectHandler(pi: ExtensionAPI): void {
+	pi.on("model_select", async (event, ctx) => {
+		// session_start restore path is owned by restoreAdvisorState — it already
+		// activates the tool and notifies. Skipping "restore" here prevents a
+		// duplicate notification on initial model load.
+		if (event.source === "restore") return;
+
+		const advisor = getAdvisorModel();
+		if (!advisor) return;
+
+		const blocked = isModelBlocked(event.model);
+		const active = pi.getActiveTools();
+		const hasTool = active.includes(ADVISOR_TOOL_NAME);
+
+		if (blocked && hasTool) {
+			pi.setActiveTools(active.filter((n) => n !== ADVISOR_TOOL_NAME));
+			if (ctx.hasUI) {
+				ctx.ui.notify(`Advisor disabled for ${modelKey(event.model)}`, "info");
+			}
+		} else if (!blocked && !hasTool) {
+			pi.setActiveTools([...active, ADVISOR_TOOL_NAME]);
+			if (ctx.hasUI) {
+				ctx.ui.notify(msgAdvisorRestored(modelKey(advisor), getAdvisorEffort()), "info");
+			}
+		}
+	});
+}
+
 // ---------------------------------------------------------------------------
 // /advisor slash command — opens selector panel for picking the advisor model
 // ---------------------------------------------------------------------------
@@ -527,6 +589,15 @@ function modelKey(m: { provider: string; id: string }): string {
 	return `${m.provider}:${m.id}`;
 }
 
+function isModelBlocked(model: Model<Api> | undefined): boolean {
+	if (!model) return false;
+	return disabledForModelsCache.includes(modelKey(model));
+}
+
+function isExecutorBlocked(ctx: ExtensionContext): boolean {
+	return isModelBlocked(ctx?.model);
+}
+
 export function registerAdvisorCommand(pi: ExtensionAPI): void {
 	pi.registerCommand("advisor", {
 		description: "Configure the advisor model for the advisor-strategy pattern",
@@ -600,10 +671,20 @@ export function registerAdvisorCommand(pi: ExtensionAPI): void {
 			setAdvisorEffort(effortChoice);
 			setAdvisorModel(picked);
 			saveAdvisorConfig(modelKey(picked), effortChoice);
-			if (!activeHas) {
-				pi.setActiveTools([...activeTools, ADVISOR_TOOL_NAME]);
+
+			// Re-read after the effort-picker await — the snapshot taken before
+			// `showEffortPicker` is stale once execution yields.
+			const activeToolsNow = pi.getActiveTools();
+			const activeHasNow = activeToolsNow.includes(ADVISOR_TOOL_NAME);
+			const blocked = isExecutorBlocked(ctx);
+			if (!activeHasNow && !blocked) {
+				pi.setActiveTools([...activeToolsNow, ADVISOR_TOOL_NAME]);
+			}
+			if (blocked) {
+				ctx.ui.notify(msgAdvisorEnabledInactive(modelKey(picked), effortChoice), "info");
+			} else {
+				ctx.ui.notify(msgAdvisorEnabled(modelKey(picked), effortChoice), "info");
 			}
-			ctx.ui.notify(msgAdvisorEnabled(modelKey(picked), effortChoice), "info");
 		},
 	});
 }

package/index.ts

@@ -1,9 +1,9 @@
 /**
  * rpiv-advisor — Pi extension
  *
- * Registers the `advisor` tool, `/advisor` command, and the two lifecycle
- * hooks (session_start restore, before_agent_start strip) that together
- * implement the advisor-strategy pattern.
+ * Registers the `advisor` tool, `/advisor` command, and the three lifecycle
+ * hooks (session_start restore, before_agent_start strip, model_select
+ * re-evaluation) that together implement the advisor-strategy pattern.
  *
  * Config persists at ~/.config/rpiv-advisor/advisor.json. Tool name
  * preserved verbatim from rpiv-pi@7525a5d.
@@ -14,6 +14,7 @@ import {
 	registerAdvisorBeforeAgentStart,
 	registerAdvisorCommand,
 	registerAdvisorTool,
+	registerModelSelectHandler,
 	restoreAdvisorState,
 } from "./advisor.js";
 
@@ -21,6 +22,7 @@ export default function (pi: ExtensionAPI) {
 	registerAdvisorTool(pi);
 	registerAdvisorCommand(pi);
 	registerAdvisorBeforeAgentStart(pi);
+	registerModelSelectHandler(pi);
 
 	pi.on("session_start", async (_event, ctx) => {
 		restoreAdvisorState(ctx, pi);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juicesharp/rpiv-advisor",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Pi extension. A second opinion the model can request from a stronger reviewer model before it acts.",
   "keywords": [
     "pi-package",