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

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

@@ -0,0 +1,3 @@
+export { default, registerAdvisor } from "./extension.js";
+export { requestAdvisorLoopCheckin } from "./extension.js";
+export * from "./router.js";

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

@@ -0,0 +1,48 @@
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+const ROOT_DIR = join(homedir(), ".pi", "agent", "pi-rogue");
+
+export function appDir(): string {
+  mkdirSync(ROOT_DIR, { recursive: true });
+  return ROOT_DIR;
+}
+
+export function featureDir(feature: string): string {
+  const dir = join(appDir(), feature);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function featureFile(feature: string, filename: string): string {
+  return join(featureDir(feature), filename);
+}
+
+export function truncate(text: string, max: number): string {
+  if (text.length <= max) return text;
+  return `${text.slice(0, Math.max(0, max - 1))}…`;
+}
+
+export function readText(filePath: string, fallback = ""): string {
+  try {
+    return readFileSync(filePath, "utf8");
+  } catch {
+    return fallback;
+  }
+}
+
+function ensureParent(filePath: string): string {
+  mkdirSync(dirname(filePath), { recursive: true });
+  return filePath;
+}
+
+export function writeText(filePath: string, text: string): void {
+  ensureParent(filePath);
+  writeFileSync(filePath, text, "utf8");
+}
+
+export function appendText(filePath: string, text: string): void {
+  ensureParent(filePath);
+  appendFileSync(filePath, text, "utf8");
+}

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

@@ -0,0 +1,301 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { completeSimple } from "@earendil-works/pi-ai";
+import { registerAdvisor } 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(),
+  };
+});
+
+type Handler = (event: any, ctx: any) => any;
+
+type HandlerMap = Record<string, Handler[]>;
+
+function makeHandlers() {
+  const handlers: HandlerMap = {};
+  const sendMessage = vi.fn();
+
+  const pi = {
+    on: (event: string, handler: Handler) => {
+      handlers[event] ??= [];
+      handlers[event].push(handler);
+    },
+    registerMessageRenderer: () => undefined,
+    registerCommand: () => undefined,
+    registerTool: vi.fn(),
+    sendMessage,
+    sendUserMessage: () => undefined,
+    ui: {
+      setStatus: () => undefined,
+      notify: () => undefined,
+    },
+  };
+
+  return { handlers, pi: pi as any, sendMessage };
+}
+
+const ADVISOR_STATE_DIR = join(homedir(), ".pi", "agent", "pi-rogue", "advisor");
+const ADVISOR_STATE_PATH = join(ADVISOR_STATE_DIR, "state.json");
+const ADVISOR_CONFIG_PATH = join(ADVISOR_STATE_DIR, "config.json");
+
+function readAdvisorState(): any {
+  return JSON.parse(readFileSync(ADVISOR_STATE_PATH, "utf8"));
+}
+
+function mkCtx() {
+  return {
+    sessionManager: {
+      getSessionFile: () => join(homedir(), ".pi", "agent", "pi-rogue", "advisor", "session.jsonl"),
+    },
+    isIdle: () => true,
+    modelRegistry: {
+      find: (provider: string, model: string) => {
+        if (provider === "openai-codex") return { id: `${provider}/${model}`, provider, input: ["text"] };
+        return null;
+      },
+      getAvailable: () => [{ id: "provider/text-light", provider: "provider", input: ["text"] }],
+      getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "k", headers: {} }),
+    },
+    ui: {
+      setStatus: () => undefined,
+      notify: () => undefined,
+    },
+  } as any;
+}
+
+describe("advisor two-agent convergence", () => {
+  let ctx: any;
+  let handlers: HandlerMap;
+  let sendMessageMock: ReturnType<typeof vi.fn>;
+  let completeSimpleMock: ReturnType<typeof vi.fn>;
+  let priorState: string | null = null;
+  let priorConfig: string | null = null;
+
+  beforeEach(() => {
+    priorState = existsSync(ADVISOR_STATE_PATH) ? readFileSync(ADVISOR_STATE_PATH, "utf8") : null;
+    priorConfig = existsSync(ADVISOR_CONFIG_PATH) ? readFileSync(ADVISOR_CONFIG_PATH, "utf8") : null;
+
+    const setup = makeHandlers();
+    handlers = setup.handlers;
+    sendMessageMock = setup.sendMessage;
+
+    mkdirSync(dirname(ADVISOR_STATE_PATH), { recursive: true });
+    writeFileSync(ADVISOR_CONFIG_PATH, JSON.stringify({ mode: "auto", review: "light", checkins: "off", checkinIntervalMinutes: 30 }, null, 2), "utf8");
+    writeFileSync(ADVISOR_STATE_PATH, JSON.stringify({
+      turns: 0,
+      lastTask: "",
+      notes: [],
+      files: [],
+      errors: [],
+      advisorCalls: 0,
+      cacheHits: 0,
+      followUp: "",
+      router: {},
+      checkin: { queued: false },
+      reviewControl: {
+        status: "idle",
+        pending: false,
+        consumed: true,
+        running: false,
+      },
+    }, null, 2), "utf8");
+
+    registerAdvisor(setup.pi);
+
+    ctx = mkCtx();
+    completeSimpleMock = vi.mocked(completeSimple as any);
+    completeSimpleMock.mockReset();
+
+    const verdict = {
+      verdict: "not_done",
+      summary: "Closeout is incomplete",
+      reason: "Please run one concrete check and report the result",
+      actions: ["run focused check"],
+      checklist: [],
+      notify: true,
+    };
+    completeSimpleMock.mockResolvedValue({ content: [{ type: "text", text: JSON.stringify(verdict) }] });
+  });
+
+  afterEach(() => {
+    if (priorState === null) {
+      writeFileSync(ADVISOR_STATE_PATH, "{}", "utf8");
+    } else {
+      writeFileSync(ADVISOR_STATE_PATH, priorState, "utf8");
+    }
+
+    if (priorConfig === null) {
+      writeFileSync(ADVISOR_CONFIG_PATH, "{}", "utf8");
+    } else {
+      writeFileSync(ADVISOR_CONFIG_PATH, priorConfig, "utf8");
+    }
+  });
+
+  it("does not re-run advisory review on repeated material snapshots", async () => {
+    const preflight = handlers.before_agent_start;
+    const turnEnd = handlers.turn_end;
+    expect(preflight?.length).toBe(1);
+    expect(turnEnd?.length).toBe(1);
+
+    await handlers.session_start?.[0]?.({}, ctx);
+
+    const basePrompt = "Continue the current goal";
+    const statusText = "Repo-side autoresearch is verified closed. Only optional external rollout/CI smoke remains.";
+
+    const firstPrompt = await preflight![0]({ systemPrompt: "SYS", prompt: basePrompt }, ctx);
+    expect(typeof firstPrompt).toBe("object");
+
+    await turnEnd![0]({
+      toolResults: [{ toolName: "edit" }],
+      message: { role: "assistant", content: statusText },
+    }, ctx);
+
+    const firstState = readAdvisorState();
+    expect(firstState.reviewControl.lastDecision).toBe("review");
+    expect(firstState.followUp).toContain("Closeout is incomplete");
+    expect(completeSimpleMock).toHaveBeenCalledTimes(1);
+
+    const consumedPrompt = await preflight![0]({ systemPrompt: "SYS", prompt: basePrompt }, ctx);
+    expect(String(consumedPrompt?.systemPrompt)).toContain("Advisor follow-up");
+
+    const consumedState = readAdvisorState();
+    expect(consumedState.reviewControl.status).toBe("consumed");
+    expect(consumedState.followUp).toBe("");
+
+    await turnEnd![0]({
+      toolResults: [{ toolName: "edit" }],
+      message: { role: "assistant", content: statusText },
+    }, ctx);
+
+    const secondState = readAdvisorState();
+    expect(completeSimpleMock).toHaveBeenCalledTimes(1);
+    expect(secondState.reviewControl.status).toBe("consumed");
+    expect(["repeated material snapshot", firstState.reviewControl.lastReason]).toContain(secondState.reviewControl.lastReason);
+
+    const withoutFollowUp = await preflight![0]({ systemPrompt: "SYS", prompt: basePrompt }, ctx);
+    expect(String(withoutFollowUp?.systemPrompt)).not.toContain("Advisor follow-up");
+  });
+
+  it("does not re-run advisory review on repeated agent-end material snapshots", async () => {
+    const preflight = handlers.before_agent_start;
+    const agentEnd = handlers.agent_end;
+    expect(preflight?.length).toBe(1);
+    expect(agentEnd?.length).toBe(1);
+
+    await handlers.session_start?.[0]?.({}, ctx);
+
+    const basePrompt = "Continue the current goal";
+    const statusText = "Repo-side autoresearch is verified closed. Only optional external rollout/CI smoke remains.";
+
+    const firstPrompt = await preflight![0]({ systemPrompt: "SYS", prompt: basePrompt }, ctx);
+    expect(typeof firstPrompt).toBe("object");
+
+    await agentEnd![0]({
+      messages: [
+        { role: "assistant", content: statusText },
+        { role: "toolResult", content: "edit tool changed file" },
+      ],
+    }, ctx);
+
+    const firstState = readAdvisorState();
+    expect(firstState.reviewControl).toBeTruthy();
+    const callsBeforeSecond = completeSimpleMock.mock.calls.length;
+
+    const consumedPrompt = await preflight![0]({ systemPrompt: "SYS", prompt: basePrompt }, ctx);
+    if (firstState.followUp) {
+      expect(String(consumedPrompt?.systemPrompt)).toContain("Advisor follow-up");
+    } else {
+      expect(String(consumedPrompt?.systemPrompt)).not.toContain("Advisor follow-up");
+    }
+
+    const consumedState = readAdvisorState();
+    expect(consumedState.reviewControl.status).toBe("consumed");
+    expect(consumedState.followUp).toBe("");
+
+    await agentEnd![0]({
+      messages: [
+        { role: "assistant", content: statusText },
+        { role: "toolResult", content: "edit tool changed file" },
+      ],
+    }, ctx);
+
+    const secondState = readAdvisorState();
+    expect(completeSimpleMock).toHaveBeenCalledTimes(callsBeforeSecond);
+    expect(secondState.reviewControl.status).toBe("consumed");
+    expect(secondState.reviewControl.lastReason).toBe("repeated material snapshot");
+
+    const withoutFollowUp = await preflight![0]({ systemPrompt: "SYS", prompt: basePrompt }, ctx);
+    expect(String(withoutFollowUp?.systemPrompt)).not.toContain("Advisor follow-up");
+  });
+
+  it("records on-track reviews silently instead of emitting repetitive continue hints", async () => {
+    const preflight = handlers.before_agent_start;
+    const turnEnd = handlers.turn_end;
+    expect(preflight?.length).toBe(1);
+    expect(turnEnd?.length).toBe(1);
+
+    completeSimpleMock.mockResolvedValue({
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          verdict: "on_track",
+          summary: "Implementation aligns with the requested advisor check-in behavior",
+          actions: [],
+          checklist: [],
+          notify: true,
+        }),
+      }],
+    });
+
+    await handlers.session_start?.[0]?.({}, ctx);
+    await preflight![0]({ systemPrompt: "SYS", prompt: "Continue the current goal" }, ctx);
+    await turnEnd![0]({
+      toolResults: [{ toolName: "edit" }],
+      message: { role: "assistant", content: "Secret token handling was reviewed and the safety fix is complete." },
+    }, ctx);
+
+    const state = readAdvisorState();
+    expect(completeSimpleMock).toHaveBeenCalledTimes(1);
+    expect(state.reviewControl.lastDecision).toBe("continue");
+    expect(sendMessageMock).not.toHaveBeenCalledWith(
+      expect.objectContaining({ customType: "advisor:llm" }),
+      expect.anything(),
+    );
+  });
+
+  it("recovers running review control state on session start", async () => {
+    const preflight = handlers.before_agent_start;
+    const sessionStart = handlers.session_start;
+    expect(sessionStart?.length).toBe(1);
+    expect(preflight?.length).toBe(1);
+
+    const state = readAdvisorState();
+    state.reviewControl = {
+      status: "running",
+      pending: true,
+      consumed: false,
+      running: true,
+      lastMaterialSignature: "stale",
+      lastTrigger: "turn-1",
+    };
+    writeFileSync(ADVISOR_STATE_PATH, JSON.stringify(state, null, 2), "utf8");
+
+    await sessionStart![0]({}, ctx);
+
+    const recovered = readAdvisorState();
+    expect(recovered.reviewControl.running).toBe(false);
+    expect(recovered.reviewControl.status).toBe("needed");
+    expect(recovered.reviewControl.pending).toBe(true);
+    expect(recovered.reviewControl.consumed).toBe(false);
+
+    const status = await preflight![0]({ systemPrompt: "SYS", prompt: "Continue the current goal" }, ctx);
+    expect(status?.systemPrompt).toContain("Review-control: needed");
+  });
+});

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

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { classifyIntent, classifyMode } from "./preflight-signals.js";
+
+describe("preflight signal classifiers", () => {
+  it("classifies planning prompts", () => {
+    expect(classifyIntent("what should we do next, design the architecture")).toBe("plan");
+  });
+
+  it("classifies implementation prompts", () => {
+    expect(classifyIntent("implement the auth flow and add tests")).toBe("implement");
+  });
+
+  it("classifies review prompts", () => {
+    expect(classifyIntent("please review this PR and check the diff")).toBe("review");
+  });
+
+  it("classifies questions vs commands", () => {
+    expect(classifyMode("what should we do next?")).toBe("question");
+    expect(classifyMode("run the tests and fix the bug")).toBe("command");
+    expect(classifyMode("hello there")).toBe("neutral");
+  });
+});

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

@@ -0,0 +1,21 @@
+/** Lightweight intent classifier for preflight signal enrichment */
+export function classifyIntent(text: string): string {
+  const t = ` ${String(text ?? "").toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ")} `;
+  if (/\b(plan|design|architecture|scope|next step|strategy|proposal|should we|what should|tradeoff|decision|path forward|how to approach)\b/.test(t)) return "plan";
+  if (/\b(debug|bug|error|fail|broken|crash|stack|traceback|investigate|why (is|was|does|did|are) )/.test(t)) return "debug";
+  if (/\b(review|check |verify|validate|look at|diff|pr |pull request|feedback)\b/i.test(t)) return "review";
+  if (/\b(research|compare|difference|which (one|model|lib|is better)|how does|documentation|read (about|the)|what is)\b/i.test(t)) return "research";
+  if (/\b(implement|build|write|create|add|make|refactor|rename|extract|migrate|fix|patch)\b/i.test(t)) return "implement";
+  if (/\b(install|config|setup|run|build|deploy|ssh|status|stats|logs?|theme|terminal|shell|brew|npm|git)\b/i.test(t)) return "ops";
+  if (/\b(continue|resume|compact|summarize|after compact|move on)\b/i.test(t)) return "handoff";
+  return "";
+}
+
+/** Classify prompt as question/command/neutral for signal enrichment */
+export function classifyMode(text: string): string {
+  const t = String(text ?? "").trim();
+  if (!t) return "";
+  if (/^(create|add|make|change|write|fix|update|remove|delete|run|install|set[\s-]?up|build|deploy|check|investigate|debug|review|test|refactor|merge|close|open|start|stop|restart|continue|show|list|compact|setup)\b/i.test(t)) return "command";
+  if (t.includes("?") || /^(what|why|how|when|where|who|which|is there|can we|should|does|did|are we|is it|do you|would you|could we)\b/i.test(t)) return "question";
+  return "neutral";
+}

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

@@ -0,0 +1,78 @@
+import { describe, expect, it } from "vitest";
+import { formatAdvisorDisplay, heuristicRoute, routeNote, shouldQueryClassifier, summarizeRoute, type AdvisorRouteInput } from "./router.js";
+
+describe("advisor router heuristics", () => {
+  it("keeps tiny edits in continue mode", () => {
+    const input: AdvisorRouteInput = { phase: "preflight", text: "fix a typo in README" };
+    const route = heuristicRoute(input);
+
+    expect(route.label).toBe("continue");
+    expect(route.preflight).toBe("off");
+    expect(route.review).toBe("off");
+    expect(route.escalate).toBe(false);
+    expect(route.safety).toBe(false);
+    expect(shouldQueryClassifier(route)).toBe(false);
+    expect(routeNote(route)).toMatch(/^\[advisor:rules: continue, reason: [a-z0-9 ,.'-]+\]$/);
+  });
+
+  it("escalates complex architecture work", () => {
+    const input: AdvisorRouteInput = { phase: "preflight", text: "need to refactor the architecture and tradeoffs" };
+    const route = heuristicRoute(input);
+
+    expect(route.label).toBe("escalate_to_advisor");
+    expect(route.preflight).toBe("full");
+    expect(route.review).toBe("light");
+    expect(route.escalate).toBe(true);
+    expect(summarizeRoute(route)).toContain("preflight:escalate_to_advisor");
+    expect(routeNote(route)).toMatch(/^\[advisor:rules: review, reason: [a-z0-9 ,.'-]+\]$/);
+  });
+
+  it("escalates strategy and decision prompts", () => {
+    const input: AdvisorRouteInput = { phase: "preflight", text: "does it make sense to buy 3x usage 2x higher sustained speed? what would you choose as a strategy" };
+    const route = heuristicRoute(input);
+
+    expect(route.label).toBe("escalate_to_advisor");
+    expect(route.escalate).toBe(true);
+    expect(routeNote(route)).toMatch(/^\[advisor:rules: review, reason: [a-z0-9 ,.'-]+\]$/);
+  });
+
+  it("flags safety-sensitive prompts", () => {
+    const input: AdvisorRouteInput = { phase: "preflight", text: "run rm -rf on prod" };
+    const route = heuristicRoute(input);
+
+    expect(route.safety).toBe(true);
+    expect(route.label).toBe("escalate_to_advisor");
+    expect(routeNote(route)).toMatch(/^\[advisor:rules: review, reason: [a-z0-9 ,.'-]+\]$/);
+  });
+
+  it("reviews incomplete work as not done", () => {
+    const input: AdvisorRouteInput = { phase: "review", text: "still incomplete, tests fail", failed: true };
+    const route = heuristicRoute(input);
+
+    expect(route.label).toBe("not_done");
+    expect(route.review).toBe("strict");
+    expect(route.escalate).toBe(true);
+    expect(routeNote(route)).toMatch(/^\[advisor:rules: review, reason: [a-z0-9 ,.'-]+\]$/);
+  });
+
+  it("abstains when review signal is weak", () => {
+    const input: AdvisorRouteInput = { phase: "review", text: "looks okay" };
+    const route = heuristicRoute(input);
+
+    expect(route.label).toBe("abstain");
+    expect(route.review).toBe("off");
+    expect(shouldQueryClassifier(route)).toBe(true);
+    expect(routeNote(route)).toMatch(/^\[advisor:rules: defer, reason: [a-z0-9 ,.'-]+\]$/);
+  });
+
+  it("tags model-routed notes explicitly", () => {
+    const input: AdvisorRouteInput = { phase: "preflight", text: "what would you choose as a strategy for this decision" };
+    const route = { ...heuristicRoute(input), source: "model" as const };
+
+    expect(routeNote(route)).toMatch(/^\[advisor:model: review, reason: [a-z0-9 ,.'-]+\]$/);
+  });
+
+  it("formats llm advisor messages with the llm tag", () => {
+    expect(formatAdvisorDisplay("advisor:llm", "review", "All set and reviewed")).toBe("[advisor:llm: review, reason: all set and reviewed]");
+  });
+});