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

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

@@ -355,10 +355,11 @@ function recoverReviewControl(state: SessionState): void {
 }
 
 type AdvisorHintDetails = {
+  kind?: "handoff" | "answer";
   decision?: "continue" | "review" | "defer";
   reason?: string;
   summary?: string;
-  actions?: string[];
+  actions?: unknown;
 };
 
 type ReviewControlState = {
@@ -379,37 +380,77 @@ type ReviewMaterialMeta = {
   isAgentEnd: boolean;
   materialSignals?: string[];
 };
-function sendAdvisorHint(pi: ExtensionAPI, decision: "continue" | "review" | "defer", reason: string, summary: string, actions: string[] = []) {
+
+function normalizeAdvisorActions(actions: unknown): string[] {
+  const raw = Array.isArray(actions) ? actions : typeof actions === "string" ? [actions] : [];
+  return raw.map((action) => squish(action, 200)).filter(Boolean).slice(0, 2);
+}
+
+function advisorHandoffText(decision: "continue" | "review" | "defer", reason: string, summary: string, actions: unknown = []): string {
+  const limitedActions = normalizeAdvisorActions(actions);
+  return [
+    `Advisor verdict: ${decision}.`,
+    reason ? `Reason: ${reason}` : "",
+    summary ? `Summary: ${summary}` : "",
+    limitedActions.length ? `Actions: ${limitedActions.join("; ")}` : "",
+  ].filter(Boolean).join("\n");
+}
+
+function sendAdvisorHint(pi: ExtensionAPI, decision: "continue" | "review" | "defer", reason: string, summary: string, actions: unknown = []) {
+  const limitedActions = normalizeAdvisorActions(actions);
   pi.sendMessage(
     {
       customType: "advisor:llm",
-      content: reason,
+      content: advisorHandoffText(decision, reason, summary, limitedActions),
       display: true,
-      details: { decision, reason, summary, actions: actions.slice(0, 2) },
+      details: { decision, reason, summary, actions: limitedActions },
     },
     { deliverAs: "followUp" },
   );
 }
 
+function sendAdvisorAnswer(pi: ExtensionAPI, text: string) {
+  pi.sendMessage({
+    customType: "advisor:llm",
+    content: text,
+    display: true,
+    details: { kind: "answer", summary: text },
+  });
+}
+
 function renderAdvisorHint(message: any, options: { expanded?: boolean }, theme: any) {
   const details = (message?.details ?? {}) as AdvisorHintDetails;
   const customType = String(message?.customType ?? "advisor:rules");
-  const decision = details.decision ?? "defer";
   const sourceColor = customType === "advisor:llm" ? "success" : customType === "advisor:model" ? "accent" : "muted";
-  const decisionColor = decision === "review" ? "accent" : decision === "continue" ? "muted" : "dim";
   const source = theme.bold(theme.fg(sourceColor, `[${customType}]`));
+
+  if (details.kind === "answer") {
+    const body = contentText(message?.content) || details.summary || "No advisor response.";
+    const box = new Box(1, 1, (s: string) => theme.bg("customMessageBg", s));
+    box.addChild(new Text(`${theme.bold(theme.fg("success", "↗"))} ${source} ${theme.bold(theme.fg("success", "answer"))}`, 0, 0));
+    box.addChild(new Text(theme.fg("dim", body), 0, 0));
+    return box;
+  }
+
+  const decision = details.decision ?? "defer";
+  const decisionColor = decision === "review" ? "accent" : decision === "continue" ? "muted" : "dim";
   const verdict = theme.bold(theme.fg(decisionColor, decision));
   const glyph = decision === "review" ? "↗" : decision === "defer" ? "…" : "·";
   const reason = squish(details.reason || contentText(message?.content) || "no extra detail", 180);
+  const actions = normalizeAdvisorActions(details.actions);
 
   const box = new Box(1, 1, (s: string) => theme.bg("customMessageBg", s));
-  box.addChild(new Text(`${theme.bold(theme.fg(decisionColor, glyph))} ${source} ${verdict} · ${theme.fg("dim", "reason: ")}${reason}`, 0, 0));
+  box.addChild(new Text(`${theme.bold(theme.fg(decisionColor, glyph))} ${source} ${verdict}`, 0, 0));
+  box.addChild(new Text(theme.fg("dim", `reason: ${reason}`), 0, 0));
 
-  if (options.expanded && details.summary) {
+  if (details.summary) {
     box.addChild(new Text(theme.fg("dim", `summary: ${squish(details.summary, 220)}`), 0, 0));
   }
-  if (options.expanded && details.actions?.length) {
-    box.addChild(new Text(theme.fg("dim", `actions: ${details.actions.map((a) => squish(a, 80)).join(" • ")}`), 0, 0));
+  if (actions.length) {
+    box.addChild(new Text(theme.fg("dim", `actions: ${actions.map((a) => squish(a, 80)).join(" • ")}`), 0, 0));
+  }
+  if (!options.expanded && contentText(message?.content).split("\n").length > 3) {
+    box.addChild(new Text(theme.fg("dim", "Ctrl+O full advisor handoff"), 0, 0));
   }
 
   return box;
@@ -933,14 +974,15 @@ async function doReview(pi: ExtensionAPI, ctx: any, trigger: string, delta: stri
       : json.verdict === "not_done" ? "review"
         : "defer";
     finalDecision = decision;
-    finalReason = (json.reason || json.summary || "review result").slice(0, 120);
+    const rawReason = json.reason || json.summary || "review result";
+    finalReason = rawReason.slice(0, 120);
 
     const display = formatAdvisorDisplay("advisor:llm", decision, finalReason);
     writeText(CURRENT_PATH, `${display}\n`);
-    sendAdvisorHint(pi, decision, finalReason, json.summary || "", json.actions || []);
+    sendAdvisorHint(pi, decision, rawReason, json.summary || "", json.actions || []);
 
     if (json.verdict !== "on_track") {
-      state.followUp = [json.summary, ...(json.actions?.slice(0, 2) || [])].filter(Boolean).join(" — ");
+      state.followUp = [json.summary, ...normalizeAdvisorActions(json.actions)].filter(Boolean).join(" — ");
     }
 
     markReviewApplied(state, signature, trigger, finalDecision, finalReason, false);
@@ -1326,7 +1368,11 @@ export function registerAdvisor(pi: ExtensionAPI): void {
 
       // Anything else: treat as a question to the advisor
       const r = await askAdvisor(pi, ctx, a, "slash", true);
-      ctx.ui.notify(r.text, r.error ? "warning" : "info");
+      if (r.error) {
+        ctx.ui.notify(r.text, "warning");
+        return;
+      }
+      sendAdvisorAnswer(pi, r.text);
     },
   });
 }

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

@@ -17,9 +17,11 @@ vi.mock("@earendil-works/pi-ai", async () => {
 type Handler = (event: any, ctx: any) => any;
 
 type HandlerMap = Record<string, Handler[]>;
+type CommandMap = Record<string, { handler: (args: string, ctx: any) => any }>;
 
 function makeHandlers() {
   const handlers: HandlerMap = {};
+  const commands: CommandMap = {};
   const sendMessage = vi.fn();
 
   const pi = {
@@ -28,7 +30,9 @@ function makeHandlers() {
       handlers[event].push(handler);
     },
     registerMessageRenderer: () => undefined,
-    registerCommand: () => undefined,
+    registerCommand: (name: string, command: { handler: (args: string, ctx: any) => any }) => {
+      commands[name] = command;
+    },
     registerTool: vi.fn(),
     sendMessage,
     sendUserMessage: () => undefined,
@@ -38,12 +42,13 @@ function makeHandlers() {
     },
   };
 
-  return { handlers, pi: pi as any, sendMessage };
+  return { handlers, commands, 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");
+const ADVISOR_CACHE_PATH = join(ADVISOR_STATE_DIR, "cache.json");
 
 function readAdvisorState(): any {
   return JSON.parse(readFileSync(ADVISOR_STATE_PATH, "utf8"));
@@ -73,21 +78,26 @@ function mkCtx() {
 describe("advisor two-agent convergence", () => {
   let ctx: any;
   let handlers: HandlerMap;
+  let commands: CommandMap;
   let sendMessageMock: ReturnType<typeof vi.fn>;
   let completeSimpleMock: ReturnType<typeof vi.fn>;
   let priorState: string | null = null;
   let priorConfig: string | null = null;
+  let priorCache: 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;
+    priorCache = existsSync(ADVISOR_CACHE_PATH) ? readFileSync(ADVISOR_CACHE_PATH, "utf8") : null;
 
     const setup = makeHandlers();
     handlers = setup.handlers;
+    commands = setup.commands;
     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_CACHE_PATH, "{}", "utf8");
     writeFileSync(ADVISOR_STATE_PATH, JSON.stringify({
       turns: 0,
       lastTask: "",
@@ -136,6 +146,12 @@ describe("advisor two-agent convergence", () => {
     } else {
       writeFileSync(ADVISOR_CONFIG_PATH, priorConfig, "utf8");
     }
+
+    if (priorCache === null) {
+      writeFileSync(ADVISOR_CACHE_PATH, "{}", "utf8");
+    } else {
+      writeFileSync(ADVISOR_CACHE_PATH, priorCache, "utf8");
+    }
   });
 
   it("does not re-run advisory review on repeated material snapshots", async () => {
@@ -160,6 +176,17 @@ describe("advisor two-agent convergence", () => {
     const firstState = readAdvisorState();
     expect(firstState.reviewControl.lastDecision).toBe("review");
     expect(firstState.followUp).toContain("Closeout is incomplete");
+    expect(sendMessageMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        customType: "advisor:llm",
+        content: expect.stringContaining("Summary: Closeout is incomplete"),
+      }),
+      expect.anything(),
+    );
+    expect(sendMessageMock).toHaveBeenCalledWith(
+      expect.objectContaining({ content: expect.stringContaining("Actions: run focused check") }),
+      expect.anything(),
+    );
     expect(completeSimpleMock).toHaveBeenCalledTimes(1);
 
     const consumedPrompt = await preflight![0]({ systemPrompt: "SYS", prompt: basePrompt }, ctx);
@@ -183,6 +210,71 @@ describe("advisor two-agent convergence", () => {
     expect(String(withoutFollowUp?.systemPrompt)).not.toContain("Advisor follow-up");
   });
 
+  it("normalizes string actions in advisor handoffs", 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: "not_done",
+          summary: "Closeout is incomplete",
+          reason: "Verification is missing",
+          actions: "run focused check",
+          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: "Repo-side autoresearch is verified closed. Only optional external rollout/CI smoke remains." },
+    }, ctx);
+
+    const state = readAdvisorState();
+    expect(completeSimpleMock).toHaveBeenCalledTimes(1);
+    expect(state.followUp).toBe("Closeout is incomplete — run focused check");
+    expect(sendMessageMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        customType: "advisor:llm",
+        content: expect.stringContaining("Actions: run focused check"),
+        details: expect.objectContaining({ actions: ["run focused check"] }),
+      }),
+      expect.anything(),
+    );
+  });
+
+  it("renders manual advisor answers as advisor custom messages", async () => {
+    expect(commands.advisor).toBeTruthy();
+
+    completeSimpleMock.mockResolvedValue({
+      content: [{
+        type: "text",
+        text: "Post-turn review: no merge blockers identified from the session brief.",
+      }],
+    });
+
+    await commands.advisor.handler("should we merge this pr?", ctx);
+
+    expect(sendMessageMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        customType: "advisor:llm",
+        content: "Post-turn review: no merge blockers identified from the session brief.",
+        display: true,
+        details: expect.objectContaining({
+          kind: "answer",
+          summary: "Post-turn review: no merge blockers identified from the session brief.",
+        }),
+      }),
+    );
+  });
+
   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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fiale-plus/pi-rogue-bundle",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Public Pi-Rogue bundle for advisor and orchestration. Single consolidated artefact (advisor and orchestration releases paused; their packages are private and bundled here).",
   "type": "module",
   "license": "MIT",