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

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

@@ -0,0 +1,274 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { appendText, featureFile, readText, sessionFile, sessionKey, truncate } from "./internal.js";
+import { clearResearchState, hasActiveResearch } from "./autoresearch-state.js";
+import { setAdvisorCheckinsEnabled } from "./advisor-checkins.js";
+import { buildGoalCheckPrompt, beginGoalCheck, hasGoalCheckPending } from "./goal-resolution.js";
+import { readSessionJson, writeSessionJson } from "./state.js";
+import { loopArgumentCompletions } from "./completions.js";
+
+const FEATURE = "orchestration";
+const LOOP_FILE = "loop.json";
+const GOAL_FILE = "goal.md";
+const LOOP_HISTORY_FILE = featureFile(FEATURE, "loop-history.jsonl");
+const MIN_INTERVAL_MS = 60_000;
+const loopTimers = new Map<string, NodeJS.Timeout>();
+
+type LoopState = {
+  enabled: boolean;
+  interval: string;
+  instruction: string;
+  updatedAt: string;
+};
+
+function defaultLoopState(): LoopState {
+  return {
+    enabled: false,
+    interval: "",
+    instruction: "",
+    updatedAt: "",
+  };
+}
+
+function activeGoal(ctx: any): string {
+  return readText(sessionFile(FEATURE, ctx, GOAL_FILE)).trim();
+}
+
+export function readLoopState(ctx: any): LoopState {
+  return readSessionJson(FEATURE, ctx, LOOP_FILE, defaultLoopState());
+}
+
+function writeLoopState(ctx: any, state: LoopState): LoopState {
+  const next: LoopState = { ...state, updatedAt: new Date().toISOString() };
+  writeSessionJson(FEATURE, ctx, LOOP_FILE, next);
+  return next;
+}
+
+function clearLoopState(ctx: any): LoopState {
+  return writeLoopState(ctx, defaultLoopState());
+}
+
+function archiveLoopState(ctx: any, previous: LoopState): void {
+  if (!previous.enabled && !previous.instruction && !previous.interval) return;
+  appendText(LOOP_HISTORY_FILE, `${JSON.stringify({
+    at: new Date().toISOString(),
+    session: sessionKey(ctx),
+    previous,
+  })}\n`);
+}
+
+export function clearLoop(ctx: any, options: { clearResearch?: boolean; preserveCheckins?: boolean } = {}): LoopState {
+  const current = readLoopState(ctx);
+  archiveLoopState(ctx, current);
+  const next = clearLoopState(ctx);
+  stopLoopTimer(sessionKey(ctx));
+  setLoopStatus(ctx, next);
+  if (!options.preserveCheckins) {
+    setAdvisorCheckinsEnabled(false);
+  }
+  if (options.clearResearch) {
+    clearResearchState(ctx);
+  }
+  return next;
+}
+
+function parseIntervalMs(interval: string): number | null {
+  const raw = interval.trim().toLowerCase();
+  const match = raw.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
+  if (!match) return null;
+
+  const value = Number(match[1]);
+  if (!Number.isFinite(value) || value <= 0) return null;
+
+  const unit = match[2] ?? "s";
+  const multiplier = unit === "ms" ? 1 : unit === "s" ? 1000 : unit === "m" ? 60_000 : 3_600_000;
+  const ms = Math.round(value * multiplier);
+  return ms >= MIN_INTERVAL_MS ? ms : null;
+}
+
+function formatLoopState(state: LoopState): string {
+  if (!state.enabled) {
+    return "No active loop.";
+  }
+
+  const target = state.instruction ? ` — ${truncate(state.instruction, 160)}` : "";
+  return `↻ Loop active: every ${state.interval}${target}`;
+}
+
+function setLoopStatus(ctx: any, state: LoopState): void {
+  ctx.ui.setStatus(
+    "orchestration-loop",
+    state.enabled ? `↻ ${state.interval}${state.instruction ? ` · ${truncate(state.instruction, 40)}` : ""}` : undefined,
+  );
+}
+
+function stopLoopTimer(key: string): void {
+  const timer = loopTimers.get(key);
+  if (timer) {
+    clearInterval(timer);
+    loopTimers.delete(key);
+  }
+}
+
+let advisorLoopCheckinFn: ((pi: ExtensionAPI, ctx: any, source?: string) => Promise<boolean>) | null | undefined;
+
+async function runAdvisorCheckinTick(pi: ExtensionAPI, ctx: any): Promise<void> {
+  if (advisorLoopCheckinFn === undefined) {
+    try {
+      const advisor = await import("@fiale-plus/pi-rogue-advisor");
+      const candidate = (advisor as { requestAdvisorLoopCheckin?: (pi: ExtensionAPI, ctx: any, source?: string) => Promise<boolean> }).requestAdvisorLoopCheckin;
+      advisorLoopCheckinFn = typeof candidate === "function" ? candidate : null;
+    } catch {
+      advisorLoopCheckinFn = null;
+    }
+  }
+
+  if (!advisorLoopCheckinFn) return;
+  await advisorLoopCheckinFn(pi, ctx, "loop_tick");
+}
+
+function runLoopTick(pi: ExtensionAPI, ctx: any): boolean {
+  const key = sessionKey(ctx);
+  const current = readLoopState(ctx);
+  if (!current.enabled || !current.instruction) {
+    stopLoopTimer(key);
+    setLoopStatus(ctx, current);
+    return false;
+  }
+
+  const currentIntervalMs = parseIntervalMs(current.interval);
+  if (currentIntervalMs === null) {
+    stopLoopTimer(key);
+    setLoopStatus(ctx, current);
+    ctx.ui.notify("Loop interval must be at least 1m (e.g. 1m, 5m, 1h).", "warning");
+    return false;
+  }
+
+  const goal = activeGoal(ctx);
+  if (goal && hasGoalCheckPending(ctx)) {
+    void runAdvisorCheckinTick(pi, ctx);
+    return false;
+  }
+
+  const prompt = goal ? buildGoalCheckPrompt(goal, current.instruction) : current.instruction;
+  ctx.ui.notify(goal ? `🎯 Goal check: ${truncate(goal, 80)}` : `↻ Loop tick: ${truncate(current.instruction, 80)}`, "info");
+  if (goal) {
+    beginGoalCheck(ctx);
+  }
+
+  if (ctx.isIdle()) {
+    pi.sendUserMessage(prompt);
+  } else {
+    pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+  }
+
+  void runAdvisorCheckinTick(pi, ctx);
+  return true;
+}
+
+function syncLoopTimer(pi: ExtensionAPI, ctx: any): void {
+  const key = sessionKey(ctx);
+  stopLoopTimer(key);
+
+  const state = readLoopState(ctx);
+  setLoopStatus(ctx, state);
+  if (!state.enabled || !state.instruction) {
+    setAdvisorCheckinsEnabled(false);
+    return;
+  }
+
+  const intervalMs = parseIntervalMs(state.interval);
+  if (intervalMs === null) {
+    ctx.ui.notify("Loop interval must be at least 1m (e.g. 1m, 5m, 1h).", "warning");
+    setAdvisorCheckinsEnabled(false);
+    return;
+  }
+
+  setAdvisorCheckinsEnabled(true);
+  const tick = () => {
+    const currentIntervalMs = parseIntervalMs(readLoopState(ctx).interval);
+    if (currentIntervalMs === null || currentIntervalMs !== intervalMs) {
+      syncLoopTimer(pi, ctx);
+      return;
+    }
+
+    runLoopTick(pi, ctx);
+  };
+
+  loopTimers.set(key, setInterval(tick, intervalMs));
+}
+
+export function startLoop(pi: ExtensionAPI, ctx: any, interval: string, instruction: string, options: { triggerNow?: boolean } = {}): LoopState | null {
+  if (!interval || !instruction || parseIntervalMs(interval) === null) {
+    return null;
+  }
+
+  const next = writeLoopState(ctx, {
+    enabled: true,
+    interval,
+    instruction,
+    updatedAt: "",
+  });
+  setAdvisorCheckinsEnabled(true);
+  setLoopStatus(ctx, next);
+  syncLoopTimer(pi, ctx);
+  if (options.triggerNow) {
+    triggerLoopTick(pi, ctx);
+  }
+  return next;
+}
+
+export function triggerLoopTick(pi: ExtensionAPI, ctx: any): boolean {
+  return runLoopTick(pi, ctx);
+}
+
+export function registerLoop(pi: ExtensionAPI): void {
+  const p = pi as any;
+  if (p.__piRogueLoopRegistered) return;
+  p.__piRogueLoopRegistered = true;
+
+  pi.on("session_start", (_event, ctx) => {
+    syncLoopTimer(pi, ctx);
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => {
+    stopLoopTimer(sessionKey(ctx));
+    setLoopStatus(ctx, defaultLoopState());
+  });
+
+  pi.registerCommand("loop", {
+    description: "Record, show, or clear the current session loop cadence",
+    getArgumentCompletions: (prefix: string) => loopArgumentCompletions(prefix),
+    handler: async (args, ctx) => {
+      const input = String(args ?? "").trim();
+      const [cmd, ...rest] = input.split(/\s+/);
+      const resolved = !input ? "status" : ["status", "show", "off", "clear", "stop"].includes(cmd) ? cmd : "set";
+
+      if (resolved === "status" || resolved === "show") {
+        ctx.ui.notify(formatLoopState(readLoopState(ctx)), "info");
+        return;
+      }
+
+      if (resolved === "off" || resolved === "clear" || resolved === "stop") {
+        const clearedResearch = hasActiveResearch(ctx);
+        const next = clearLoop(ctx, { clearResearch: true });
+        ctx.ui.notify(next.enabled ? formatLoopState(next) : `Loop cleared${clearedResearch ? "; autoresearch status cleared" : ""}.`, "info");
+        return;
+      }
+
+      const interval = cmd;
+      const instruction = rest.join(" ").trim();
+      if (!interval || !instruction || parseIntervalMs(interval) === null) {
+        ctx.ui.notify("Usage: /loop <interval> <instruction> (e.g. 1m, 5m, 1h)", "error");
+        return;
+      }
+
+      clearLoop(ctx, { clearResearch: true });
+      const next = startLoop(pi, ctx, interval, instruction);
+      if (!next) {
+        ctx.ui.notify("Usage: /loop <interval> <instruction> (e.g. 1m, 5m, 1h)", "error");
+        return;
+      }
+      ctx.ui.notify(formatLoopState(next), "info");
+    },
+  });
+}

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

@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+import {
+  detectAssistantRepetition,
+  normalizeTurn,
+  recordAssistantTurn,
+  turnSimilarity,
+  type RepetitionGuardState,
+} from "./novelty-guard.js";
+
+describe("repetition guard", () => {
+  it("normalizes noisy assistant text", () => {
+    expect(normalizeTurn("Run `npm test` now. https://example.test")).toBe("run now url");
+  });
+
+  it("keeps similarity high for close paraphrases", () => {
+    const similarity = turnSimilarity(
+      "Inspect current state and apply the smallest missing delta before retrying.",
+      "Inspect the current state, then apply only the smallest missing change before retrying.",
+    );
+
+    expect(similarity).toBeGreaterThan(0.8);
+  });
+
+  it("detects repeated assistant output", () => {
+    const base: RepetitionGuardState = { recentAssistantTurns: [] };
+    const first = recordAssistantTurn(base, "Now let me build the session-flow analyzer and workflow clustering pipeline.");
+    const second = recordAssistantTurn(first, "Now let me build the session-flow analyzer and workflow clustering pipeline.");
+    const third = recordAssistantTurn(second, "Now let me build the session-flow analyzer and workflow clustering pipeline.");
+
+    const repeat = detectAssistantRepetition(third);
+
+    expect(repeat?.count).toBe(3);
+    expect(third.assistantRepeat?.text).toContain("session-flow analyzer");
+  });
+});

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

@@ -0,0 +1,145 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { contentText, readText, sessionFile, truncate, writeText } from "./internal.js";
+
+const FEATURE = "orchestration";
+const STATE_FILE = "repetition-guard.json";
+const MAX_ASSISTANT_TURNS = 6;
+const REPEAT_COUNT = 3;
+const REPEAT_THRESHOLD = 0.8;
+
+export interface RepetitionGuardTurn {
+  at: string;
+  text: string;
+}
+
+export interface RepetitionGuardRepeat {
+  at: string;
+  count: number;
+  text: string;
+}
+
+export interface RepetitionGuardState {
+  recentAssistantTurns: RepetitionGuardTurn[];
+  assistantRepeat?: RepetitionGuardRepeat;
+}
+
+export function defaultRepetitionGuardState(): RepetitionGuardState {
+  return { recentAssistantTurns: [] };
+}
+
+export function normalizeTurn(text: string): string {
+  return String(text ?? "")
+    .toLowerCase()
+    .replace(/`[^`]*`/g, " ")
+    .replace(/https?:\/\/\S+/g, " url ")
+    .replace(/[^a-z0-9\s']/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+export function turnSimilarity(a: string, b: string): number {
+  const left = new Set(normalizeTurn(a).split(" ").filter((token) => token.length > 2));
+  const right = new Set(normalizeTurn(b).split(" ").filter((token) => token.length > 2));
+  if (left.size === 0 || right.size === 0) return 0;
+
+  let overlap = 0;
+  for (const token of left) {
+    if (right.has(token)) overlap++;
+  }
+  return overlap / Math.min(left.size, right.size);
+}
+
+export function detectAssistantRepetition(state: RepetitionGuardState, minCount = REPEAT_COUNT): RepetitionGuardRepeat | null {
+  const recent = state.recentAssistantTurns.slice(-MAX_ASSISTANT_TURNS);
+  const last = recent.at(-1);
+  if (!last || normalizeTurn(last.text).length < 16) return null;
+
+  let count = 1;
+  for (let index = recent.length - 2; index >= 0; index--) {
+    const candidate = recent[index];
+    if (!candidate || normalizeTurn(candidate.text).length < 16) break;
+    if (normalizeTurn(candidate.text) !== normalizeTurn(last.text) && turnSimilarity(last.text, candidate.text) < REPEAT_THRESHOLD) break;
+    count++;
+  }
+
+  if (count < minCount) return null;
+  return {
+    at: new Date().toISOString(),
+    count,
+    text: truncate(last.text, 240),
+  };
+}
+
+export function recordAssistantTurn(state: RepetitionGuardState, text: string): RepetitionGuardState {
+  const trimmed = String(text ?? "").trim();
+  if (!trimmed) return state;
+  const next: RepetitionGuardState = {
+    ...state,
+    recentAssistantTurns: [...state.recentAssistantTurns, { at: new Date().toISOString(), text: truncate(trimmed, 1200) }].slice(-MAX_ASSISTANT_TURNS),
+  };
+  const repeat = detectAssistantRepetition(next);
+  return repeat ? { ...next, assistantRepeat: repeat } : { ...next, assistantRepeat: undefined };
+}
+
+function parseState(raw: string): RepetitionGuardState {
+  if (!raw.trim()) return defaultRepetitionGuardState();
+  try {
+    const parsed = JSON.parse(raw) as Partial<RepetitionGuardState>;
+    return {
+      recentAssistantTurns: Array.isArray(parsed.recentAssistantTurns)
+        ? parsed.recentAssistantTurns.filter((turn) => typeof turn?.text === "string").slice(-MAX_ASSISTANT_TURNS)
+        : [],
+      assistantRepeat: parsed.assistantRepeat && typeof parsed.assistantRepeat.text === "string"
+        ? {
+            at: String(parsed.assistantRepeat.at ?? new Date().toISOString()),
+            count: Number(parsed.assistantRepeat.count) || REPEAT_COUNT,
+            text: parsed.assistantRepeat.text,
+          }
+        : undefined,
+    };
+  } catch {
+    return defaultRepetitionGuardState();
+  }
+}
+
+function readGuardState(ctx: any): RepetitionGuardState {
+  return parseState(readText(sessionFile(FEATURE, ctx, STATE_FILE)));
+}
+
+function writeGuardState(ctx: any, state: RepetitionGuardState): void {
+  writeText(sessionFile(FEATURE, ctx, STATE_FILE), `${JSON.stringify(state, null, 2)}\n`);
+}
+
+export function registerNoveltyGuard(pi: ExtensionAPI): void {
+  const p = pi as any;
+  if (p.__piRogueNoveltyGuardRegistered) return;
+  p.__piRogueNoveltyGuardRegistered = true;
+
+  pi.on("before_agent_start", async (event, ctx) => {
+    const state = readGuardState(ctx);
+    const repeat = detectAssistantRepetition(state) ?? state.assistantRepeat;
+    if (!repeat) return { systemPrompt: event.systemPrompt };
+
+    return {
+      systemPrompt: [
+        event.systemPrompt,
+        "Pi-Rogue repetition guard:",
+        `The previous assistant output repeated ${repeat.count} times: ${truncate(repeat.text, 180)}`,
+        "Inspect current state before continuing, then apply only the smallest missing delta. Do not repeat the same response.",
+      ].join("\n\n"),
+    };
+  });
+
+  pi.on("message_end", async (event, ctx) => {
+    if (event?.message?.role !== "assistant") return;
+    const text = contentText(event.message.content);
+    if (!text) return;
+
+    const previous = readGuardState(ctx);
+    const next = recordAssistantTurn(previous, text);
+    writeGuardState(ctx, next);
+    if (next.assistantRepeat && (!previous.assistantRepeat || next.assistantRepeat.count > previous.assistantRepeat.count)) {
+      ctx.ui.notify("Repetition guard detected repeated assistant output; the next turn will inspect current state before retrying.", "warning");
+    }
+  });
+}

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

@@ -0,0 +1,24 @@
+import { readText, sessionFile, writeText } from "./internal.js";
+
+export function readSessionText(feature: string, ctx: any, file: string): string {
+  return readText(sessionFile(feature, ctx, file)).trim();
+}
+
+export function writeSessionText(feature: string, ctx: any, file: string, text: string): void {
+  writeText(sessionFile(feature, ctx, file), text ? `${text}\n` : "");
+}
+
+export function readSessionJson<T>(feature: string, ctx: any, file: string, fallback: T): T {
+  const raw = readSessionText(feature, ctx, file);
+  if (!raw) return fallback;
+
+  try {
+    return JSON.parse(raw) as T;
+  } catch {
+    return fallback;
+  }
+}
+
+export function writeSessionJson(feature: string, ctx: any, file: string, value: unknown): void {
+  writeText(sessionFile(feature, ctx, file), `${JSON.stringify(value, null, 2)}\n`);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fiale-plus/pi-rogue-bundle",
-  "version": "0.1.8",
-  "description": "Public Pi-Rogue bundle for advisor and orchestration.",
+  "version": "0.1.10",
+  "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",
   "repository": {
@@ -18,6 +18,10 @@
   "pi": {
     "extensions": [
       "./src/extension.ts"
+    ],
+    "skills": [
+      "./node_modules/@fiale-plus/pi-rogue-advisor/skills",
+      "./node_modules/@fiale-plus/pi-rogue-orchestration/skills"
     ]
   },
   "peerDependencies": {
@@ -27,6 +31,10 @@
     "@fiale-plus/pi-rogue-advisor": "^0.1.0",
     "@fiale-plus/pi-rogue-orchestration": "^0.1.0"
   },
+  "bundledDependencies": [
+    "@fiale-plus/pi-rogue-advisor",
+    "@fiale-plus/pi-rogue-orchestration"
+  ],
   "publishConfig": {
     "access": "public"
   }