@fiale-plus/pi-rogue-bundle 0.1.13 → 0.1.15

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/extension.ts

@@ -5,7 +5,7 @@ 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 { featureFile, readText, truncate, writeText, atomicWriteText } from "./internal.js";
 import { advisorArgumentCompletions, piRogueArgumentCompletions } from "./completions.js";
 import {
   appendRouteLog,
@@ -58,6 +58,7 @@ const MAX_FILES = 8;
 const MAX_ERRORS = 5;
 const MIN_CHECKIN_INTERVAL_MINUTES = 10;
 const MAX_CHECKIN_INTERVAL_MINUTES = 240;
+const STATE_VERSION = 1;
 const checkinLocks = new Set<string>();
 
 // ── SOTA models (ordered by preference) ───────────────────────────────────
@@ -70,6 +71,8 @@ const SOTA_CHAIN: Array<{ provider: string; model: string; label: string }> = [
 
 // ── Internal state ────────────────────────────────────────────────────────
 interface SessionState {
+  /** State schema version for migration support */
+  _v?: number;
   turns: number;
   lastTask: string;
   notes: string[];
@@ -159,9 +162,18 @@ function saveConfig(c: AdvisorConfig) {
 
 function loadState(): SessionState {
   const raw = readJson<Partial<SessionState>>(STATE_PATH, {});
+  // Handle state versioning: migrate old versions to current
+  const version = raw._v ?? 0;
+  if (version < STATE_VERSION) {
+    // Migrate: ensure reviewControl has all fields
+    if (raw.reviewControl && !raw.reviewControl.lastAppliedAt) {
+      (raw.reviewControl as any).lastAppliedAt = new Date().toISOString();
+    }
+  }
   const control = raw.reviewControl;
   const pauseUntil = Number(raw.advisorPauseUntilTurn);
   return {
+    _v: STATE_VERSION,
     turns: raw.turns ?? 0,
     lastTask: raw.lastTask ?? "",
     notes: (raw.notes ?? []).map(noteText).filter(Boolean).slice(-MAX_NOTES),
@@ -197,7 +209,7 @@ function loadState(): SessionState {
 }
 
 function saveState(s: SessionState) {
-  writeJson(STATE_PATH, s);
+  atomicWriteText(STATE_PATH, JSON.stringify(s, null, 2) + "\n");
 }
 
 function loadCache(): Record<string, string> {
@@ -210,21 +222,50 @@ function saveCache(c: Record<string, string>) {
     entries.sort((a, b) => a[0].localeCompare(b[0]));
     for (const [k] of entries.slice(0, entries.length - MAX_CACHE)) delete c[k];
   }
-  writeJson(CACHE_PATH, c);
+  atomicWriteText(CACHE_PATH, JSON.stringify(c, null, 2) + "\n");
 }
 
 // ── Prompts ───────────────────────────────────────────────────────────────
 
-const ADVISOR_SYSTEM = `You are a senior engineering advisor. Use the session brief only. Return terse, specific advice with concrete recommendations. 200 words max.`;
+const ADVISOR_SYSTEM = `You are a senior engineering advisor. Use the session brief only. Return terse, specific advice with concrete recommendations. 200 words max.
+
+## Guidance
+- Focus on actionable insights, not summaries of what was done.
+- If no issues found, say so briefly — do not invent problems.
+- Flag security concerns, architecture risks, and test gaps.
+- Reference specific files or lines when possible.`;
+
+const REVIEW_SYSTEM = `You are a senior reviewer. An AI agent just completed work. Assess it and return ONLY valid JSON.
+
+## Verdicts
+- **on_track**: Work is complete. Changes are correct, tests pass (if applicable), no outstanding issues. This is the default for clearly finished work.
+- **course_correct**: Work is mostly done but needs specific changes. Minor fixes, adjustments, or refinements required. Be specific about what needs to change.
+- **not_done**: Work is incomplete, failing, or has critical errors. The agent has not finished the task. Include what is missing or broken.
+
+## Confidence Calibration
+- 0.80+ = clear signal (e.g., explicit "done" with file changes, or explicit errors)
+- 0.60-0.79 = moderate signal (e.g., partial completion, some issues noted)
+- <0.60 = weak signal — defer rather than force a verdict
+
+## Guidelines
+- Focus on MATERIAL changes (logic, behavior, correctness). Ignore cosmetic changes (formatting, comments, whitespace).
+- If the agent explicitly states "done"/"fixed"/"implemented" AND file changes are small/simple → on_track.
+- If the agent states "done" BUT there are errors or incomplete logic → course_correct or not_done.
+- If the agent states "incomplete"/"wip"/"todo" → not_done.
+- Actions should be concrete next steps (2 max), not vague suggestions.
+- Checklist items are optional — include only when there are specific verification steps.
+- notify is always false for this system.
+
+## Examples
+
+Example 1 (on_track):
+{ "verdict": "on_track", "summary": "Added new endpoint and tests pass", "actions": [], "checklist": ["Verify endpoint returns 200"], "notify": false }
+
+Example 2 (course_correct):
+{ "verdict": "course_correct", "summary": "Refactored module but error handling was removed", "actions": ["Restore error handling in handleRequest"], "checklist": [], "notify": false }
 
-const REVIEW_SYSTEM = `You are a senior reviewer. An AI agent just completed work. Assess it. Return ONLY valid JSON:
-{
-  "verdict": "on_track"|"course_correct"|"not_done",
-  "summary": "1-2 sentence assessment",
-  "actions": ["action1"],
-  "checklist": ["item"],
-  "notify": false
-}`;
+Example 3 (not_done):
+{ "verdict": "not_done", "summary": "Migration script has syntax errors and missing table reference", "actions": ["Fix syntax errors in migration.sql", "Add missing users table reference"], "checklist": ["Verify migration runs cleanly"], "notify": false }`;
 
 // ── Helpers ───────────────────────────────────────────────────────────────
 

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

@@ -1,4 +1,4 @@
-import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { appendFileSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 
@@ -46,3 +46,18 @@ export function appendText(filePath: string, text: string): void {
   ensureParent(filePath);
   appendFileSync(filePath, text, "utf8");
 }
+
+/** Write text atomically: write to temp file, then rename. Falls back to direct write on failure. */
+export function atomicWriteText(filePath: string, text: string): void {
+  const tempPath = filePath + ".tmp";
+  try {
+    writeText(tempPath, text);
+    try { renameSync(tempPath, filePath); } catch {
+      // If rename fails (e.g., cross-device), fall back to overwrite
+      writeText(filePath, text);
+    }
+  } catch {
+    // If temp write fails, try direct write
+    writeText(filePath, text);
+  }
+}

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

@@ -6,6 +6,13 @@ import { join } from "node:path";
 import { completeSimple } from "@earendil-works/pi-ai";
 import { registerAdvisor } from "./extension.js";
 
+const testHome = vi.hoisted(() => `/tmp/pi-rogue-advisor-loop-convergence-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+
+vi.mock("node:os", async () => {
+  const actual = await vi.importActual<typeof import("node:os")>("node:os");
+  return { ...actual, homedir: () => testHome };
+});
+
 vi.mock("@earendil-works/pi-ai", async () => {
   const actual = await vi.importActual<typeof import("@earendil-works/pi-ai")>("@earendil-works/pi-ai");
   return {

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

@@ -3,6 +3,7 @@ import { copyFileSync, existsSync, mkdirSync, readFileSync, statSync } from "nod
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { appendText, featureFile, truncate } from "./internal.js";
+import { extractBinaryGateFeatureCounts } from "./binary-gate-features.js";
 
 export type AdvisorPhase = "preflight" | "review" | "closeout";
 export type PreflightLabel = "continue" | "escalate_to_advisor" | "need_more_context" | "low_confidence";
@@ -85,43 +86,8 @@ function loadBinaryGate(): BinaryGateModel | null {
   } catch { _binaryGateCache = null; return null; }
 }
 
-function binaryGateTokens(text: string): string[] {
-  const norm = String(text ?? "").toLowerCase()
-    .replace(/https?:\/\/\S+/g, " url ")
-    .replace(/[^a-z0-9\s']/g, " ")
-    .replace(/\s+/g, " ").trim();
-  return norm ? norm.split(" ").filter(Boolean) : [];
-}
-
 function binaryGateFeatures(text: string, model: BinaryGateModel) {
-  const toks = binaryGateTokens(text);
-  const lower = String(text ?? "").toLowerCase()
-    .replace(/https?:\/\/\S+/g, " url ")
-    .replace(/[^a-z0-9\s']/g, " ")
-    .replace(/\s+/g, " ").trim();
-  const counts = new Map<string, number>();
-  const inc = (k: string, b = 1) => counts.set(k, (counts.get(k) || 0) + b);
-  for (const n of [1, 2]) {
-    if (toks.length >= n) for (let i = 0; i <= toks.length - n; i++)
-      inc(`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(`c${n}:${g}`);
-    }
-  }
-  if (toks.length > 0) inc(`pref1:${toks[0]}`);
-  if (toks.length > 1) inc(`pref2:${toks.slice(0, 2).join("_")}`);
-  if (toks.length > 2) inc(`pref3:${toks.slice(0, 3).join("_")}`);
-  if (text.includes("?")) inc("cue:question_mark");
-  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 ts = new Set(toks);
-  for (const c of cues) if (ts.has(c)) inc(`cue:${c}`);
-  for (const c of multi) if (lower.includes(c)) inc(`cue:${c.replace(/\s+/g,"_")}`);
-
+  const counts = extractBinaryGateFeatureCounts(text);
   const index = new Map(model.features.map((f, i) => [f, i]));
   const pairs: Array<[number, number]> = [];
   let nrm = 0;
@@ -129,7 +95,8 @@ function binaryGateFeatures(text: string, model: BinaryGateModel) {
     const idx = index.get(feature);
     if (idx === undefined) continue;
     const value = (1 + Math.log(tf)) * model.idf[idx];
-    pairs.push([idx, value]); nrm += value * value;
+    pairs.push([idx, value]);
+    nrm += value * value;
   }
   const scale = nrm > 0 ? 1 / Math.sqrt(nrm) : 1;
   pairs.sort((a, b) => a[0] - b[0]);