@fiale-plus/pi-rogue-advisor 0.1.6 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fiale-plus/pi-rogue-advisor",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Pi-Rogue advisor extension for Pi — multi-model support, SOTA model suggestion, cache-aware session advisory.",
   "type": "module",
   "license": "MIT",

package/skills/advisor/SKILL.md

@@ -12,7 +12,7 @@ Use this skill for non-trivial decisions before/after significant edits.
 - `/pi-rogue` — open cockpit and command pointers
 - `/advisor status` — show current advisor settings and model route
 - `/advisor <question>` — ask immediate advice
-- `/advisor checkins on|off|<minutes>` — control low-power check-ins
+- Check-ins are lifecycle-managed by `/loop`, not by the advisor command surface
 
 ## Command surface
 
@@ -24,7 +24,6 @@ Use this skill for non-trivial decisions before/after significant edits.
 | `/advisor off` | Disable advisor |
 | `/advisor mode auto\|manual\|off` | Control when advisor auto-runs |
 | `/advisor review light\|strict\|off` | Set review threshold |
-| `/advisor checkins on\|off\|<minutes>` | Configure interval check-ins |
 | `/advisor config` | Dump full config |
 | `/advisor model <provider/model>` | Pin model explicitly |
 | `/advisor <question>` | Run one advisory response |
@@ -33,7 +32,7 @@ Use this skill for non-trivial decisions before/after significant edits.
 
 - Preflight is heuristics + quick local gate first.
 - Review runs after edits and/or at completion points by policy.
-- No hidden long-running background daemon: check-ins are interval-gated and lightweight.
+- No standalone check-in command: check-ins are triggered from loop cadence (not from advisor internals), using higher/advanced advisor models first with regular model fallback enabled by default.
 
 ## Keep scope clear
 
@@ -43,6 +42,6 @@ The advisor surface is separate from orchestration (`goal`/`loop`/`autoresearch`
 
 - `mode: auto`
 - `review: light`
-- `checkins: off` by default; orchestration enables them while a goal/autoresearch flow is active
+- `checkins: off` by default; loop orchestration owns cadence and enables them when active
 - `checkinIntervalMinutes: 30`
 - `model: auto`

package/src/completions.test.ts

@@ -4,7 +4,8 @@ import { advisorArgumentCompletions, piRogueArgumentCompletions } from "./comple
 describe("advisor completions", () => {
   it("offers top-level advisor continuations", () => {
     const values = advisorArgumentCompletions("")?.map((i) => i.value);
-    expect(values).toEqual(expect.arrayContaining(["status", "config", "checkins", "review"]));
+    expect(values).toEqual(expect.arrayContaining(["status", "config", "model", "review"]));
+    expect(values).not.toContain("checkins");
   });
 
   it("offers nested review choices", () => {
@@ -12,10 +13,6 @@ describe("advisor completions", () => {
     expect(values).toEqual(["light", "strict", "off"]);
   });
 
-  it("offers check-in choices", () => {
-    const values = advisorArgumentCompletions("checkins ")?.map((i) => i.value);
-    expect(values).toEqual(expect.arrayContaining(["on", "off", "30", "60"]));
-  });
 });
 
 describe("pi-rogue cockpit completions", () => {

package/src/completions.ts

@@ -40,24 +40,19 @@ const advisorTopLevel: Array<[string, string?]> = [
   ["off", "disable advisor"],
   ["mode", "set auto/manual/off"],
   ["review", "set light/strict/off"],
-  ["checkins", "configure mid-hour check-ins"],
-  ["checkin", "alias for checkins"],
   ["model", "set or inspect model override"],
 ];
 
 const advisorNested: Record<string, Array<[string, string?]>> = {
   mode: [["auto"], ["manual"], ["off"]],
   review: [["light"], ["strict"], ["off"]],
-  checkins: [["on"], ["off"], ["10"], ["15"], ["30"], ["60"]],
-  checkin: [["on"], ["off"], ["10"], ["15"], ["30"], ["60"]],
   model: [["auto"], ["openai-codex/gpt-5.5"], ["anthropic/claude-opus-4-6"]],
 };
 
 const piRogueTopLevel: Array<[string, string?]> = [
   ["status", "show cockpit"],
-  ["advisor", "advisor status and check-ins"],
+  ["advisor", "advisor status"],
   ["orchestration", "goal/loop/autoresearch shortcuts"],
-  ["checkins", "advisor check-ins"],
   ["help", "show cockpit help"],
 ];
 
@@ -70,8 +65,7 @@ const piRogueNested: Record<string, Array<[string, string?]>> = {
     ["autoresearch-lab", "parallel research flow"],
     ["status", "show all surfaces"],
   ],
-  checkins: advisorNested.checkins,
-  help: [["advisor"], ["orchestration"], ["checkins"], ["status"]],
+  help: [["advisor"], ["orchestration"], ["status"]],
 };
 
 export function advisorArgumentCompletions(prefix: string): CompletionItem[] | null {

package/src/extension.test.ts

@@ -1,5 +1,14 @@
-import { describe, it, expect } from "vitest";
-import { normalizeAdvisorConfig, shouldRunCheckin, type AdvisorConfig } from "./extension.js";
+import { describe, expect, it, vi } from "vitest";
+import { completeSimple } from "@earendil-works/pi-ai";
+import { normalizeAdvisorConfig, shouldRunCheckin, type AdvisorConfig, completeWithHigherAdvisorModel, completeWithModelFallback } from "./extension.js";
+
+vi.mock("@earendil-works/pi-ai", async () => {
+  const actual = await vi.importActual<typeof import("@earendil-works/pi-ai")>("@earendil-works/pi-ai");
+  return {
+    ...actual,
+    completeSimple: vi.fn(),
+  };
+});
 
 function state(overrides: Record<string, unknown> = {}) {
   return {
@@ -89,6 +98,80 @@ describe("mid-hour check-ins", () => {
     const cfg = normalizeAdvisorConfig({ checkins: "off" });
     expect(shouldRunCheckin(cfg, state(), 999999, 1)).toBeNull();
   });
+
+  it("flushes queued check-in regardless of turn delta", () => {
+    const cfg = normalizeAdvisorConfig({ checkins: "mid-hour", checkinIntervalMinutes: 30 });
+    expect(
+      shouldRunCheckin(cfg, state({
+        checkin: {
+          queued: true,
+          queuedReason: "queued mid-session check-in",
+        },
+      })),
+    ).toBe("queued mid-session check-in");
+  });
+});
+
+
+describe("advisor completion fallback behavior", () => {
+  function mkCtx(allowHighTier: boolean, includeRegular = true) {
+    const high = { id: "openai-codex/gpt-5.5", provider: "openai-codex", input: ["text"] };
+    const regular = { id: "provider/text-light", provider: "provider", input: ["text"] };
+    return {
+      modelRegistry: {
+        find: (_provider: string, model: string) => {
+          if (!allowHighTier) return null;
+          if (_provider === "openai-codex" && model === "gpt-5.5") return high;
+          if (_provider === "anthropic" && model === "claude-opus-4-6") return { ...high, id: "anthropic/claude-opus-4-6" };
+          if (_provider === "anthropic" && model === "claude-sonnet-4-6") return { ...high, id: "anthropic/claude-sonnet-4-6" };
+          if (_provider === "openai-codex" && model === "gpt-5.4-mini") return { ...high, id: "openai-codex/gpt-5.4-mini" };
+          return null;
+        },
+        getAvailable: () => (includeRegular ? [regular] : []),
+        getApiKeyAndHeaders: async (_model: unknown) => ({ ok: true, apiKey: "k", headers: {} }),
+      },
+    } as any;
+  }
+
+  it("uses high/advanced models first for check-in completion", async () => {
+    const completeSimpleMock = vi.mocked(completeSimple as any);
+    completeSimpleMock.mockReset();
+    completeSimpleMock.mockResolvedValue({ content: [{ type: "text", text: "ok" }] });
+
+    const cfg = normalizeAdvisorConfig({ mode: "auto", review: "light" });
+    const result = await completeWithHigherAdvisorModel(mkCtx(true, true), cfg, "system", [{ role: "user", content: "x" }], { maxTokens: 128, reasoning: "low" as const });
+
+    expect(result).not.toBeNull();
+    expect(completeSimpleMock).toHaveBeenCalledTimes(1);
+    expect(completeSimpleMock.mock.calls[0]?.[0]?.id).toBe("openai-codex/gpt-5.5");
+  });
+
+  it("falls back to regular models for check-in completion when high/advanced are unavailable", async () => {
+    const completeSimpleMock = vi.mocked(completeSimple as any);
+    completeSimpleMock.mockReset();
+    completeSimpleMock.mockResolvedValue({ content: [{ type: "text", text: "ok" }] });
+
+    const cfg = normalizeAdvisorConfig({ mode: "auto", review: "light" });
+    const result = await completeWithHigherAdvisorModel(mkCtx(false, true), cfg, "system", [{ role: "user", content: "x" }], { maxTokens: 128, reasoning: "low" as const });
+
+    expect(result).not.toBeNull();
+    expect(completeSimpleMock).toHaveBeenCalledTimes(1);
+    expect(completeSimpleMock.mock.calls[0]?.[0]?.id).toBe("provider/text-light");
+  });
+
+  it("uses regular fallback for non-checkin completion", async () => {
+    const completeSimpleMock = vi.mocked(completeSimple as any);
+    completeSimpleMock.mockReset();
+    completeSimpleMock.mockResolvedValue({ content: [{ type: "text", text: "ok" }] });
+
+    const cfg = normalizeAdvisorConfig({ mode: "auto", review: "light" });
+    const result = await completeWithModelFallback(mkCtx(false), cfg, "system", [{ role: "user", content: "x" }], { maxTokens: 128, reasoning: "low" as const });
+
+    expect(result).not.toBeNull();
+    expect(result?.fallback).toBe(true);
+    expect(completeSimpleMock).toHaveBeenCalledTimes(1);
+    expect(completeSimpleMock.mock.calls[0]?.[0]?.id).toBe("provider/text-light");
+  });
 });