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

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

@@ -0,0 +1,23 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerAutoresearch, registerAutoresearchLab } from "./autoresearch.js";
+import { registerGoal } from "./goal.js";
+import { registerLoop } from "./loop.js";
+import { registerNoveltyGuard } from "./novelty-guard.js";
+
+export function registerOrchestration(pi: ExtensionAPI): void {
+  const p = pi as any;
+  if (p.__piRogueOrchestrationRegistered) return;
+  p.__piRogueOrchestrationRegistered = true;
+
+  registerNoveltyGuard(pi);
+  registerGoal(pi);
+  registerLoop(pi);
+  registerAutoresearch(pi);
+  registerAutoresearchLab(pi);
+}
+
+export { registerAutoresearch, registerAutoresearchLab, registerGoal, registerLoop };
+
+export default function orchestrationExtension(pi: ExtensionAPI): void {
+  registerOrchestration(pi);
+}

package/node_modules/@fiale-plus/pi-rogue-orchestration/src/goal-resolution.ts

@@ -0,0 +1,36 @@
+import { sessionKey, truncate } from "./internal.js";
+
+const goalChecks = new Map<string, boolean>();
+
+export function hasGoalCheckPending(ctx: any): boolean {
+  return goalChecks.get(sessionKey(ctx)) === true;
+}
+
+export function beginGoalCheck(ctx: any): void {
+  goalChecks.set(sessionKey(ctx), true);
+}
+
+export function endGoalCheck(ctx: any): void {
+  goalChecks.delete(sessionKey(ctx));
+}
+
+export function buildGoalCheckPrompt(goal: string, instruction: string): string {
+  return [
+    "Goal check and work request:",
+    `Current goal: ${goal}`,
+    "Are we done? Ignore step/phase details; judge only whether the goal itself is complete.",
+    "If done, start your response with `GOAL_DONE: <short reason>` and summarize final state.",
+    "If not done, start your response with `GOAL_CONTINUE: <short reason>` and then continue working.",
+    "After `GOAL_CONTINUE`, immediately take the next concrete action toward the goal. Do not only record, restate, or summarize the goal.",
+    instruction ? `Current loop instruction: ${truncate(instruction, 400)}` : "",
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+export function goalCheckResult(text: string): "done" | "continue" | "unknown" {
+  const raw = text.trim();
+  if (/^GOAL_DONE\b/i.test(raw)) return "done";
+  if (/^GOAL_CONTINUE\b/i.test(raw)) return "continue";
+  return "unknown";
+}

package/node_modules/@fiale-plus/pi-rogue-orchestration/src/goal.test.ts

@@ -0,0 +1,182 @@
+import { randomUUID } from "node:crypto";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { resetAdvisorSessionContext, setAdvisorCheckinsEnabled } from "./advisor-checkins.js";
+import { endGoalCheck } from "./goal-resolution.js";
+import { activeGoal, clearGoal, registerGoal, setGoal, startGoalProcessing } from "./goal.js";
+import { featureFile, readText } from "./internal.js";
+
+vi.mock("./advisor-checkins.js", () => ({
+  resetAdvisorSessionContext: vi.fn(),
+  setAdvisorCheckinsEnabled: vi.fn(),
+}));
+
+const resetAdvisorSessionContextMock = vi.mocked(resetAdvisorSessionContext);
+const setAdvisorCheckinsEnabledMock = vi.mocked(setAdvisorCheckinsEnabled);
+
+function fakeCtx(id = randomUUID(), idle = true) {
+  return {
+    isIdle: () => idle,
+    sessionManager: {
+      getSessionFile: () => `/tmp/pi-rogue-goal-test-${id}.jsonl`,
+    },
+    ui: {
+      setStatus: () => undefined,
+      notify: () => undefined,
+    },
+  };
+}
+
+describe("goal processing", () => {
+  beforeEach(() => {
+    resetAdvisorSessionContextMock.mockClear();
+    setAdvisorCheckinsEnabledMock.mockClear();
+  });
+
+  function countGoalEntries(text: string, goal: string): number {
+    return text
+      .split("\n")
+      .filter((line) => line.includes(goal))
+      .length;
+  }
+
+  it("starts an immediate standalone goal check when no loop is active", () => {
+    const ctx = fakeCtx();
+    const sent: Array<{ text: string; options?: unknown }> = [];
+    const pi = {
+      sendUserMessage: (text: string, options?: unknown) => sent.push({ text, options }),
+    } as any;
+
+    expect(setGoal(ctx, "ship a small fix")).toBe("updated");
+    const result = startGoalProcessing(pi, ctx, "ship a small fix");
+
+    expect(result).toBe("standalone");
+    expect(sent).toHaveLength(1);
+    expect(sent[0].text).toContain("Goal check and work request:");
+    expect(sent[0].text).toContain("Current goal: ship a small fix");
+    expect(sent[0].text).toContain("Start processing the goal immediately.");
+    expect(sent[0].text).toContain("Take the first concrete step now");
+    expect(sent[0].text).toContain("Do not only record, restate, or summarize the goal.");
+    endGoalCheck(ctx);
+  });
+
+  it("does not append history or reset orchestration for an exact active goal duplicate", () => {
+    const ctx = fakeCtx();
+    const goal = `dedupe goal ${randomUUID()}`;
+    const before = readText(featureFile("orchestration", "goal-history.jsonl"));
+
+    expect(setGoal(ctx, goal)).toBe("updated");
+    setAdvisorCheckinsEnabledMock.mockClear();
+    const afterFirst = readText(featureFile("orchestration", "goal-history.jsonl"));
+    expect(setGoal(ctx, goal)).toBe("duplicate");
+    const afterSecond = readText(featureFile("orchestration", "goal-history.jsonl"));
+
+    expect(countGoalEntries(before, goal)).toBe(0);
+    expect(countGoalEntries(afterFirst, goal)).toBe(1);
+    expect(countGoalEntries(afterSecond, goal)).toBe(1);
+    expect(resetAdvisorSessionContextMock).toHaveBeenCalledTimes(1);
+    expect(setAdvisorCheckinsEnabledMock).toHaveBeenCalledWith(true);
+    clearGoal(ctx);
+  });
+
+  it("allows explicit goal changes without cycle heuristics", () => {
+    const ctx = fakeCtx();
+    const first = `cycle-a ${randomUUID()}`;
+    const second = `cycle-b ${randomUUID()}`;
+
+    expect(setGoal(ctx, first)).toBe("updated");
+    expect(setGoal(ctx, second)).toBe("updated");
+    expect(setGoal(ctx, first)).toBe("updated");
+    expect(setGoal(ctx, second)).toBe("updated");
+    expect(setGoal(ctx, first)).toBe("updated");
+    expect(setGoal(ctx, second)).toBe("updated");
+
+    clearGoal(ctx);
+    expect(setGoal(ctx, second)).toBe("updated");
+    clearGoal(ctx);
+  });
+
+  it("queues immediate standalone goal processing as follow-up when busy", () => {
+    const ctx = fakeCtx(undefined, false);
+    const sent: Array<{ text: string; options?: unknown }> = [];
+    const pi = {
+      sendUserMessage: (text: string, options?: unknown) => sent.push({ text, options }),
+    } as any;
+
+    setGoal(ctx, "finish benchmark report");
+    const result = startGoalProcessing(pi, ctx, "finish benchmark report");
+
+    expect(result).toBe("standalone");
+    expect(sent).toHaveLength(1);
+    expect(sent[0].options).toEqual({ deliverAs: "followUp" });
+    endGoalCheck(ctx);
+  });
+
+  it("resets advisor context when a goal is cleared", () => {
+    const ctx = fakeCtx();
+
+    clearGoal(ctx);
+
+    expect(resetAdvisorSessionContextMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("re-arms advisor check-ins when a session resumes with an active goal", () => {
+    const handlers: Record<string, Array<(event: any, ctx: any) => Promise<void> | void>> = {};
+    const pi = {
+      on: (name: string, handler: (event: any, ctx: any) => Promise<void> | void) => {
+        handlers[name] = [...(handlers[name] ?? []), handler];
+      },
+      registerCommand: () => undefined,
+      sendUserMessage: () => undefined,
+    } as any;
+    const ctx = fakeCtx();
+
+    registerGoal(pi);
+    setGoal(ctx, "resume heartbeat after compaction");
+    setAdvisorCheckinsEnabledMock.mockClear();
+
+    void handlers.session_start?.[0]?.({}, ctx);
+
+    expect(setAdvisorCheckinsEnabledMock).toHaveBeenCalledWith(true);
+  });
+
+  it("disables advisor check-ins when /goal clear stops the loop", async () => {
+    let handler: ((args: string, ctx: any) => Promise<void>) | undefined;
+    const pi = {
+      on: () => undefined,
+      registerCommand: (name: string, command: { handler: (args: string, ctx: any) => Promise<void> }) => {
+        if (name === "goal") handler = command.handler;
+      },
+      sendUserMessage: () => undefined,
+    } as any;
+    const ctx = fakeCtx();
+
+    registerGoal(pi);
+    setGoal(ctx, "clear lifecycle test");
+    setAdvisorCheckinsEnabledMock.mockClear();
+    await handler?.("clear", ctx);
+
+    expect(setAdvisorCheckinsEnabledMock).toHaveBeenCalledWith(false);
+  });
+
+  it("clears the active goal immediately when a pending check returns GOAL_DONE", async () => {
+    const handlers: Record<string, Array<(event: any, ctx: any) => Promise<void> | void>> = {};
+    const pi = {
+      on: (name: string, handler: (event: any, ctx: any) => Promise<void> | void) => {
+        handlers[name] = [...(handlers[name] ?? []), handler];
+      },
+      registerCommand: () => undefined,
+      sendUserMessage: () => undefined,
+    } as any;
+    const ctx = fakeCtx();
+
+    registerGoal(pi);
+    setGoal(ctx, "ship the thing");
+    startGoalProcessing(pi, ctx, "ship the thing");
+    await handlers.agent_end?.[0]?.({
+      messages: [{ role: "assistant", content: "GOAL_DONE: shipped with evidence" }],
+    }, ctx);
+
+    expect(activeGoal(ctx)).toBe("");
+  });
+
+});

package/node_modules/@fiale-plus/pi-rogue-orchestration/src/goal.ts

@@ -0,0 +1,232 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { appendText, contentText, featureFile, readText, sessionFile, truncate, writeText } from "./internal.js";
+import { clearResearchStateForGoal, readResearchState, writeResearchState, type ResearchState } from "./autoresearch-state.js";
+import { beginGoalCheck, buildGoalCheckPrompt, endGoalCheck, goalCheckResult, hasGoalCheckPending } from "./goal-resolution.js";
+import { clearLoop, triggerLoopTick } from "./loop.js";
+import { resetAdvisorSessionContext, setAdvisorCheckinsEnabled } from "./advisor-checkins.js";
+import { goalArgumentCompletions } from "./completions.js";
+
+const FEATURE = "orchestration";
+const CURRENT_FILE = "goal.md";
+const HISTORY_FILE = featureFile(FEATURE, "goal-history.jsonl");
+
+type GoalHistoryEntry = {
+  at: string;
+  goal: string;
+};
+
+export type GoalSetResult = "updated" | "duplicate";
+export type GoalProcessingStartResult = "loop" | "standalone" | "pending";
+
+export function activeGoal(ctx: any): string {
+  return readText(sessionFile(FEATURE, ctx, CURRENT_FILE)).trim();
+}
+
+function historyEntries(limit = 10): GoalHistoryEntry[] {
+  const raw = readText(HISTORY_FILE).trim();
+  if (!raw) return [];
+
+  return raw
+    .split("\n")
+    .filter(Boolean)
+    .slice(-limit)
+    .map((line) => {
+      try {
+        return JSON.parse(line) as GoalHistoryEntry;
+      } catch {
+        return { at: new Date().toISOString(), goal: line };
+      }
+    });
+}
+
+export function setGoal(ctx: any, goal: string, options: { restartDuplicate?: boolean } = {}): GoalSetResult {
+  const note = goal.trim();
+  const previous = activeGoal(ctx);
+  if (previous === note && !options.restartDuplicate) {
+    if (note) {
+      setAdvisorCheckinsEnabled(true);
+    }
+    return "duplicate";
+  }
+
+  if (previous && previous !== note) {
+    clearResearchStateForGoal(ctx, previous);
+  }
+  clearLoop(ctx, { clearResearch: true, preserveCheckins: true });
+  writeText(sessionFile(FEATURE, ctx, CURRENT_FILE), note ? `${note}\n` : "");
+  resetAdvisorSessionContext();
+  if (note) {
+    setAdvisorCheckinsEnabled(true);
+  }
+  endGoalCheck(ctx);
+
+  if (note) {
+    appendText(HISTORY_FILE, `${JSON.stringify({ at: new Date().toISOString(), goal: note })}\n`);
+  }
+  return "updated";
+}
+
+export function clearGoal(ctx: any): void {
+  writeText(sessionFile(FEATURE, ctx, CURRENT_FILE), "");
+  resetAdvisorSessionContext();
+}
+
+function goalBlock(goal: string): string {
+  return [
+    "## Pi-Rogue Goal",
+    `Current goal: ${goal}`,
+    "When a loop tick asks whether the goal is done, answer exactly with `GOAL_DONE: ...` or `GOAL_CONTINUE: ...`.",
+  ].join("\n");
+}
+
+export function setGoalStatus(ctx: any, goal: string | null): void {
+  ctx.ui.setStatus("orchestration-goal", goal ? `🎯 ${truncate(goal, 60)}` : undefined);
+}
+
+function assistantText(event: any): string {
+  const messages = Array.isArray(event?.messages) ? event.messages : [];
+  const lastAssistant = [...messages].reverse().find((m: any) => m?.role === "assistant");
+  return contentText(lastAssistant?.content);
+}
+
+function researchForGoal(ctx: any, goal: string): ResearchState | null {
+  const state = readResearchState(ctx);
+  if (!state.instruction || !state.goal || state.goal !== goal) return null;
+  return state;
+}
+
+function recordResearchResult(ctx: any, state: ResearchState, result: "done" | "continue" | "unknown"): void {
+  writeResearchState(ctx, {
+    ...state,
+    cycles: (state.cycles ?? 0) + 1,
+    lastResult: result,
+  });
+}
+
+export function startGoalProcessing(pi: ExtensionAPI, ctx: any, goal: string): GoalProcessingStartResult {
+  if (hasGoalCheckPending(ctx)) {
+    return "pending";
+  }
+
+  if (triggerLoopTick(pi, ctx)) {
+    return "loop";
+  }
+
+  beginGoalCheck(ctx);
+  const prompt = buildGoalCheckPrompt(
+    goal,
+    "Start processing the goal immediately. Take the first concrete step now: inspect, run, edit, or ask only if a specific blocker prevents action.",
+  );
+  if (ctx.isIdle?.() === false) {
+    pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+  } else {
+    pi.sendUserMessage(prompt);
+  }
+  return "standalone";
+}
+
+export function registerGoal(pi: ExtensionAPI): void {
+  const p = pi as any;
+  if (p.__piRogueGoalRegistered) return;
+  p.__piRogueGoalRegistered = true;
+
+  pi.on("session_start", (_event, ctx) => {
+    endGoalCheck(ctx);
+    const goal = activeGoal(ctx);
+    setGoalStatus(ctx, goal || null);
+    if (goal) {
+      setAdvisorCheckinsEnabled(true);
+    }
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => {
+    endGoalCheck(ctx);
+  });
+
+  pi.on("agent_end", async (event, ctx) => {
+    const goal = activeGoal(ctx);
+    if (!goal || !hasGoalCheckPending(ctx)) return;
+
+    const result = goalCheckResult(assistantText(event));
+    endGoalCheck(ctx);
+
+    const research = researchForGoal(ctx, goal);
+    if (research) recordResearchResult(ctx, research, result);
+
+    if (result === "done") {
+      clearGoal(ctx);
+      setGoalStatus(ctx, null);
+      clearLoop(ctx, { clearResearch: true });
+      ctx.ui.notify(`🎯 Goal completed: ${truncate(goal, 160)}`, "info");
+    }
+  });
+
+  pi.on("before_agent_start", async (event, ctx) => {
+    const goal = activeGoal(ctx);
+    setGoalStatus(ctx, goal || null);
+    if (!goal) return { systemPrompt: event.systemPrompt };
+
+    return { systemPrompt: `${event.systemPrompt}\n\n${goalBlock(goal)}` };
+  });
+
+  pi.registerCommand("goal", {
+    description: "Set, show, clear, or list the current session goal",
+    getArgumentCompletions: (prefix: string) => goalArgumentCompletions(prefix),
+    handler: async (args, ctx) => {
+      const input = String(args ?? "").trim();
+      const [cmd, ...rest] = input.split(/\s+/);
+      const known = new Set(["set", "show", "clear", "list"]);
+      const resolved = !input ? "show" : known.has(cmd) ? cmd : "set";
+      const text = resolved === "set" && known.has(cmd) ? rest.join(" ").trim() : input;
+
+      if (resolved === "show") {
+        const goal = activeGoal(ctx);
+        setGoalStatus(ctx, goal || null);
+        ctx.ui.notify(goal ? `🎯 ${truncate(goal, 160)}` : "No active goal.", "info");
+        return;
+      }
+
+      if (resolved === "clear") {
+        const goal = activeGoal(ctx);
+        const clearedResearch = goal ? clearResearchStateForGoal(ctx, goal) : false;
+        clearGoal(ctx);
+        endGoalCheck(ctx);
+        setGoalStatus(ctx, null);
+        clearLoop(ctx, { clearResearch: true });
+        ctx.ui.notify(goal ? `Goal cleared${clearedResearch ? "; matching autoresearch status cleared" : ""}.` : "No goal to clear.", "info");
+        return;
+      }
+
+      if (resolved === "list") {
+        const entries = historyEntries();
+        if (entries.length === 0) {
+          ctx.ui.notify("No goal history yet.", "info");
+          return;
+        }
+
+        ctx.ui.notify(
+          entries
+            .map((entry, index) => `${index + 1}. ${truncate(entry.goal, 120)} (${new Date(entry.at).toLocaleDateString()})`)
+            .join("\n"),
+          "info",
+        );
+        return;
+      }
+
+      if (!text) {
+        ctx.ui.notify("Usage: /goal set <text>", "error");
+        return;
+      }
+
+      const result = setGoal(ctx, text);
+      if (result === "duplicate") {
+        ctx.ui.notify(`🎯 Goal already active: ${truncate(text, 160)}.`, "info");
+        return;
+      }
+
+      setGoalStatus(ctx, text);
+      const started = startGoalProcessing(pi, ctx, text);
+      ctx.ui.notify(`🎯 Goal set: ${truncate(text, 160)}${started === "pending" ? " (goal processing already pending)" : " — processing started"}`, "info");
+    },
+  });
+}

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

@@ -0,0 +1 @@
+export { default, registerAutoresearch, registerGoal, registerLoop, registerOrchestration } from "./extension.js";

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

@@ -0,0 +1,98 @@
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+const ROOT_DIR = join(homedir(), ".pi", "agent", "fiale-plus");
+
+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 contentText(content: unknown): string {
+  if (typeof content === "string") return content.trim();
+  if (content && typeof content === "object" && !Array.isArray(content)) {
+    const block = content as Record<string, unknown>;
+    if (typeof block.text === "string") return block.text.trim();
+    if (block.content !== undefined) return contentText(block.content);
+    if (block.message !== undefined) return contentText(block.message);
+    return "";
+  }
+  if (!Array.isArray(content)) return String(content ?? "").trim();
+
+  const parts: string[] = [];
+  for (const item of content) {
+    if (!item) continue;
+    if (typeof item === "string") {
+      parts.push(item);
+      continue;
+    }
+
+    const block = item as Record<string, unknown>;
+    if (typeof block.text === "string") {
+      parts.push(block.text);
+    } else if (block.content !== undefined) {
+      const nested = contentText(block.content);
+      if (nested) parts.push(nested);
+    } else if (block.message !== undefined) {
+      const nested = contentText(block.message);
+      if (nested) parts.push(nested);
+    }
+  }
+
+  return parts.join("\n").replace(/\s+/g, " ").trim();
+}
+
+function ensureParent(filePath: string): string {
+  mkdirSync(dirname(filePath), { recursive: true });
+  return filePath;
+}
+
+export function readText(filePath: string, fallback = ""): string {
+  try {
+    return readFileSync(filePath, "utf8");
+  } catch {
+    return fallback;
+  }
+}
+
+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");
+}
+
+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 sessionKey(ctx: any): string {
+  const sessionFile = ctx?.sessionManager?.getSessionFile?.();
+  if (!sessionFile) return "session";
+  return basename(String(sessionFile)).replace(/\.[^.]+$/, "");
+}
+
+export function sessionDir(feature: string, ctx: any): string {
+  const dir = join(featureDir(feature), sessionKey(ctx));
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function featureFile(feature: string, filename: string): string {
+  return join(featureDir(feature), filename);
+}
+
+export function sessionFile(feature: string, ctx: any, filename: string): string {
+  return join(sessionDir(feature, ctx), filename);
+}