@fiale-plus/pi-rogue-bundle 0.1.9 → 0.1.10

package/node_modules/@fiale-plus/pi-rogue-advisor/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@fiale-plus/pi-rogue-advisor",
+  "version": "0.1.5",
+  "description": "Pi-Rogue advisor extension for Pi — multi-model support, SOTA model suggestion, cache-aware session advisory. (Releases paused; consolidated into @fiale-plus/pi-rogue-bundle. Install the bundle instead.)",
+  "private": true,
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fiale-plus/pi-rogue.git"
+  },
+  "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"
+  },
+  "pi": {
+    "extensions": [
+      "./advisor"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.74.0",
+    "@earendil-works/pi-ai": "^0.74.0",
+    "@earendil-works/pi-tui": "^0.74.0"
+  },
+  "dependencies": {
+    "typebox": "^1.1.24"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "advisor",
+    "src",
+    "skills",
+    "assets",
+    "README.md",
+    "package.json"
+  ]
+}

package/node_modules/@fiale-plus/pi-rogue-advisor/skills/advisor/SKILL.md

@@ -0,0 +1,51 @@
+---
+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.
+---
+
+# Pi-Rogue Advisor
+
+Use this skill for non-trivial decisions before/after significant edits.
+
+## Quick start
+
+- `/pi-rogue` — open cockpit and command pointers
+- `/advisor status` — show current advisor settings and model route
+- `/advisor <question>` — ask immediate advice
+- Check-ins are lifecycle-managed by orchestration, not by the advisor command surface
+
+## Command surface
+
+| Command | What it does |
+|---|---|
+| `/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 config` | Dump full config |
+| `/advisor pause <N>` | Pause advisor auto-runs for the next N turns |
+| `/advisor unpause` | Resume advisor auto-runs immediately |
+| `/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 standalone check-in command: check-ins are triggered from goal/loop orchestration cadence (not from advisor internals), using higher/advanced advisor models first with regular model fallback enabled by default.
+
+## Keep scope clear
+
+- Successful `on_track` review verdicts are recorded silently instead of displayed as follow-up messages.
+- Goal/loop-managed check-ins gate on session activity and `checkinIntervalMinutes`, avoid overlapping calls, and use higher/advanced advisor models first with regular model fallback enabled by default.
+- 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 owns cadence and enables them when a goal or loop is active
+- `checkinIntervalMinutes: 30`
+- `model: auto`

package/node_modules/@fiale-plus/pi-rogue-advisor/src/completions.test.ts

@@ -0,0 +1,28 @@
+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", "model", "review", "pause", "unpause"]));
+    expect(values).not.toContain("checkins");
+  });
+
+  it("offers nested review choices", () => {
+    const values = advisorArgumentCompletions("review ")?.map((i) => i.value);
+    expect(values).toEqual(["light", "strict", "off"]);
+  });
+
+});
+
+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/node_modules/@fiale-plus/pi-rogue-advisor/src/completions.ts

@@ -0,0 +1,79 @@
+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"],
+  ["pause", "pause advisor auto-runs for N turns"],
+  ["unpause", "resume advisor auto-runs immediately"],
+  ["model", "set or inspect model override"],
+];
+
+const advisorNested: Record<string, Array<[string, string?]>> = {
+  mode: [["auto"], ["manual"], ["off"]],
+  review: [["light"], ["strict"], ["off"]],
+  model: [["auto"], ["openai-codex/gpt-5.5"], ["anthropic/claude-opus-4-6"]],
+};
+
+const piRogueTopLevel: Array<[string, string?]> = [
+  ["status", "show cockpit"],
+  ["advisor", "advisor status"],
+  ["orchestration", "goal/loop/autoresearch shortcuts"],
+  ["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"],
+  ],
+  help: [["advisor"], ["orchestration"], ["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/node_modules/@fiale-plus/pi-rogue-advisor/src/extension.test.ts

@@ -0,0 +1,257 @@
+import { describe, expect, it, vi } from "vitest";
+import { completeSimple } from "@earendil-works/pi-ai";
+import {
+  buildAdvisorCheckinPrompt,
+  completeWithHigherAdvisorModel,
+  completeWithModelFallback,
+  contentText,
+  normalizeAdvisorConfig,
+  shouldRunCheckin,
+  type AdvisorConfig,
+} 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 {
+    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, 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("off");
+    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", 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, 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 = 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 = normalizeAdvisorConfig({ mode: "auto", review: "light", model: "claude-opus-4-6" });
+    const json = JSON.stringify(original);
+    const parsed = normalizeAdvisorConfig(JSON.parse(json) as AdvisorConfig);
+    expect(parsed.mode).toBe("auto");
+    expect(parsed.review).toBe("light");
+    expect(parsed.checkins).toBe("off");
+    expect(parsed.checkinIntervalMinutes).toBe(30);
+    expect(parsed.model).toBe("claude-opus-4-6");
+  });
+});
+
+describe("advisor message extraction", () => {
+  it("extracts nested structured content without object string leakage", () => {
+    expect(contentText({ content: [{ type: "text", text: "done" }] })).toBe("done");
+    expect(contentText([{ type: "toolResult", content: [{ type: "text", text: "ok" }] }])).toBe("ok");
+    expect(contentText({ arbitrary: "shape" })).toBe("");
+  });
+});
+
+describe("mid-hour check-ins", () => {
+  it("does not run immediately after session start", () => {
+    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({ 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({ 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();
+  });
+
+  it("does not run when check-ins are disabled", () => {
+    const cfg = normalizeAdvisorConfig({ checkins: "off" });
+    expect(shouldRunCheckin(cfg, state(), 999999, 1)).toBeNull();
+  });
+
+  it("skips check-in while advisor is in temporary pause", () => {
+    const cfg = normalizeAdvisorConfig({ checkins: "mid-hour", checkinIntervalMinutes: 30 });
+    expect(
+      shouldRunCheckin(cfg, state({
+        turns: 5,
+        advisorPauseUntilTurn: 10,
+      }), 2_000_000, 1_000),
+    ).toBeNull();
+  });
+
+  it("allows check-in after pause expires", () => {
+    const cfg = normalizeAdvisorConfig({ checkins: "mid-hour", checkinIntervalMinutes: 30 });
+    const startedAt = 1_000;
+    const now = startedAt + 31 * 60_000;
+    expect(
+      shouldRunCheckin(cfg, state({
+        turns: 12,
+        lastTask: "work",
+        notes: ["note"],
+        advisorPauseUntilTurn: 10,
+      }), now, startedAt),
+    ).toMatch(/mid-hour check-in/);
+  });
+
+  it("keeps loop-triggered check-ins bounded by the minute interval", () => {
+    const cfg = normalizeAdvisorConfig({ checkins: "mid-hour", checkinIntervalMinutes: 30 });
+    const startedAt = 1_000;
+    const now = startedAt + 5 * 60_000;
+    expect(
+      shouldRunCheckin(cfg, state({
+        turns: 5,
+        checkin: { lastAt: new Date(startedAt).toISOString(), lastTurn: 3 },
+        lastTask: "work",
+        notes: ["note"],
+      }), now, startedAt),
+    ).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");
+  });
+
+  it("keeps check-in guidance anchored to the active goal", () => {
+    const prompt = buildAdvisorCheckinPrompt(
+      "loop_tick",
+      [
+        "Orchestration:",
+        "- Goal: active — Autoresearch: solve advisor weaknesses",
+        "- Autoresearch: active — solve advisor weaknesses; cycles=1",
+        "- Loop: active every 5m — Run one autoresearch cycle toward the active goal.",
+      ].join("\n"),
+      "Task: solve advisor weaknesses\nNotes:\n- found shallow mid-hour feedback",
+    );
+
+    expect(prompt).toContain("alignment reviewer");
+    expect(prompt).toContain("Do not create a new task");
+    expect(prompt).toContain("preserve its research question");
+    expect(prompt).toContain("solving the named weakness");
+    expect(prompt).toContain("Nudge: <one concrete next action that continues the active goal>");
+    expect(prompt).toContain("found shallow mid-hour feedback");
+  });
+});
+
+
+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");
+  });
+});
+
+
+describe("SOTA model suggestions", () => {
+  it("includes gpt-5.5 as primary option", () => {
+    const cfg = normalizeAdvisorConfig({ mode: "auto", review: "light" });
+    expect(cfg.model).toBeUndefined(); // model is optional, auto-detect
+  });
+});