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

package/README.md

@@ -1,9 +1,14 @@
 # @fiale-plus/pi-rogue-advisor
 
-PiRogue advisor: session coaching, phase-aware routing, and decision framing for Pi.
+PiRogue advisor: session coaching, phase-aware routing, mid-hour check-ins, and decision framing for Pi.
 
 The bundled binary gate model is shipped with the package and auto-seeded on install.
 
 Install locally from this repo root: `npm install`
 
 Published install: `pi install @fiale-plus/pi-rogue-advisor`
+
+Useful commands:
+
+- `/pi-rogue` — cockpit/status entry point
+- `/advisor checkins on|off|<minutes>` — configure low-power mid-session check-ins

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fiale-plus/pi-rogue-advisor",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "PiRogue advisor extension for Pi — multi-model support, SOTA model suggestion, cache-aware session advisory.",
   "type": "module",
   "license": "MIT",
@@ -11,6 +11,10 @@
   "keywords": [
     "pi-package"
   ],
+  "scripts": {
+    "check": "tsc -p ../../tsconfig.json --noEmit",
+    "test": "cd ../.. && vitest run packages/advisor/src/*.test.ts"
+  },
   "main": "./src/index.ts",
   "exports": {
     ".": "./src/index.ts"

package/skills/advisor/SKILL.md

@@ -5,15 +5,17 @@ description: Zero-config strategic advisor for Pi. Auto-detects best model, phas
 
 # PiRogue Advisor
 
-Works out of the box. Just install and use `/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)
 
 ## 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.
 
@@ -34,14 +36,15 @@ Skip: reads, small edits, one-liners.
 | `/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 info |
-| `/advisor config` | Show current 3-field config |
+| `/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 (3 fields, all optional)
+## Config (5 fields, all optional)
 
-Defaults: `mode: auto, review: light`
+Defaults: `mode: auto, review: light, checkins: mid-hour, checkinIntervalMinutes: 30`
 
 ```json
-{ "mode": "auto", "review": "light" }
+{ "mode": "auto", "review": "light", "checkins": "mid-hour", "checkinIntervalMinutes": 30 }
 ```

package/src/completions.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { advisorArgumentCompletions, piRogueArgumentCompletions } from "./completions.js";
+
+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"]));
+  });
+
+  it("offers nested review choices", () => {
+    const values = advisorArgumentCompletions("review ")?.map((i) => i.value);
+    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", () => {
+  it("offers umbrella sections", () => {
+    const values = piRogueArgumentCompletions("")?.map((i) => i.value);
+    expect(values).toEqual(expect.arrayContaining(["status", "advisor", "orchestration", "help"]));
+  });
+
+  it("fans out to orchestration shortcuts", () => {
+    const values = piRogueArgumentCompletions("orchestration ")?.map((i) => i.value);
+    expect(values).toEqual(expect.arrayContaining(["goal", "loop", "autoresearch", "autoresearch-lab"]));
+  });
+});

package/src/completions.ts

@@ -0,0 +1,83 @@
+type CompletionItem = { value: string; label: string; description?: string };
+
+function item(value: string, description?: string): CompletionItem {
+  return { value, label: value, ...(description ? { description } : {}) };
+}
+
+function complete(values: Array<[string, string?]>, prefix: string): CompletionItem[] | null {
+  const q = prefix.trimStart().toLowerCase();
+  const items = values.map(([value, description]) => item(value, description));
+  const filtered = q
+    ? items.filter((i) => i.value.startsWith(q))
+    : items;
+  return filtered.length > 0 ? filtered : null;
+}
+
+function completionsForPrefix(prefix: string, topLevel: Array<[string, string?]>, nested: Record<string, Array<[string, string?]>>): CompletionItem[] | null {
+  const q = prefix.trimStart().toLowerCase();
+  if (!q) return complete(topLevel, q);
+
+  const [head, ...rest] = q.split(/\s+/);
+  if (!head) return complete(topLevel, q);
+
+  if (rest.length === 0) {
+    const top = complete(topLevel, head);
+    if (top) return top;
+  }
+
+  const next = nested[head];
+  if (next) {
+    return complete(next, rest.join(" "));
+  }
+
+  return complete(topLevel, q);
+}
+
+const advisorTopLevel: Array<[string, string?]> = [
+  ["status", "show status and configuration"],
+  ["config", "show full config"],
+  ["on", "enable auto mode"],
+  ["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"],
+  ["orchestration", "goal/loop/autoresearch shortcuts"],
+  ["checkins", "advisor check-ins"],
+  ["help", "show cockpit help"],
+];
+
+const piRogueNested: Record<string, Array<[string, string?]>> = {
+  advisor: advisorTopLevel,
+  orchestration: [
+    ["goal", "goal commands"],
+    ["loop", "loop commands"],
+    ["autoresearch", "solo research flow"],
+    ["autoresearch-lab", "parallel research flow"],
+    ["status", "show all surfaces"],
+  ],
+  checkins: advisorNested.checkins,
+  help: [["advisor"], ["orchestration"], ["checkins"], ["status"]],
+};
+
+export function advisorArgumentCompletions(prefix: string): CompletionItem[] | null {
+  return completionsForPrefix(prefix, advisorTopLevel, advisorNested);
+}
+
+export function piRogueArgumentCompletions(prefix: string): CompletionItem[] | null {
+  return completionsForPrefix(prefix, piRogueTopLevel, piRogueNested);
+}

package/src/extension.test.ts

@@ -1,54 +1,100 @@
 import { describe, it, expect } from "vitest";
-import type { AdvisorConfig } from "./extension.js";
+import { normalizeAdvisorConfig, shouldRunCheckin, type AdvisorConfig } from "./extension.js";
+
+function state(overrides: Record<string, unknown> = {}) {
+  return {
+    turns: 2,
+    lastTask: "work on orchestration",
+    notes: ["made progress"],
+    files: [],
+    errors: [],
+    advisorCalls: 0,
+    cacheHits: 0,
+    followUp: "",
+    router: {},
+    checkin: {},
+    ...overrides,
+  } as any;
+}
 
 describe("AdvisorConfig", () => {
-  it("defaults to auto mode and light review with no model override", () => {
-    const cfg: AdvisorConfig = { mode: "auto", review: "light" };
+  it("defaults to auto mode, light review, and mid-hour check-ins", () => {
+    const cfg = normalizeAdvisorConfig({});
     expect(cfg.mode).toBe("auto");
     expect(cfg.review).toBe("light");
+    expect(cfg.checkins).toBe("mid-hour");
+    expect(cfg.checkinIntervalMinutes).toBe(30);
     expect(cfg.model).toBeUndefined();
   });
 
   it("accepts all 3 modes", () => {
     for (const mode of ["auto", "manual", "off"] as const) {
-      const cfg: AdvisorConfig = { mode, review: "light" };
-      expect(cfg.mode).toBe(mode);
+      const cfg: AdvisorConfig = { mode, review: "light", checkins: "mid-hour", checkinIntervalMinutes: 30 };
+      expect(normalizeAdvisorConfig(cfg).mode).toBe(mode);
     }
   });
 
   it("accepts all 3 review levels", () => {
     for (const review of ["light", "strict", "off"] as const) {
-      const cfg: AdvisorConfig = { mode: "auto", review };
-      expect(cfg.review).toBe(review);
+      const cfg: AdvisorConfig = { mode: "auto", review, checkins: "mid-hour", checkinIntervalMinutes: 30 };
+      expect(normalizeAdvisorConfig(cfg).review).toBe(review);
     }
   });
 
+  it("bounds check-in intervals", () => {
+    expect(normalizeAdvisorConfig({ checkinIntervalMinutes: 1 }).checkinIntervalMinutes).toBe(10);
+    expect(normalizeAdvisorConfig({ checkinIntervalMinutes: 999 }).checkinIntervalMinutes).toBe(240);
+  });
+
   it("accepts optional model override", () => {
-    const cfg: AdvisorConfig = { mode: "auto", review: "light", model: "claude-sonnet-4-6" };
+    const cfg = normalizeAdvisorConfig({ mode: "auto", review: "light", model: "claude-sonnet-4-6" });
     expect(cfg.model).toBe("claude-sonnet-4-6");
   });
 
   it("serializes/deserializes without data loss (JSON round-trip)", () => {
-    const original: AdvisorConfig = { mode: "auto", review: "light", model: "claude-opus-4-6" };
+    const original = normalizeAdvisorConfig({ mode: "auto", review: "light", model: "claude-opus-4-6" });
     const json = JSON.stringify(original);
-    const parsed = JSON.parse(json) as 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.checkinIntervalMinutes).toBe(30);
     expect(parsed.model).toBe("claude-opus-4-6");
   });
+});
+
+describe("mid-hour check-ins", () => {
+  it("does not run immediately after session start", () => {
+    const cfg = normalizeAdvisorConfig({ checkinIntervalMinutes: 30 });
+    const startedAt = 1_000;
+    const now = startedAt + 5 * 60_000;
+    expect(shouldRunCheckin(cfg, state(), now, startedAt)).toBeNull();
+  });
 
-  it("has exactly 3 properties (mode, review, model)", () => {
-    const keys = Object.keys({ mode: "auto", review: "light" } as AdvisorConfig);
-    expect(keys.length).toBeLessThanOrEqual(3);
-    const allKeys = ["mode", "review", "model"];
-    const configKeys = Object.keys({ mode: "auto", review: "light" } as AdvisorConfig);
-    expect(configKeys.every((k) => allKeys.includes(k))).toBe(true);
+  it("runs after interval when there was new activity", () => {
+    const cfg = normalizeAdvisorConfig({ 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 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();
+  });
+
+  it("does not run when check-ins are disabled", () => {
+    const cfg = normalizeAdvisorConfig({ checkins: "off" });
+    expect(shouldRunCheckin(cfg, state(), 999999, 1)).toBeNull();
   });
 });
 
+
 describe("SOTA model suggestions", () => {
   it("includes gpt-5.5 as primary option", () => {
-    const cfg: AdvisorConfig = { mode: "auto", review: "light" };
+    const cfg = normalizeAdvisorConfig({ mode: "auto", review: "light" });
     expect(cfg.model).toBeUndefined(); // model is optional, auto-detect
   });
 });

package/src/extension.ts

@@ -1,9 +1,11 @@
 import { createHash } from "node:crypto";
+import { basename } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Box, Text } from "@earendil-works/pi-tui";
 import { completeSimple, type ThinkingLevel } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
 import { featureFile, readText, truncate, writeText } from "./internal.js";
+import { advisorArgumentCompletions, piRogueArgumentCompletions } from "./completions.js";
 import {
   appendRouteLog,
   binaryGatePredict,
@@ -25,6 +27,10 @@ export interface AdvisorConfig {
   mode: "auto" | "manual" | "off";
   /** "light" (file changes/errors only) | "strict" (every 3 turns) | "off" */
   review: "light" | "strict" | "off";
+  /** Opportunistic advisor check-ins during long sessions. */
+  checkins: "mid-hour" | "off";
+  /** Minutes between check-ins; bounded and cheap-gated by recent activity. */
+  checkinIntervalMinutes: number;
   /** Optional model override. Auto-detects SOTA (gpt-5.5, claude-opus-4-6…) if unset */
   model?: string;
 }
@@ -32,6 +38,8 @@ export interface AdvisorConfig {
 const DEFAULT_CONFIG: AdvisorConfig = {
   mode: "auto",
   review: "light",
+  checkins: "mid-hour",
+  checkinIntervalMinutes: 30,
 };
 
 const CONFIG_PATH = featureFile("advisor", "config.json");
@@ -44,6 +52,12 @@ const MAX_CACHE = 64;
 const MAX_NOTES = 12;
 const MAX_FILES = 8;
 const MAX_ERRORS = 5;
+const CHECKIN_POLL_MS = 5 * 60_000;
+const MIN_CHECKIN_INTERVAL_MINUTES = 10;
+const MAX_CHECKIN_INTERVAL_MINUTES = 240;
+const checkinTimers = new Map<string, NodeJS.Timeout>();
+const checkinStartedAt = new Map<string, number>();
+const checkinLocks = new Set<string>();
 
 // ── SOTA models (ordered by preference) ───────────────────────────────────
 const SOTA_CHAIN: Array<{ provider: string; model: string; label: string }> = [
@@ -67,6 +81,11 @@ interface SessionState {
     preflight?: AdvisorRouteDecision;
     review?: AdvisorRouteDecision;
   };
+  checkin: {
+    lastAt?: string;
+    lastTurn?: number;
+    lastReason?: string;
+  };
 }
 
 function defaultState(): SessionState {
@@ -80,6 +99,7 @@ function defaultState(): SessionState {
     cacheHits: 0,
     followUp: "",
     router: {},
+    checkin: {},
   };
 }
 
@@ -96,15 +116,21 @@ function writeJson(path: string, v: unknown) {
   writeText(path, JSON.stringify(v, null, 2) + "\n");
 }
 
-function loadConfig(): AdvisorConfig {
-  const raw = readJson<Partial<AdvisorConfig>>(CONFIG_PATH, {});
+export function normalizeAdvisorConfig(raw: Partial<AdvisorConfig> = {}): AdvisorConfig {
+  const interval = Number(raw.checkinIntervalMinutes ?? DEFAULT_CONFIG.checkinIntervalMinutes);
   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",
+    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,
   };
 }
 
+function loadConfig(): AdvisorConfig {
+  return normalizeAdvisorConfig(readJson<Partial<AdvisorConfig>>(CONFIG_PATH, {}));
+}
+
 function saveConfig(c: AdvisorConfig) {
   writeJson(CONFIG_PATH, c);
 }
@@ -124,6 +150,11 @@ function loadState(): SessionState {
       preflight: raw.router?.preflight,
       review: raw.router?.review,
     },
+    checkin: {
+      lastAt: raw.checkin?.lastAt,
+      lastTurn: raw.checkin?.lastTurn,
+      lastReason: raw.checkin?.lastReason,
+    },
   };
 }
 
@@ -262,6 +293,97 @@ function mergeRouteReview(configReview: AdvisorConfig["review"], route?: ReviewP
   return mergeReviewPolicy(configReview, route);
 }
 
+function sessionKey(ctx: any): string {
+  const sessionFile = ctx?.sessionManager?.getSessionFile?.();
+  if (!sessionFile) return "session";
+  return basename(String(sessionFile)).replace(/\.[^.]+$/, "");
+}
+
+function setPiRogueStatus(ctx: any, config = loadConfig(), state = loadState()): void {
+  const normalized = normalizeAdvisorConfig(config);
+  const checkin = normalized.checkins === "off" ? "checkins off" : `checkins ${normalized.checkinIntervalMinutes}m`;
+  const last = state.checkin.lastAt ? ` · last ${new Date(state.checkin.lastAt).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })}` : "";
+  ctx.ui.setStatus("pi-rogue", `☠︎ advisor ${normalized.mode}/${normalized.review} · ${checkin}${last}`);
+}
+
+export function shouldRunCheckin(config: AdvisorConfig, state: SessionState, now = Date.now(), startedAt = now): string | null {
+  const normalized = normalizeAdvisorConfig(config);
+  if (normalized.mode === "off" || normalized.mode === "manual") return null;
+  if (normalized.checkins === "off") return null;
+  if (!state.lastTask && state.notes.length === 0) return null;
+  const lastTurn = state.checkin.lastTurn ?? 0;
+  if (state.turns <= lastTurn) return null;
+  const lastAt = state.checkin.lastAt ? Date.parse(state.checkin.lastAt) : 0;
+  const intervalMs = normalized.checkinIntervalMinutes * 60_000;
+  const since = lastAt || startedAt;
+  if (since && now - since < intervalMs) return null;
+  return `mid-hour check-in after ${state.turns - lastTurn} new turn(s)`;
+}
+
+function stopCheckinTimer(key: string): void {
+  const timer = checkinTimers.get(key);
+  if (timer) {
+    clearInterval(timer);
+    checkinTimers.delete(key);
+  }
+}
+
+async function maybeAdvisorCheckin(pi: ExtensionAPI, ctx: any, source: string): Promise<boolean> {
+  const key = sessionKey(ctx);
+  if (checkinLocks.has(key)) return false;
+
+  const config = loadConfig();
+  const state = loadState();
+  const startedAt = checkinStartedAt.get(key) ?? Date.now();
+  const reason = shouldRunCheckin(config, state, Date.now(), startedAt);
+  setPiRogueStatus(ctx, config, state);
+  if (!reason) return false;
+
+  checkinLocks.add(key);
+  try {
+    const response = await askAdvisor(
+      pi,
+      ctx,
+      `Mid-session check-in (${source}): briefly assess whether the current session is on track, stuck, or missing a higher-leverage next step. Return one concrete nudge.`,
+      "review",
+      true,
+    );
+    if (response.error) return false;
+
+    const next = loadState();
+    next.checkin = { lastAt: new Date().toISOString(), lastTurn: next.turns, lastReason: reason };
+    saveState(next);
+    setPiRogueStatus(ctx, config, next);
+    sendAdvisorHint(pi, "review", "mid-hour check-in", response.text, [response.text]);
+    return true;
+  } finally {
+    checkinLocks.delete(key);
+  }
+}
+
+function syncCheckinTimer(pi: ExtensionAPI, ctx: any): void {
+  const key = sessionKey(ctx);
+  stopCheckinTimer(key);
+  checkinStartedAt.set(key, Date.now());
+  setPiRogueStatus(ctx);
+  const config = loadConfig();
+  if (config.mode === "off" || config.mode === "manual" || config.checkins === "off") return;
+  checkinTimers.set(key, setInterval(() => { void maybeAdvisorCheckin(pi, ctx, "timer"); }, CHECKIN_POLL_MS));
+}
+
+function piRogueCockpitText(config: AdvisorConfig, state: SessionState, currentNote: string): string {
+  const normalized = normalizeAdvisorConfig(config);
+  return [
+    "☠︎ PiRogue 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}`,
+    state.checkin.lastAt ? `Last check-in: ${new Date(state.checkin.lastAt).toLocaleString()} (${state.checkin.lastReason || "mid-hour"})` : "Last check-in: never",
+    "",
+    "Commands: /advisor status · /advisor checkins on|off|<minutes> · /goal · /loop status · /autoresearch status",
+  ].join("\n");
+}
+
 // ── Model resolution (auto-fallback through SOTA chain) ────────────────────
 async function resolveModel(ctx: any, config: AdvisorConfig): Promise<{ model: any; auth: any; label: string } | null> {
   // Try user's configured model first
@@ -417,12 +539,22 @@ async function doReview(pi: ExtensionAPI, ctx: any, trigger: string, delta: stri
 // ── Extension entry point ──────────────────────────────────────────────────
 
 export function registerAdvisor(pi: ExtensionAPI): void {
-  const config = loadConfig();
-
   for (const customType of ["advisor:model", "advisor:rules", "advisor:llm"] as const) {
     pi.registerMessageRenderer(customType, renderAdvisorHint);
   }
 
+  pi.on("session_start", (_event, ctx) => {
+    syncCheckinTimer(pi, ctx);
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => {
+    const key = sessionKey(ctx);
+    stopCheckinTimer(key);
+    checkinStartedAt.delete(key);
+    checkinLocks.delete(key);
+    ctx.ui.setStatus("pi-rogue", undefined);
+  });
+
   // ── Tool ───────────────────────────────────────────────────────────────
   pi.registerTool({
     name: "advisor",
@@ -442,8 +574,10 @@ export function registerAdvisor(pi: ExtensionAPI): void {
 
   // ── Preflight (heuristics only — no LLM call, <1ms) ──────────────────
   pi.on("before_agent_start", async (event: any, ctx: any) => {
-    if (config.mode === "off" || config.mode === "manual") return { systemPrompt: event.systemPrompt };
+    const cfg = loadConfig();
+    if (cfg.mode === "off" || cfg.mode === "manual") return { systemPrompt: event.systemPrompt };
     const state = loadState();
+    setPiRogueStatus(ctx, cfg, state);
     const prompt = typeof event.prompt === "string" && event.prompt.trim() ? squish(event.prompt, 1000) : "";
     if (prompt) state.lastTask = prompt;
     const briefText = brief(state);
@@ -499,7 +633,8 @@ export function registerAdvisor(pi: ExtensionAPI): void {
 
   // ── Post-review (turn_end) ─────────────────────────────────────────────
   pi.on("turn_end", async (event: any, ctx: any) => {
-    if (config.mode === "off") return;
+    const cfg = loadConfig();
+    if (cfg.mode === "off") return;
     const state = loadState();
     state.turns++;
     const tools = (event.toolResults || []).map((t: any) => String(t?.toolName || t?.name || "tool"));
@@ -508,15 +643,18 @@ export function registerAdvisor(pi: ExtensionAPI): void {
     const text = squish(contentText(event.message?.content));
     if (text && text !== state.notes[state.notes.length - 1]) state.notes.push(text);
     saveState(state);
+    setPiRogueStatus(ctx, cfg, state);
+    void maybeAdvisorCheckin(pi, ctx, "turn_end");
 
-    if (config.review !== "off") {
+    if (cfg.review !== "off") {
       await doReview(pi, ctx, `turn-${state.turns}`, text, { fileChanged, failed, isAgentEnd: false });
     }
   });
 
   // ── Post-review (agent_end) ────────────────────────────────────────────
   pi.on("agent_end", async (event: any, ctx: any) => {
-    if (config.mode === "off" || config.review === "off") return;
+    const cfg = loadConfig();
+    if (cfg.mode === "off" || cfg.review === "off") return;
     const state = loadState();
     const msgs = (event.messages || []).filter((m: any) => m.role === "assistant" || m.role === "toolResult");
     const last = msgs[msgs.length - 1];
@@ -526,9 +664,59 @@ export function registerAdvisor(pi: ExtensionAPI): void {
     await doReview(pi, ctx, "agent-end", delta, { fileChanged, failed, isAgentEnd: true });
   });
 
+  // ── /pi-rogue cockpit ──────────────────────────────────────────────────
+  pi.registerCommand("pi-rogue", {
+    description: "Show PiRogue cockpit: advisor, check-ins, and orchestration command pointers",
+    getArgumentCompletions: (prefix: string) => piRogueArgumentCompletions(prefix),
+    handler: async (args, ctx) => {
+      const cfg = loadConfig();
+      const state = loadState();
+      const arg = String(args ?? "").trim().toLowerCase();
+      setPiRogueStatus(ctx, cfg, state);
+
+      if (!arg || arg === "status" || arg === "help") {
+        ctx.ui.notify(piRogueCockpitText(cfg, state, readText(CURRENT_PATH).trim()), "info");
+        return;
+      }
+
+      if (arg.startsWith("advisor")) {
+        ctx.ui.notify([
+          "Advisor surface:",
+          "  /advisor status",
+          "  /advisor config",
+          "  /advisor checkins on|off|<minutes>",
+          "  /advisor <question>",
+        ].join("\n"), "info");
+        return;
+      }
+
+      if (arg.startsWith("orchestration")) {
+        ctx.ui.notify([
+          "Orchestration surface:",
+          "  /goal show|clear|list|set <text>",
+          "  /loop status|off|clear|stop|<interval> <instruction>",
+          "  /autoresearch status|clear|<instruction>",
+          "  /autoresearch-lab status|clear|<instruction>",
+        ].join("\n"), "info");
+        return;
+      }
+
+      if (arg.startsWith("checkins")) {
+        ctx.ui.notify([
+          `Advisor check-ins: ${cfg.checkins === "off" ? "off" : `${cfg.checkinIntervalMinutes}m`}`,
+          "Use /advisor checkins on|off|<minutes> to change it.",
+        ].join("\n"), "info");
+        return;
+      }
+
+      ctx.ui.notify(piRogueCockpitText(cfg, state, readText(CURRENT_PATH).trim()), "info");
+    },
+  });
+
   // ── /advisor command ───────────────────────────────────────────────────
   pi.registerCommand("advisor", {
     description: "Senior engineering advisor. Usage: /advisor [on|off|status|config|question]",
+    getArgumentCompletions: (prefix: string) => advisorArgumentCompletions(prefix),
     handler: async (args, ctx) => {
       const a = String(args ?? "").trim().toLowerCase();
       const [cmd, ...rest] = a.split(/\s+/);
@@ -543,21 +731,22 @@ export function registerAdvisor(pi: ExtensionAPI): void {
           note ? `🧭 ${truncate(note, 200)}` : "",
           route ? `Router: ${summarizeRoute(route)}${route.safety ? " · safety" : ""}` : "",
           "",
-          `Mode: ${cfg.mode} | Review: ${cfg.review} | Model: ${resolved?.label || cfg.model || "auto"}`,
+          `Mode: ${cfg.mode} | Review: ${cfg.review} | Check-ins: ${cfg.checkins === "off" ? "off" : `${cfg.checkinIntervalMinutes}m`} | Model: ${resolved?.label || cfg.model || "auto"}`,
           `Turns: ${state.turns} | Calls: ${state.advisorCalls} | Cache hits: ${state.cacheHits}`,
+          state.checkin.lastAt ? `Last check-in: ${new Date(state.checkin.lastAt).toLocaleString()} (${state.checkin.lastReason || "mid-hour"})` : "Last check-in: never",
           "",
-          "Commands: /advisor on|off | /advisor status | /advisor config | <question>",
+          "Commands: /advisor on|off | /advisor status | /advisor checkins on|off|<minutes> | /advisor config | <question>",
           "Tip: SOTA models auto-detected. No config needed.",
         ].filter(Boolean).join("\n"), "info");
         return;
       }
 
-      if (cmd === "on" && cfg.mode === "off") { saveConfig({ ...cfg, mode: "auto" }); ctx.ui.notify("Advisor enabled (auto mode).", "info"); return; }
-      if (cmd === "off") { saveConfig({ ...cfg, mode: "off" }); ctx.ui.notify("Advisor disabled.", "info"); return; }
+      if (cmd === "on" && cfg.mode === "off") { const next = { ...cfg, mode: "auto" as const }; saveConfig(next); syncCheckinTimer(pi, ctx); ctx.ui.notify("Advisor enabled (auto mode).", "info"); return; }
+      if (cmd === "off") { const next = { ...cfg, mode: "off" as const }; saveConfig(next); stopCheckinTimer(sessionKey(ctx)); setPiRogueStatus(ctx, next, state); ctx.ui.notify("Advisor disabled.", "info"); return; }
       if (cmd === "mode") {
         const v = rest[0];
-        if (v === "auto" || v === "manual") { saveConfig({ ...cfg, mode: v }); ctx.ui.notify(`Mode set to ${v}.`, "info"); return; }
-        if (v === "off") { saveConfig({ ...cfg, mode: "off" }); ctx.ui.notify("Advisor disabled.", "info"); return; }
+        if (v === "auto" || v === "manual") { const next: AdvisorConfig = { ...cfg, mode: v }; saveConfig(next); syncCheckinTimer(pi, ctx); ctx.ui.notify(`Mode set to ${v}.`, "info"); return; }
+        if (v === "off") { const next = { ...cfg, mode: "off" as const }; saveConfig(next); stopCheckinTimer(sessionKey(ctx)); setPiRogueStatus(ctx, next, state); ctx.ui.notify("Advisor disabled.", "info"); return; }
         ctx.ui.notify("Usage: /advisor mode auto|manual|off", "error");
         return;
       }
@@ -580,9 +769,11 @@ export function registerAdvisor(pi: ExtensionAPI): void {
       }
       if (cmd === "config") {
         ctx.ui.notify([
-          "Advisor config (3 fields, all optional):",
+          "Advisor config (5 fields, all optional):",
           `  mode: "${cfg.mode}" — auto (preflight+post+cache) | manual | off`,
           `  review: "${cfg.review}" — light (changes/errors) | strict (every 3) | off`,
+          `  checkins: "${cfg.checkins}" — mid-hour | off`,
+          `  checkinIntervalMinutes: ${cfg.checkinIntervalMinutes}`,
           `  model: "${cfg.model || "auto"}" — optional override`,
           "",
           "Router logs: evals/advisor-router.jsonl",
@@ -592,10 +783,38 @@ export function registerAdvisor(pi: ExtensionAPI): void {
       }
       if (cmd === "review") {
         const v = rest[0];
-        if (v === "light" || v === "strict" || v === "off") { saveConfig({ ...cfg, review: v }); ctx.ui.notify(`Review set to ${v}.`, "info"); return; }
+        if (v === "light" || v === "strict" || v === "off") { const next: AdvisorConfig = { ...cfg, review: v }; saveConfig(next); setPiRogueStatus(ctx, next, state); ctx.ui.notify(`Review set to ${v}.`, "info"); return; }
         ctx.ui.notify("Usage: /advisor review light|strict|off", "error");
         return;
       }
+      if (cmd === "checkins" || cmd === "checkin") {
+        const v = rest[0];
+        if (v === "off") {
+          const next = { ...cfg, checkins: "off" as const };
+          saveConfig(next);
+          stopCheckinTimer(sessionKey(ctx));
+          setPiRogueStatus(ctx, next, state);
+          ctx.ui.notify("Advisor mid-hour check-ins disabled.", "info");
+          return;
+        }
+        if (v === "on" || v === "mid-hour") {
+          const next = { ...cfg, checkins: "mid-hour" as const };
+          saveConfig(next);
+          syncCheckinTimer(pi, ctx);
+          ctx.ui.notify(`Advisor mid-hour check-ins enabled every ${next.checkinIntervalMinutes}m.`, "info");
+          return;
+        }
+        const minutes = Number(v);
+        if (Number.isFinite(minutes)) {
+          const next = normalizeAdvisorConfig({ ...cfg, checkins: "mid-hour", checkinIntervalMinutes: minutes });
+          saveConfig(next);
+          syncCheckinTimer(pi, ctx);
+          ctx.ui.notify(`Advisor mid-hour check-ins every ${next.checkinIntervalMinutes}m.`, "info");
+          return;
+        }
+        ctx.ui.notify("Usage: /advisor checkins on|off|<minutes>", "error");
+        return;
+      }
 
       // Anything else: treat as a question to the advisor
       const r = await askAdvisor(pi, ctx, a, "slash", true);