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

package/README.md

@@ -1,14 +1,50 @@
 # @fiale-plus/pi-rogue-advisor
 
-PiRogue advisor: session coaching, phase-aware routing, mid-hour check-ins, and decision framing for Pi.
+## What this package is
 
-The bundled binary gate model is shipped with the package and auto-seeded on install.
+Strategic advisor for Pi sessions with low-overhead preflight/post-review routing, model auto-detection, session memory, and optional mid-session check-ins.
 
-Install locally from this repo root: `npm install`
+- SOTA-first model fallback: `gpt-5.5`/`claude-opus-4-6`/`claude-sonnet-4-6` where available.
+- Keeps command-level behavior simple and explicit.
 
-Published install: `pi install @fiale-plus/pi-rogue-advisor`
+## Install
 
-Useful commands:
+```bash
+# Published package (recommended)
+pi install npm:@fiale-plus/pi-rogue-advisor
+
+# Local package development
+npm install --workspace packages/advisor
+```
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `/pi-rogue` | Show the Pi-Rogue cockpit + command pointers |
+| `/advisor` | Show status (`/advisor status`) and quick hint |
+| `/advisor status` | Show mode, review policy, check-in status, model selection, counters |
+| `/advisor on` | Enable advisor (auto mode) |
+| `/advisor off` | Disable advisor |
+| `/advisor mode auto\|manual\|off` | Change routing behavior |
+| `/advisor review light\|strict\|off` | Change review strictness |
+| `/advisor checkins on\|off\|<minutes>` | Enable/disable low-cost mid-hour check-ins |
+| `/advisor config` | Show current config |
+| `/advisor model <provider>/<model>` | Set explicit model override |
+| `/advisor <question>` | Get one-shot advisory response |
+
+## Notes on defaults
+
+- `mode`: `auto`
+- `review`: `light`
+- `checkins`: `off` (orchestration turns them on while a goal/autoresearch flow is active)
+- `checkinIntervalMinutes`: `30`
+- `model`: not set (auto-detected)
+
+Check-ins gate on session activity, are bounded, and avoid overlapping calls. They can still be controlled explicitly with `/advisor checkins on|off|<minutes>`.
+
+## Stability guarantees
+
+- No flattening: the advisor remains its own surface and does not hide orchestration commands.
+- Cockpit is simple and explicit: `/pi-rogue` is the top-level status view.
 
-- `/pi-rogue` — cockpit/status entry point
-- `/advisor checkins on|off|<minutes>` — configure low-power mid-session check-ins

package/package.json

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

package/skills/advisor/SKILL.md

@@ -3,48 +3,46 @@ name: advisor
 description: Zero-config strategic advisor for Pi. Auto-detects best model, phase-aware routing, preflight + post-review + cache. Use for architecture, tradeoffs, planning.
 ---
 
-# PiRogue Advisor
+# Pi-Rogue Advisor
 
-Works out of the box. Just install and use `/advisor` or `/pi-rogue`.
-
-> 96 strategic calls saved ~$53 on GPT-5.5 over 3,071 turns — see [`docs/savings.md`](../../docs/savings.md)
+Use this skill for non-trivial decisions before/after significant edits.
 
 ## Quick start
 
-- `/pi-rogue` — cockpit/status entry point
-- `/advisor` — status + config
-- `/advisor <question>` — get immediate advice
-- `/advisor on|off` — enable/disable
-- `/advisor checkins on|off|<minutes>` — configure low-power mid-hour check-ins
-
-Zero config needed. Falls back through SOTA models (gpt-5.5 → claude-opus-4-6 → sonnet-4-6) automatically.
-
-The router is phase-aware: it keeps tiny edits cheap, escalates complex/high-risk work to SOTA, and writes compact routing logs for future classifier training.
-
-## When to call
-
-Agent should call `advisor` tool before: new frameworks, refactoring, API design, concurrency, security, tradeoffs.
-Skip: reads, small edits, one-liners.
+- `/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
 
-## Commands
+## Command surface
 
 | Command | What it does |
-|---------|-------------|
-| `/advisor` | Show status, config, cached note |
-| `/advisor <question>` | Get immediate strategic advice |
-| `/advisor on` | Enable auto mode (preflight+post+cache) |
-| `/advisor off` | Disable |
-| `/advisor mode auto\|manual\|off` | Set advisor mode |
-| `/advisor model <provider/model>` | Set specific model (e.g. `openai-codex/gpt-5.5`) |
-| `/advisor status` | Full status with model and check-in info |
-| `/advisor config` | Show current config |
-| `/advisor review light\|strict\|off` | Set review aggressiveness |
-| `/advisor checkins on\|off\|<minutes>` | Configure low-power mid-hour check-ins |
-
-## Config (5 fields, all optional)
-
-Defaults: `mode: auto, review: light, checkins: mid-hour, checkinIntervalMinutes: 30`
-
-```json
-{ "mode": "auto", "review": "light", "checkins": "mid-hour", "checkinIntervalMinutes": 30 }
-```
+|---|---|
+| `/advisor` | Show status + config summary |
+| `/advisor status` | Same as `/advisor` |
+| `/advisor on` | Enable auto mode |
+| `/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 |
+
+## Routing and safety
+
+- 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.
+
+## Keep scope clear
+
+The advisor surface is separate from orchestration (`goal`/`loop`/`autoresearch`) and intentionally stays a small command set with explicit entries above.
+
+## Defaults
+
+- `mode: auto`
+- `review: light`
+- `checkins: off` by default; orchestration enables them while a goal/autoresearch flow is active
+- `checkinIntervalMinutes: 30`
+- `model: auto`

package/src/extension.test.ts

@@ -18,11 +18,11 @@ function state(overrides: Record<string, unknown> = {}) {
 }
 
 describe("AdvisorConfig", () => {
-  it("defaults to auto mode, light review, and mid-hour check-ins", () => {
+  it("defaults to auto mode, light review, and goal-scoped check-ins off", () => {
     const cfg = normalizeAdvisorConfig({});
     expect(cfg.mode).toBe("auto");
     expect(cfg.review).toBe("light");
-    expect(cfg.checkins).toBe("mid-hour");
+    expect(cfg.checkins).toBe("off");
     expect(cfg.checkinIntervalMinutes).toBe(30);
     expect(cfg.model).toBeUndefined();
   });
@@ -57,7 +57,7 @@ describe("AdvisorConfig", () => {
     const parsed = normalizeAdvisorConfig(JSON.parse(json) as AdvisorConfig);
     expect(parsed.mode).toBe("auto");
     expect(parsed.review).toBe("light");
-    expect(parsed.checkins).toBe("mid-hour");
+    expect(parsed.checkins).toBe("off");
     expect(parsed.checkinIntervalMinutes).toBe(30);
     expect(parsed.model).toBe("claude-opus-4-6");
   });
@@ -65,21 +65,21 @@ describe("AdvisorConfig", () => {
 
 describe("mid-hour check-ins", () => {
   it("does not run immediately after session start", () => {
-    const cfg = normalizeAdvisorConfig({ checkinIntervalMinutes: 30 });
+    const cfg = normalizeAdvisorConfig({ checkins: "mid-hour", checkinIntervalMinutes: 30 });
     const startedAt = 1_000;
     const now = startedAt + 5 * 60_000;
     expect(shouldRunCheckin(cfg, state(), now, startedAt)).toBeNull();
   });
 
   it("runs after interval when there was new activity", () => {
-    const cfg = normalizeAdvisorConfig({ checkinIntervalMinutes: 30 });
+    const cfg = normalizeAdvisorConfig({ checkins: "mid-hour", checkinIntervalMinutes: 30 });
     const startedAt = 1_000;
     const now = startedAt + 31 * 60_000;
     expect(shouldRunCheckin(cfg, state(), now, startedAt)).toMatch(/mid-hour check-in/);
   });
 
   it("does not run without activity since the last check-in", () => {
-    const cfg = normalizeAdvisorConfig({ checkinIntervalMinutes: 30 });
+    const cfg = normalizeAdvisorConfig({ checkins: "mid-hour", checkinIntervalMinutes: 30 });
     const lastAt = new Date(1_000).toISOString();
     const now = 1_000 + 60 * 60_000;
     expect(shouldRunCheckin(cfg, state({ turns: 5, checkin: { lastAt, lastTurn: 5 } }), now, 1_000)).toBeNull();

package/src/extension.ts

@@ -38,7 +38,7 @@ export interface AdvisorConfig {
 const DEFAULT_CONFIG: AdvisorConfig = {
   mode: "auto",
   review: "light",
-  checkins: "mid-hour",
+  checkins: "off",
   checkinIntervalMinutes: 30,
 };
 
@@ -121,7 +121,7 @@ export function normalizeAdvisorConfig(raw: Partial<AdvisorConfig> = {}): Adviso
   return {
     mode: (raw.mode === "manual" || raw.mode === "off") ? raw.mode : "auto",
     review: (raw.review === "strict" || raw.review === "off") ? raw.review : "light",
-    checkins: raw.checkins === "off" ? "off" : "mid-hour",
+    checkins: raw.checkins === "mid-hour" ? "mid-hour" : DEFAULT_CONFIG.checkins,
     checkinIntervalMinutes: Math.min(MAX_CHECKIN_INTERVAL_MINUTES, Math.max(MIN_CHECKIN_INTERVAL_MINUTES, Number.isFinite(interval) ? Math.round(interval) : DEFAULT_CONFIG.checkinIntervalMinutes)),
     model: raw.model || undefined,
   };
@@ -374,7 +374,7 @@ function syncCheckinTimer(pi: ExtensionAPI, ctx: any): void {
 function piRogueCockpitText(config: AdvisorConfig, state: SessionState, currentNote: string): string {
   const normalized = normalizeAdvisorConfig(config);
   return [
-    "☠︎ PiRogue cockpit",
+    "☠︎ Pi-Rogue cockpit",
     currentNote ? `Advisor: ${truncate(currentNote, 220)}` : "Advisor: no current note",
     `Mode: ${normalized.mode} | Review: ${normalized.review} | Check-ins: ${normalized.checkins === "off" ? "off" : `${normalized.checkinIntervalMinutes}m`}`,
     `Turns: ${state.turns} | Advisor calls: ${state.advisorCalls} | Cache hits: ${state.cacheHits}`,
@@ -666,7 +666,7 @@ export function registerAdvisor(pi: ExtensionAPI): void {
 
   // ── /pi-rogue cockpit ──────────────────────────────────────────────────
   pi.registerCommand("pi-rogue", {
-    description: "Show PiRogue cockpit: advisor, check-ins, and orchestration command pointers",
+    description: "Show Pi-Rogue cockpit: advisor, check-ins, and orchestration command pointers",
     getArgumentCompletions: (prefix: string) => piRogueArgumentCompletions(prefix),
     handler: async (args, ctx) => {
       const cfg = loadConfig();