@fiale-plus/pi-rogue 0.2.0

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/binary-gate-features.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { extractBinaryGateFeatureCounts } from "./binary-gate-features.js";
+
+describe("binary gate feature extraction", () => {
+  it("emits shared lexical and routing cue features", () => {
+    const features = extractBinaryGateFeatureCounts("review the auth migration diff before production deploy?");
+
+    expect(features.get("cue:question_mark")).toBe(1);
+    expect(features.get("cue:question_punct")).toBe(1);
+    expect(features.get("cue:imperative")).toBe(1);
+    expect(features.get("len_bucket:medium")).toBe(1);
+    expect(features.get("complex:auth")).toBe(1);
+    expect(features.get("complex:migration")).toBe(1);
+    expect(features.get("review:review")).toBe(1);
+    expect(features.get("review:diff")).toBe(1);
+    expect(features.get("safety:production")).toBe(1);
+    expect(features.get("safety:deploy")).toBe(1);
+  });
+});

package/node_modules/@fiale-plus/pi-rogue-advisor/src/binary-gate-features.ts

@@ -0,0 +1,248 @@
+const NORMALIZE_REPLACEMENT_PATTERNS = [
+  [/https?:\/\/\S+/g, " url "],
+  [/[^a-z0-9\s']/g, " "],
+] as const;
+
+function normalizeBinaryGateText(text: string): string {
+  return String(text ?? "")
+    .toLowerCase()
+    .replace(NORMALIZE_REPLACEMENT_PATTERNS[0]![0], NORMALIZE_REPLACEMENT_PATTERNS[0]![1])
+    .replace(NORMALIZE_REPLACEMENT_PATTERNS[1]![0], NORMALIZE_REPLACEMENT_PATTERNS[1]![1])
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function normalizeBinaryGateTokens(text: string): string[] {
+  const norm = normalizeBinaryGateText(text);
+  return norm ? norm.split(" ").filter(Boolean) : [];
+}
+
+function replaceSpaces(value: string): string {
+  return value.replace(/\s+/g, "_");
+}
+
+function inc(map: Map<string, number>, key: string, by = 1): void {
+  map.set(key, (map.get(key) || 0) + by);
+}
+
+export function extractBinaryGateFeatureCounts(text: string): Map<string, number> {
+  const counts = new Map<string, number>();
+  const toks = normalizeBinaryGateTokens(text);
+  const lower = normalizeBinaryGateText(text);
+
+  for (const n of [1, 2]) {
+    if (toks.length >= n) {
+      for (let i = 0; i <= toks.length - n; i++) {
+        inc(counts, `w${n}:${toks.slice(i, i + n).join("_")}`);
+      }
+    }
+  }
+
+  const norm = ` ${lower} `;
+  for (const n of [3, 4]) {
+    if (norm.length >= n) {
+      for (let i = 0; i <= norm.length - n; i++) {
+        const g = norm.slice(i, i + n);
+        if (!/^\s+$/.test(g)) {
+          inc(counts, `c${n}:${g}`);
+        }
+      }
+    }
+  }
+
+  if (toks.length > 0) inc(counts, `pref1:${toks[0]}`);
+  if (toks.length > 1) inc(counts, `pref2:${toks.slice(0, 2).join("_")}`);
+  if (toks.length > 2) inc(counts, `pref3:${toks.slice(0, 3).join("_")}`);
+
+  if (text.includes("?")) inc(counts, "cue:question_mark");
+
+  if (toks.length > 0) {
+    inc(counts, `len_bucket:${toks.length <= 3 ? "short" : toks.length <= 8 ? "medium" : "long"}`);
+  }
+
+  if (/[\?\!]/.test(text)) {
+    inc(counts, "cue:question_punct");
+  }
+
+  const imperative = /^(create|add|make|change|write|fix|update|remove|delete|run|install|set|build|deploy|check|investigate|debug|review|test|refactor|merge|close|open|start|stop|continue|show|list|compact|setup|implement|build|write|create|add|make|refactor|rename|extract|migrate|patch)/i.test(text.trim());
+  if (imperative) {
+    inc(counts, "cue:imperative");
+  }
+
+  const safetyWords = [
+    "rm -rf",
+    "sudo",
+    "shutdown",
+    "reboot",
+    "mkfs",
+    "chmod -R",
+    "chown",
+    "git push --force",
+    "curl | sh",
+    "wget | sh",
+    "drop table",
+    "delete database",
+    "secret",
+    "token",
+    "credential",
+    "password",
+    "prod",
+    "production",
+    "deploy",
+    "deploying",
+  ];
+  for (const safetyWord of safetyWords) {
+    if (lower.includes(safetyWord)) {
+      inc(counts, `safety:${replaceSpaces(safetyWord)}`);
+    }
+  }
+
+  const complexityWords = [
+    "architecture",
+    "refactor",
+    "design",
+    "tradeoff",
+    "security",
+    "auth",
+    "migration",
+    "performance",
+    "scale",
+    "scalability",
+    "framework",
+    "system design",
+    "schema",
+    "data model",
+    "protocol",
+    "advisor routing",
+    "advisor flow",
+    "router logic",
+    "call vs skip",
+    "skip vs call",
+    "compare",
+    "recommend",
+    "benchmark",
+    "evaluate",
+    "experiment",
+    "train",
+    "strategy",
+    "choose",
+    "make sense",
+    "worth",
+    "kpi",
+    "kpis",
+    "how it works",
+    "where it comes from",
+    "what would you choose",
+    "what do you think",
+    "next step",
+    "pick between",
+    "buy",
+    "usage",
+    "sustained speed",
+    "available models",
+    "running model kpis",
+  ];
+  let complexityCount = 0;
+  for (const complexityWord of complexityWords) {
+    if (lower.includes(complexityWord)) {
+      complexityCount++;
+      inc(counts, `complex:${replaceSpaces(complexityWord)}`);
+    }
+  }
+  if (complexityCount > 0) {
+    inc(counts, `complex_count:${complexityCount}`);
+  }
+
+  const debugWords = ["debug", "bug", "error", "stack trace", "traceback", "fail", "broken", "investigate", "why is", "cannot", "can't", "crash", "regression"];
+  for (const debugWord of debugWords) {
+    if (lower.includes(debugWord)) {
+      inc(counts, `debug:${replaceSpaces(debugWord)}`);
+    }
+  }
+
+  const contextWords = ["need more context", "missing context", "clarify", "not enough info", "unspecified", "unknown", "ambiguous"];
+  for (const contextWord of contextWords) {
+    if (lower.includes(contextWord)) {
+      inc(counts, `context:${replaceSpaces(contextWord)}`);
+    }
+  }
+
+  const reviewWords = ["review", "check", "verify", "validate", "diff", "pr", "pull request", "feedback"];
+  for (const reviewWord of reviewWords) {
+    if (lower.includes(reviewWord)) {
+      inc(counts, `review:${replaceSpaces(reviewWord)}`);
+    }
+  }
+
+  const doneWords = ["done", "complete", "fixed", "implemented", "works", "passing tests", "tests pass", "verified", "looks good", "merged"];
+  for (const doneWord of doneWords) {
+    if (lower.includes(doneWord)) {
+      inc(counts, `done:${replaceSpaces(doneWord)}`);
+    }
+  }
+
+  const checkinWords = ["check-in", "checkin", "mid-hour", "alignment", "progress", "status", "stats", "log", "logs"];
+  for (const checkinWord of checkinWords) {
+    if (lower.includes(checkinWord)) {
+      inc(counts, `checkin:${replaceSpaces(checkinWord)}`);
+    }
+  }
+
+  const cues = [
+    "check",
+    "why",
+    "what",
+    "how",
+    "should",
+    "status",
+    "stats",
+    "log",
+    "logs",
+    "review",
+    "diff",
+    "pr",
+    "build",
+    "run",
+    "test",
+    "deploy",
+    "fix",
+    "debug",
+    "install",
+    "configure",
+    "plan",
+    "continue",
+    "resume",
+    "compact",
+    "research",
+    "update",
+    "patch",
+    "cleanup",
+    "remove",
+  ];
+  const multi = [
+    "what is",
+    "what's",
+    "safe to use",
+    "pull request",
+    "model family",
+    "how does",
+    "next step",
+    "path forward",
+    "should we",
+    "what should",
+  ];
+
+  const tokenSet = new Set(toks);
+  for (const cue of cues) {
+    if (tokenSet.has(cue)) {
+      inc(counts, `cue:${cue}`);
+    }
+  }
+  for (const cue of multi) {
+    if (lower.includes(cue)) {
+      inc(counts, `cue:${replaceSpaces(cue)}`);
+    }
+  }
+
+  return counts;
+}

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

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { binaryGatePredict } from "./router.js";
+
+describe("binary gate model", () => {
+  it("returns a decision when model is available", () => {
+    const result = binaryGatePredict("test");
+    if (result) {
+      expect(["continue", "escalate"]).toContain(result.decision);
+      expect(result.confidence).toBeGreaterThanOrEqual(0);
+      expect(result.confidence).toBeLessThanOrEqual(1);
+    }
+  });
+
+  it("classifies short prompts and returns a valid decision", () => {
+    const result = binaryGatePredict("fix typo");
+    if (result) {
+      expect(["continue", "escalate"]).toContain(result.decision);
+      expect(result.confidence).toBeGreaterThan(0.5);
+    }
+  });
+
+  it("handles empty text gracefully", () => {
+    const result = binaryGatePredict("");
+    if (result) {
+      expect(["continue", "escalate"]).toContain(result.decision);
+      expect(result.confidence).toBeGreaterThanOrEqual(0);
+      expect(result.confidence).toBeLessThanOrEqual(1);
+    }
+  });
+
+  it("handles very long text without crashing", () => {
+    const longText = "a".repeat(10000);
+    const result = binaryGatePredict(longText);
+    if (result) {
+      expect(result.confidence).toBeGreaterThanOrEqual(0);
+      expect(result.confidence).toBeLessThanOrEqual(1);
+    }
+  });
+
+  it("handles unicode text", () => {
+    const result = binaryGatePredict("Привет мир 你好世界 مرحبا بالعالم");
+    if (result) {
+      expect(["continue", "escalate"]).toContain(result.decision);
+      expect(result.confidence).toBeGreaterThanOrEqual(0);
+      expect(result.confidence).toBeLessThanOrEqual(1);
+    }
+  });
+
+  it("handles special characters and potential injection", () => {
+    const result = binaryGatePredict("fix <script>alert('xss')</script> && rm -rf /");
+    if (result) {
+      expect(["continue", "escalate"]).toContain(result.decision);
+      expect(result.confidence).toBeGreaterThanOrEqual(0);
+      expect(result.confidence).toBeLessThanOrEqual(1);
+    }
+  });
+
+  it("handles URLs", () => {
+    const result = binaryGatePredict("check https://example.com/path?query=value&foo=bar");
+    if (result) {
+      expect(["continue", "escalate"]).toContain(result.decision);
+      expect(result.confidence).toBeGreaterThanOrEqual(0);
+      expect(result.confidence).toBeLessThanOrEqual(1);
+    }
+  });
+});

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);
+}