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

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

@@ -6,6 +6,7 @@ import {
   completeWithModelFallback,
   contentText,
   normalizeAdvisorConfig,
+  sanitizeAdvisorText,
   shouldRunCheckin,
   type AdvisorConfig,
 } from "./extension.js";
@@ -86,6 +87,17 @@ describe("advisor message extraction", () => {
     expect(contentText([{ type: "toolResult", content: [{ type: "text", text: "ok" }] }])).toBe("ok");
     expect(contentText({ arbitrary: "shape" })).toBe("");
   });
+
+  it("redacts transient clipboard image paths from advisor-facing text", () => {
+    const text = "see /var/folders/fm/rwczdnws5j58x7kbyn3vcx_h0000gn/T/clipboard-2026-06-04-012248-DEE3A154.png please";
+    expect(sanitizeAdvisorText(text)).toBe("see [clipboard image] please");
+    expect(contentText({ content: [{ type: "text", text }] })).toBe("see [clipboard image] please");
+  });
+
+  it("does not redact ordinary repo or temp file paths", () => {
+    const text = "inspect /Users/pavel/repos/fiale-plus/pi-rogue/packages/advisor/src/extension.ts and /tmp/benchmark-results.json";
+    expect(sanitizeAdvisorText(text)).toBe(text);
+  });
 });
 
 describe("mid-hour check-ins", () => {

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

@@ -234,16 +234,22 @@ function hash(...parts: string[]): string {
 
 function brief(s: SessionState): string {
   const lines: string[] = [];
-  if (s.lastTask) lines.push(`Task: ${truncate(s.lastTask, 200)}`);
+  if (s.lastTask) lines.push(`Task: ${truncate(sanitizeAdvisorText(s.lastTask), 200)}`);
   if (s.turns) lines.push(`Turns: ${s.turns}`);
   if (s.notes.length) { lines.push("Notes:"); s.notes.slice(-4).forEach(n => lines.push(`- ${truncate(n, 200)}`)); }
-  if (s.files.length) lines.push(`Files: ${s.files.slice(-4).join(", ")}`);
-  if (s.errors.length) lines.push(`Errors: ${s.errors.slice(-2).join(" | ")}`);
+  if (s.files.length) lines.push(`Files: ${sanitizeAdvisorText(s.files.slice(-4).join(", "))}`);
+  if (s.errors.length) lines.push(`Errors: ${sanitizeAdvisorText(s.errors.slice(-2).join(" | "))}`);
   return lines.join("\n").slice(0, 1200);
 }
 
+const CLIPBOARD_IMAGE_PATH_RE = /(?:\/(?:private\/)?var\/folders\/[^\s"'`<>]+\/T|\/(?:tmp|var\/tmp))\/clipboard-\d{4}-\d{2}-\d{2}-[A-Za-z0-9-]+\.(?:png|jpe?g|gif|webp)\b/g;
+
+export function sanitizeAdvisorText(text: unknown): string {
+  return String(text ?? "").replace(CLIPBOARD_IMAGE_PATH_RE, "[clipboard image]");
+}
+
 function squish(t: unknown, max = 200): string {
-  const s = String(t ?? "").replace(/\s+/g, " ").trim();
+  const s = sanitizeAdvisorText(t).replace(/\s+/g, " ").trim();
   return s.length <= max ? s : s.slice(0, max - 1).trimEnd() + "…";
 }
 
@@ -355,10 +361,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 +386,117 @@ 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 comparableAdvisorText(text: string): string {
+  return sanitizeAdvisorText(text).toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+
+function isRedundantAdvisorSummary(reason: string, summary: string): boolean {
+  const r = comparableAdvisorText(reason);
+  const s = comparableAdvisorText(summary);
+  if (!s) return true;
+  if (!r) return false;
+  if (r === s) return true;
+  if (Math.min(r.length, s.length) >= 60 && (r.includes(s) || s.includes(r))) return true;
+
+  const rTokens = new Set(r.split(" ").filter((token) => token.length > 2));
+  const sTokens = new Set(s.split(" ").filter((token) => token.length > 2));
+  if (rTokens.size < 8 || sTokens.size < 8) return false;
+  const overlap = [...sTokens].filter((token) => rTokens.has(token)).length;
+  return overlap / Math.max(rTokens.size, sTokens.size) >= 0.86;
+}
+
+function distinctAdvisorSummary(reason: string, summary: string): string {
+  const cleanSummary = sanitizeAdvisorText(summary).trim();
+  return isRedundantAdvisorSummary(reason, cleanSummary) ? "" : cleanSummary;
+}
+
+function advisorHandoffText(decision: "continue" | "review" | "defer", reason: string, summary: string, actions: unknown = []): string {
+  const limitedActions = normalizeAdvisorActions(actions);
+  const cleanReason = sanitizeAdvisorText(reason);
+  const cleanSummary = distinctAdvisorSummary(cleanReason, summary);
+  return [
+    `Advisor verdict: ${decision}.`,
+    cleanReason ? `Reason: ${cleanReason}` : "",
+    cleanSummary ? `Summary: ${cleanSummary}` : "",
+    limitedActions.length ? `Actions: ${limitedActions.join("; ")}` : "",
+  ].filter(Boolean).join("\n");
+}
+
+function sendAdvisorHint(pi: ExtensionAPI, decision: "continue" | "review" | "defer", reason: string, summary: string, actions: unknown = []) {
+  const cleanReason = sanitizeAdvisorText(reason);
+  const cleanSummary = distinctAdvisorSummary(cleanReason, summary);
+  const limitedActions = normalizeAdvisorActions(actions);
   pi.sendMessage(
     {
       customType: "advisor:llm",
-      content: reason,
+      content: advisorHandoffText(decision, cleanReason, cleanSummary, limitedActions),
       display: true,
-      details: { decision, reason, summary, actions: actions.slice(0, 2) },
+      details: { kind: "handoff", decision, reason: cleanReason, summary: cleanSummary, actions: limitedActions },
     },
     { deliverAs: "followUp" },
   );
 }
 
+function sendAdvisorAnswer(pi: ExtensionAPI, text: string) {
+  const cleanText = sanitizeAdvisorText(text);
+  pi.sendMessage({
+    customType: "advisor:llm",
+    content: cleanText,
+    display: true,
+    details: { kind: "answer", summary: cleanText },
+  });
+}
+
 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 = sanitizeAdvisorText(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 fullHandoff = sanitizeAdvisorText(
+    (details.reason || details.summary || actions.length)
+      ? advisorHandoffText(decision, details.reason || "", details.summary || "", actions)
+      : contentText(message?.content),
+  );
 
   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));
-
-  if (options.expanded && 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));
+  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) {
+    box.addChild(new Text(theme.fg("dim", "full handoff:"), 0, 0));
+    box.addChild(new Text(theme.fg("dim", fullHandoff), 0, 0));
+  } else {
+    const summary = distinctAdvisorSummary(details.reason || "", details.summary || "");
+    if (summary) {
+      box.addChild(new Text(theme.fg("dim", `summary: ${squish(summary, 220)}`), 0, 0));
+    }
+    if (actions.length) {
+      box.addChild(new Text(theme.fg("dim", `actions: ${actions.map((a) => squish(a, 80)).join(" • ")}`), 0, 0));
+    }
+    if (fullHandoff.split("\n").length > 3) {
+      box.addChild(new Text(theme.fg("dim", "Ctrl+O full advisor handoff"), 0, 0));
+    }
   }
 
   return box;
@@ -417,15 +504,15 @@ function renderAdvisorHint(message: any, options: { expanded?: boolean }, theme:
 
 /** Extract readable text from message content (handles strings, blocks, and nested message payloads). */
 export function contentText(content: unknown): string {
-  if (typeof content === "string") return content.trim();
+  if (typeof content === "string") return sanitizeAdvisorText(content).trim();
   if (content && typeof content === "object" && !Array.isArray(content)) {
     const obj = content as Record<string, unknown>;
-    if (typeof obj.text === "string") return obj.text.trim();
+    if (typeof obj.text === "string") return sanitizeAdvisorText(obj.text).trim();
     if (obj.content !== undefined) return contentText(obj.content);
     if (obj.message !== undefined) return contentText(obj.message);
     return "";
   }
-  if (!Array.isArray(content)) return String(content ?? "").trim();
+  if (!Array.isArray(content)) return sanitizeAdvisorText(content).trim();
   const parts: string[] = [];
   for (const item of content) {
     if (!item) continue;
@@ -442,7 +529,7 @@ export function contentText(content: unknown): string {
       if (nested) parts.push(nested);
     }
   }
-  return parts.join("\n").replace(/\s+/g, " ").trim();
+  return sanitizeAdvisorText(parts.join("\n")).replace(/\s+/g, " ").trim();
 }
 
 /** Check if a tool result or message indicates an actual execution failure */
@@ -933,14 +1020,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 = sanitizeAdvisorText(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 = [sanitizeAdvisorText(json.summary), ...normalizeAdvisorActions(json.actions)].filter(Boolean).join(" — ");
     }
 
     markReviewApplied(state, signature, trigger, finalDecision, finalReason, false);
@@ -1326,7 +1414,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,13 @@ 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 }>;
+type MessageRendererMap = Record<string, (message: any, options: { expanded?: boolean }, theme: any) => any>;
 
 function makeHandlers() {
   const handlers: HandlerMap = {};
+  const commands: CommandMap = {};
+  const messageRenderers: MessageRendererMap = {};
   const sendMessage = vi.fn();
 
   const pi = {
@@ -27,8 +31,12 @@ function makeHandlers() {
       handlers[event] ??= [];
       handlers[event].push(handler);
     },
-    registerMessageRenderer: () => undefined,
-    registerCommand: () => undefined,
+    registerMessageRenderer: (customType: string, renderer: MessageRendererMap[string]) => {
+      messageRenderers[customType] = renderer;
+    },
+    registerCommand: (name: string, command: { handler: (args: string, ctx: any) => any }) => {
+      commands[name] = command;
+    },
     registerTool: vi.fn(),
     sendMessage,
     sendUserMessage: () => undefined,
@@ -38,12 +46,13 @@ function makeHandlers() {
     },
   };
 
-  return { handlers, pi: pi as any, sendMessage };
+  return { handlers, commands, messageRenderers, 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 +82,28 @@ function mkCtx() {
 describe("advisor two-agent convergence", () => {
   let ctx: any;
   let handlers: HandlerMap;
+  let commands: CommandMap;
+  let messageRenderers: MessageRendererMap;
   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;
+    messageRenderers = setup.messageRenderers;
     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 +152,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 +182,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 +216,157 @@ 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("redacts transient clipboard image paths from emitted advisor handoffs", async () => {
+    const preflight = handlers.before_agent_start;
+    const turnEnd = handlers.turn_end;
+    const clipboardPath = "/var/folders/fm/rwczdnws5j58x7kbyn3vcx_h0000gn/T/clipboard-2026-06-04-012248-DEE3A154.png";
+
+    completeSimpleMock.mockResolvedValue({
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          verdict: "not_done",
+          summary: `The visible handoff should not include ${clipboardPath}`,
+          reason: `Expanded Ctrl+O output leaks ${clipboardPath}`,
+          actions: [`redact ${clipboardPath}`],
+          checklist: [],
+          notify: true,
+        }),
+      }],
+    });
+
+    await handlers.session_start?.[0]?.({}, ctx);
+    await preflight![0]({ systemPrompt: "SYS", prompt: `Continue the current goal ${clipboardPath}` }, 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);
+
+    expect(sendMessageMock).toHaveBeenCalled();
+    const sent = sendMessageMock.mock.calls[0]?.[0];
+    expect(JSON.stringify(sent)).not.toContain(clipboardPath);
+    expect(sent.content).toContain("[clipboard image]");
+    expect(readAdvisorState().followUp).toContain("[clipboard image]");
+
+    const theme = {
+      fg: (_name: string, text: string) => text,
+      bg: (_name: string, text: string) => text,
+      bold: (text: string) => text,
+    };
+    const expanded = messageRenderers["advisor:llm"](sent, { expanded: true }, theme).render(120).join("\n");
+    expect(expanded).toContain("full handoff:");
+    expect(expanded).toContain("Advisor verdict: review.");
+    expect(expanded).toContain("[clipboard image]");
+    expect(expanded).not.toContain(clipboardPath);
+  });
+
+  it("suppresses duplicate reason and summary in advisor handoffs", async () => {
+    const preflight = handlers.before_agent_start;
+    const turnEnd = handlers.turn_end;
+    const duplicate = "The agent made a safe attempt, but it did not demonstrate that the advisor post-turn review was induced.";
+
+    completeSimpleMock.mockResolvedValue({
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          verdict: "not_done",
+          reason: duplicate,
+          summary: duplicate,
+          actions: ["Invoke the real review hook if available."],
+          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 sent = sendMessageMock.mock.calls[0]?.[0];
+    expect(sent.content).toContain(`Reason: ${duplicate}`);
+    expect(sent.content).not.toContain("Summary:");
+    expect(sent.details.summary).toBe("");
+
+    const theme = {
+      fg: (_name: string, text: string) => text,
+      bg: (_name: string, text: string) => text,
+      bold: (text: string) => text,
+    };
+    const collapsed = messageRenderers["advisor:llm"](sent, { expanded: false }, theme).render(120).join("\n");
+    const expanded = messageRenderers["advisor:llm"](sent, { expanded: true }, theme).render(120).join("\n");
+    expect(collapsed).not.toContain("summary:");
+    expect(expanded).not.toContain("Summary:");
+  });
+
+  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.12",
   "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",