@fiale-plus/pi-rogue 0.2.2 → 0.2.4

package/node_modules/@fiale-plus/pi-rogue-context-broker/src/sqlite.test.ts

@@ -40,6 +40,43 @@ describe("createSqliteContextBroker", () => {
     }
   });
 
+  it("persists age-based tier cooling without deleting artifacts", () => {
+    const dir = mkdtempSync(join(tmpdir(), "ctx-sqlite-test-"));
+    try {
+      const path = join(dir, "artifacts.sqlite");
+      let broker = createSqliteContextBroker({ path, defaultTtlMs: 0, hotToWarmMs: 100, warmToColdMs: 200, briefBytes: 900 });
+      const now = Date.now();
+      const oldHot = broker.publish({ sessionId: "s", kind: "tool_output", payload: "old hot", summary: "old hot", tier: "hot", createdAt: now - 300 });
+      const pinned = broker.publish({ sessionId: "s", kind: "tool_output", payload: "pinned", summary: "pinned", tier: "hot", pinned: true, createdAt: now - 300 });
+
+      broker.prune(now);
+      broker = createSqliteContextBroker({ path, defaultTtlMs: 0, hotToWarmMs: 100, warmToColdMs: 200, briefBytes: 900 });
+
+      expect(broker.lookup({ handle: oldHot.handle })[0]?.tier).toBe("cold");
+      expect(broker.lookup({ handle: pinned.handle })[0]?.tier).toBe("hot");
+      expect(broker.renderBrief({ sessionId: "s" })).not.toContain(oldHot.handle);
+      expect(broker.renderBrief({ sessionId: "s" })).toContain(pinned.handle);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("cools protected new artifacts before enforcing durable tier caps", () => {
+    const dir = mkdtempSync(join(tmpdir(), "ctx-sqlite-test-"));
+    try {
+      const now = Date.now();
+      const broker = createSqliteContextBroker({ path: join(dir, "artifacts.sqlite"), defaultTtlMs: 0, maxRecords: 10, hotMaxRecords: 1, hotToWarmMs: 10_000, warmToColdMs: 20_000 });
+      const fresh = broker.publish({ sessionId: "s", kind: "tool_output", payload: "fresh", summary: "fresh", tier: "hot", createdAt: now - 1_000 });
+      const aged = broker.publish({ sessionId: "s", kind: "tool_output", payload: "aged", summary: "aged", tier: "hot", createdAt: now - 30_000 });
+
+      expect(aged.tier).toBe("cold");
+      expect(broker.lookup({ handle: fresh.handle })[0]?.tier).toBe("hot");
+      expect(broker.lookup({ handle: aged.handle })[0]?.tier).toBe("cold");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   it("dedupes replayed source artifacts so durable handles survive caps", () => {
     const dir = mkdtempSync(join(tmpdir(), "ctx-sqlite-test-"));
     try {

package/node_modules/@fiale-plus/pi-rogue-context-broker/src/sqlite.ts

@@ -29,6 +29,10 @@ const DEFAULT_BRIEF_BYTES = 2_000;
 const TIER_ORDER: Record<ContextArtifactTier, number> = { hot: 0, warm: 1, cold: 2 };
 const TIER_REMOVAL_ORDER: Record<ContextArtifactTier, number> = { cold: 0, warm: 1, hot: 2 };
 
+function optionMs(value: number | undefined): number {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : Number.POSITIVE_INFINITY;
+}
+
 function defaultStoreDir(): string {
   return join(homedir(), ".pi", "agent", "fiale-plus", "context-broker");
 }
@@ -226,6 +230,8 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
     warm: Math.max(1, Math.floor(options.warmMaxBytes ?? maxBytes)),
     cold: Math.max(1, Math.floor(options.coldMaxBytes ?? maxBytes)),
   };
+  const hotToWarmMs = optionMs(options.hotToWarmMs);
+  const warmToColdMs = optionMs(options.warmToColdMs);
   const summaryBytes = Math.max(16, Math.floor(options.summaryBytes ?? DEFAULT_SUMMARY_BYTES));
   const defaultBriefBytes = Math.max(64, Math.floor(options.briefBytes ?? DEFAULT_BRIEF_BYTES));
 
@@ -241,6 +247,31 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
     db.prepare("DELETE FROM artifacts WHERE id = ?").run(id);
   }
 
+  function cooledTier(artifact: ContextArtifact & { baseTier: ContextArtifactTier }, now = Date.now()): ContextArtifactTier {
+    if (artifact.pinned) return "hot";
+    if (artifact.baseTier === "cold") return "cold";
+    const age = Math.max(0, now - artifact.createdAt);
+    if (age >= warmToColdMs) return "cold";
+    if (artifact.baseTier === "hot" && age >= hotToWarmMs) return "warm";
+    return artifact.baseTier;
+  }
+
+  function applyCooling(now = Date.now(), _protectedIds = new Set<string>()): void {
+    const rows = db.prepare("SELECT id, createdAt, tier, baseTier, pinned FROM artifacts WHERE pinned = 0").all();
+    const update = db.prepare("UPDATE artifacts SET tier = ?, updatedAt = ? WHERE id = ?");
+    for (const row of rows) {
+      const artifact = {
+        id: String(row.id),
+        createdAt: Number(row.createdAt),
+        tier: String(row.tier) as ContextArtifactTier,
+        baseTier: String(row.baseTier ?? row.tier) as ContextArtifactTier,
+        pinned: Boolean(row.pinned),
+      };
+      const nextTier = cooledTier(artifact as ContextArtifact & { baseTier: ContextArtifactTier }, now);
+      if (artifact.tier !== nextTier) update.run(nextTier, now, artifact.id);
+    }
+  }
+
   function currentStatus(): ContextBrokerStatus {
     const row = db.prepare(`
       SELECT
@@ -269,6 +300,8 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
       coldBytes: Number(row.coldBytes ?? 0),
       maxRecords,
       maxBytes,
+      globalMaxRecords,
+      globalMaxBytes,
     };
   }
 
@@ -329,6 +362,7 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
 
   function prune(now = Date.now(), protectedIds = new Set<string>()): ContextBrokerStatus {
     dropExpired(now, protectedIds);
+    applyCooling(now, protectedIds);
     const sessions = db.prepare("SELECT DISTINCT sessionId FROM artifacts").all().map((row) => String(row.sessionId));
     for (const sessionId of sessions) {
       for (const tier of ["cold", "warm", "hot"] as ContextArtifactTier[]) {
@@ -356,11 +390,13 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
 
   function status(): ContextBrokerStatus {
     dropExpired();
+    applyCooling();
     return currentStatus();
   }
 
   function purge(options: ContextPurgeOptions = {}): ContextBrokerStatus {
     dropExpired();
+    applyCooling();
     const keepPinned = options.keepPinned ?? true;
     const clauses: string[] = [];
     const params: Array<string | number> = [];
@@ -468,12 +504,13 @@ export function createSqliteContextBroker(options: SqliteContextBrokerOptions =
       throw error;
     }
 
-    prune(now, new Set([artifact.id]));
-    return artifact;
+    prune(Date.now(), new Set([artifact.id]));
+    return lookup({ id: artifact.id })[0] ?? artifact;
   }
 
   function lookup(query: ContextLookupQuery = {}): ContextArtifact[] {
     dropExpired();
+    applyCooling();
     const storedCount = Number(db.prepare("SELECT COUNT(*) AS count FROM artifacts").get()?.count ?? 1) || 1;
     const limit = Math.max(1, Math.floor(query.limit ?? storedCount));
     const clauses: string[] = [];

package/node_modules/@fiale-plus/pi-rogue-orchestration/README.md

@@ -47,10 +47,10 @@ npm install --workspace packages/orchestration
 ## Behavior notes
 
 - `loop` supports minimum interval `1m`.
-- `goal` checks are done through assistant loop ticks; `GOAL_DONE` / `GOAL_CONTINUE` are preserved.
+- Active goals can be completed with the model-callable `goal_complete` tool, which requires a summary and verification evidence; `GOAL_DONE` / `GOAL_CONTINUE` sentinel loop checks are preserved for compatibility.
 - `autoresearch` and `autoresearch-lab` are thin facades over `/goal + /loop`.
 - A goal or loop activation enables scheduled advisor check-ins; stopping or clearing the active goal/loop disables them again.
 - Check-ins are part of orchestration lifecycle, not a standalone advisor command. They use the advisor interval, higher/advanced advisor models first, and regular model fallback by default.
-- A small repetition guard detects repeated assistant output and nudges the next turn to inspect current state before retrying.
-- There are no hidden flow budgets. Long loops run until `/loop off`, `/goal clear`, or a `GOAL_DONE` response clears the active goal and loop.
+- A bounded no-progress guard detects repeated assistant output or repeated planning-only turns during active orchestration, then nudges one concrete alternative action and eventually stops retry churn instead of stacking recovery prompts.
+- There are no hidden flow budgets. Long loops run until `/loop off`, `/goal clear`, `goal_complete`, or a `GOAL_DONE` response clears the active goal and loop.
 - Stale research state is cleared when `goal` or `loop` are cleared.

package/node_modules/@fiale-plus/pi-rogue-orchestration/package.json

@@ -31,6 +31,9 @@
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.74.0"
   },
+  "dependencies": {
+    "typebox": "^1.1.24"
+  },
   "publishConfig": {
     "access": "public"
   },

package/node_modules/@fiale-plus/pi-rogue-orchestration/skills/orchestration/SKILL.md

@@ -28,12 +28,13 @@ Use this skill to run measurable, bounded workflow loops inside a Pi session.
 ## Behavior rules
 
 - `loop` is the primitive; `goal` is the execution intent.
-- Goal completion is explicit through `GOAL_DONE` / `GOAL_CONTINUE` in loop checks.
+- Goal completion should use the `goal_complete` tool when available, with a summary and verification evidence; `GOAL_DONE` / `GOAL_CONTINUE` remain valid loop-check sentinels for compatibility.
 - `autoresearch` / `autoresearch-lab` are facades over goal+loop.
 - Goal or loop activation enables scheduled advisor check-ins; stopping or clearing either disables them.
 - Check-ins belong to orchestration lifecycle, not the advisor command surface, and use higher/advanced advisor models first, with regular model fallback enabled by default.
 - `autoresearch` enforces multi-cycle + evidence-aware completion.
-- Clearing goal/loop clears stale autoresearch state.
+- Clearing goal/loop or completing a goal clears stale autoresearch state.
+- Bounded no-progress recovery may steer one concrete alternative action after repeated self-talk/repetition, then stops retry churn instead of stacking prompts.
 
 ## Safety and agentic flow
 

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

@@ -2,8 +2,8 @@ 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";
+import { activeGoal, clearGoal, completeActiveGoal, registerGoal, setGoal, startGoalProcessing } from "./goal.js";
+import { featureFile, readText, sessionFile, writeText } from "./internal.js";
 
 vi.mock("./advisor-checkins.js", () => ({
   resetAdvisorSessionContext: vi.fn(),
@@ -111,6 +111,20 @@ describe("goal processing", () => {
     endGoalCheck(ctx);
   });
 
+  it("clears stale no-progress recovery state when goal lifecycle changes", () => {
+    const ctx = fakeCtx();
+    const guardFile = sessionFile("orchestration", ctx, "repetition-guard.json");
+    writeText(guardFile, `${JSON.stringify({
+      recentAssistantTurns: [],
+      noProgress: { at: new Date().toISOString(), count: 3, text: "I will plan next.", reason: "test" },
+    })}\n`);
+
+    setGoal(ctx, "fresh goal after stale recovery");
+
+    expect(JSON.parse(readText(guardFile)).noProgress).toBeUndefined();
+    clearGoal(ctx);
+  });
+
   it("resets advisor context when a goal is cleared", () => {
     const ctx = fakeCtx();
 
@@ -158,6 +172,55 @@ describe("goal processing", () => {
     expect(setAdvisorCheckinsEnabledMock).toHaveBeenCalledWith(false);
   });
 
+  it("completes an active goal through the explicit completion signal", () => {
+    const ctx = fakeCtx();
+    const goal = `complete with tool ${randomUUID()}`;
+
+    setGoal(ctx, goal);
+    const result = completeActiveGoal(ctx, {
+      summary: "Implemented the requested behavior.",
+      verification: "Ran focused unit tests.",
+      source: "tool",
+    });
+
+    expect(result.completed).toBe(true);
+    expect(activeGoal(ctx)).toBe("");
+    expect(readText(featureFile("orchestration", "goal-completions.jsonl"))).toContain(goal);
+  });
+
+  it("rejects explicit goal completion without verification", () => {
+    const ctx = fakeCtx();
+    setGoal(ctx, "needs verification");
+
+    const result = completeActiveGoal(ctx, { summary: "Done", verification: "" });
+
+    expect(result.completed).toBe(false);
+    expect(activeGoal(ctx)).toBe("needs verification");
+    clearGoal(ctx);
+  });
+
+  it("registers a goal completion tool", async () => {
+    let tool: any;
+    const pi = {
+      on: () => undefined,
+      registerCommand: () => undefined,
+      registerTool: (definition: any) => { tool = definition; },
+      sendUserMessage: () => undefined,
+    } as any;
+    const ctx = fakeCtx();
+
+    registerGoal(pi);
+    setGoal(ctx, "finish explicit tool path");
+    const response = await tool.execute("call", {
+      summary: "Finished explicit path.",
+      verification: "Verified with a fake focused check.",
+    }, undefined, undefined, ctx);
+
+    expect(tool.name).toBe("goal_complete");
+    expect(response.details.completed).toBe(true);
+    expect(activeGoal(ctx)).toBe("");
+  });
+
   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 = {

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

@@ -1,20 +1,35 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
 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 { clearNoProgressRecovery } from "./novelty-guard.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");
+const COMPLETION_HISTORY_FILE = featureFile(FEATURE, "goal-completions.jsonl");
 
 type GoalHistoryEntry = {
   at: string;
   goal: string;
 };
 
+export type GoalCompletionInput = {
+  summary: string;
+  verification: string;
+  source?: "tool" | "sentinel";
+};
+
+export type GoalCompletionResult = {
+  completed: boolean;
+  goal?: string;
+  reason?: string;
+};
+
 export type GoalSetResult = "updated" | "duplicate";
 export type GoalProcessingStartResult = "loop" | "standalone" | "pending";
 
@@ -53,6 +68,7 @@ export function setGoal(ctx: any, goal: string, options: { restartDuplicate?: bo
     clearResearchStateForGoal(ctx, previous);
   }
   clearLoop(ctx, { clearResearch: true, preserveCheckins: true });
+  clearNoProgressRecovery(ctx);
   writeText(sessionFile(FEATURE, ctx, CURRENT_FILE), note ? `${note}\n` : "");
   resetAdvisorSessionContext(ctx);
   if (note) {
@@ -68,14 +84,47 @@ export function setGoal(ctx: any, goal: string, options: { restartDuplicate?: bo
 
 export function clearGoal(ctx: any): void {
   writeText(sessionFile(FEATURE, ctx, CURRENT_FILE), "");
+  clearNoProgressRecovery(ctx);
   resetAdvisorSessionContext(ctx);
 }
 
+function completionLine(goal: string, input: GoalCompletionInput): string {
+  return `${JSON.stringify({
+    at: new Date().toISOString(),
+    goal,
+    summary: input.summary.trim(),
+    verification: input.verification.trim(),
+    source: input.source ?? "tool",
+  })}\n`;
+}
+
+export function completeActiveGoal(ctx: any, input: GoalCompletionInput): GoalCompletionResult {
+  const goal = activeGoal(ctx);
+  if (!goal) return { completed: false, reason: "No active goal." };
+
+  const summary = input.summary.trim();
+  const verification = input.verification.trim();
+  if (!summary) return { completed: false, goal, reason: "Goal completion requires a summary." };
+  if (!verification) return { completed: false, goal, reason: "Goal completion requires verification evidence or an explicit not-verified statement." };
+
+  appendText(COMPLETION_HISTORY_FILE, completionLine(goal, { ...input, summary, verification }));
+
+  const research = researchForGoal(ctx, goal);
+  if (research) recordResearchResult(ctx, research, "done");
+
+  endGoalCheck(ctx);
+  clearGoal(ctx);
+  setGoalStatus(ctx, null);
+  clearLoop(ctx, { clearResearch: true });
+  return { completed: true, goal };
+}
+
 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: ...`.",
+    "When the goal is complete, prefer the `goal_complete` tool with a summary and verification evidence. If that tool is unavailable during a loop tick, answer exactly with `GOAL_DONE: ...`.",
+    "When the goal is not complete during a loop tick, answer exactly with `GOAL_CONTINUE: ...` and then take one concrete next action.",
   ].join("\n");
 }
 
@@ -154,9 +203,13 @@ export function registerGoal(pi: ExtensionAPI): void {
     if (research) recordResearchResult(ctx, research, result);
 
     if (result === "done") {
-      clearGoal(ctx);
-      setGoalStatus(ctx, null);
-      clearLoop(ctx, { clearResearch: true });
+      const text = assistantText(event);
+      const summary = text.replace(/^GOAL_DONE:\s*/i, "").trim() || "Goal marked done by sentinel response.";
+      completeActiveGoal(ctx, {
+        summary: truncate(summary, 1200),
+        verification: "GOAL_DONE sentinel response; see assistant message for final state and evidence.",
+        source: "sentinel",
+      });
       ctx.ui.notify(`🎯 Goal completed: ${truncate(goal, 160)}`, "info");
     }
   });
@@ -169,6 +222,33 @@ export function registerGoal(pi: ExtensionAPI): void {
     return { systemPrompt: `${event.systemPrompt}\n\n${goalBlock(goal)}` };
   });
 
+  const registerTool = (pi as any).registerTool;
+  if (typeof registerTool === "function") registerTool.call(pi, {
+    name: "goal_complete",
+    label: "Goal Complete",
+    description: "Mark the active Pi-Rogue goal complete. Requires a completion summary and verification evidence.",
+    parameters: Type.Object({
+      summary: Type.String({ description: "What was completed for the active goal" }),
+      verification: Type.String({ description: "How completion was verified, or an explicit not-verified statement with reason" }),
+    }),
+    async execute(_id: unknown, params: { summary?: unknown; verification?: unknown }, _signal: unknown, onUpdate: ((update: unknown) => void) | undefined, ctx: any) {
+      const result = completeActiveGoal(ctx, {
+        summary: String(params.summary ?? ""),
+        verification: String(params.verification ?? ""),
+        source: "tool",
+      });
+      if (!result.completed) {
+        const message = result.reason || "Goal completion failed.";
+        onUpdate?.({ content: [{ type: "text", text: message }], details: { completed: false } });
+        return { content: [{ type: "text", text: message }], details: { completed: false } };
+      }
+
+      const message = `Goal completed: ${truncate(result.goal || "", 160)}`;
+      ctx.ui.notify(`🎯 ${message}`, "info");
+      return { content: [{ type: "text", text: message }], details: { completed: true, goal: result.goal } };
+    },
+  });
+
   pi.registerCommand("goal", {
     description: "Set, show, clear, or list the current session goal",
     getArgumentCompletions: (prefix: string) => goalArgumentCompletions(prefix),

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

@@ -3,6 +3,7 @@ import { appendText, featureFile, readText, sessionFile, sessionKey, truncate }
 import { clearResearchState, hasActiveResearch } from "./autoresearch-state.js";
 import { setAdvisorCheckinsEnabled } from "./advisor-checkins.js";
 import { buildGoalCheckPrompt, beginGoalCheck, hasGoalCheckPending } from "./goal-resolution.js";
+import { clearNoProgressRecovery } from "./novelty-guard.js";
 import { readSessionJson, writeSessionJson } from "./state.js";
 import { loopArgumentCompletions } from "./completions.js";
 
@@ -60,6 +61,7 @@ export function clearLoop(ctx: any, options: { clearResearch?: boolean; preserve
   const current = readLoopState(ctx);
   archiveLoopState(ctx, current);
   const next = clearLoopState(ctx);
+  clearNoProgressRecovery(ctx);
   stopLoopTimer(sessionKey(ctx));
   setLoopStatus(ctx, next);
   if (!options.preserveCheckins) {
@@ -202,6 +204,7 @@ export function startLoop(pi: ExtensionAPI, ctx: any, interval: string, instruct
     return null;
   }
 
+  clearNoProgressRecovery(ctx);
   const next = writeLoopState(ctx, {
     enabled: true,
     interval,

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

@@ -1,11 +1,15 @@
+import { randomUUID } from "node:crypto";
 import { describe, expect, it } from "vitest";
 import {
   detectAssistantRepetition,
+  looksLikeNoProgressTurn,
   normalizeTurn,
   recordAssistantTurn,
+  registerNoveltyGuard,
   turnSimilarity,
   type RepetitionGuardState,
 } from "./novelty-guard.js";
+import { readText, sessionFile, writeText } from "./internal.js";
 
 describe("repetition guard", () => {
   it("normalizes noisy assistant text", () => {
@@ -21,6 +25,45 @@ describe("repetition guard", () => {
     expect(similarity).toBeGreaterThan(0.8);
   });
 
+  it("identifies planning-only no-progress turns", () => {
+    expect(looksLikeNoProgressTurn("I will think through the approach and plan the next steps.")).toBe(true);
+    expect(looksLikeNoProgressTurn("I ran npm test and found one failing assertion.")).toBe(false);
+  });
+
+  it("tracks bounded no-progress only while orchestration is active", () => {
+    const base: RepetitionGuardState = { recentAssistantTurns: [] };
+    const first = recordAssistantTurn(base, "I will think through the approach and plan the next step.", { activeOrchestration: true });
+    const second = recordAssistantTurn(first, "I will think through the approach and plan the next step.", { activeOrchestration: true });
+    const third = recordAssistantTurn(second, "I will think through the approach and plan the next step.", { activeOrchestration: true });
+
+    expect(third.noProgress?.count).toBe(3);
+
+    const inactive = recordAssistantTurn(base, "I will think through the approach and plan the next step.", { activeOrchestration: false });
+    expect(inactive.noProgress).toBeUndefined();
+  });
+
+  it("does not inject stale no-progress recovery after orchestration is inactive", async () => {
+    const handlers: Record<string, (event: any, ctx: any) => Promise<any> | any> = {};
+    const pi = {
+      on: (name: string, handler: (event: any, ctx: any) => Promise<any> | any) => { handlers[name] = handler; },
+    } as any;
+    const sessionPath = `/tmp/pi-rogue-novelty-${randomUUID()}.jsonl`;
+    const ctx = {
+      sessionManager: { getSessionFile: () => sessionPath },
+      ui: { notify: () => undefined },
+    };
+    writeText(sessionFile("orchestration", ctx, "repetition-guard.json"), `${JSON.stringify({
+      recentAssistantTurns: [],
+      noProgress: { at: new Date().toISOString(), count: 3, text: "I will plan the next step.", reason: "test" },
+    })}\n`);
+
+    registerNoveltyGuard(pi);
+    const result = await handlers.before_agent_start?.({ systemPrompt: "base" }, ctx);
+
+    expect(result.systemPrompt).toBe("base");
+    expect(JSON.parse(readText(sessionFile("orchestration", ctx, "repetition-guard.json"))).noProgress).toBeUndefined();
+  });
+
   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.");