@fiale-plus/pi-rogue 0.2.3 → 0.2.4

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

@@ -8,6 +8,7 @@ Strategic advisor for Pi sessions with low-overhead preflight/post-review routin
 
 - SOTA-first model fallback: `gpt-5.5`/`claude-opus-4-6`/`claude-sonnet-4-6` where available.
 - Keeps command-level behavior simple and explicit.
+- Router/binary-gate policy escalates architecture/refactor/tradeoff/security/high-uncertainty and material stuck/no-progress work, while tiny edits, direct answers, docs/formatting cleanup, and other low-risk reactive tasks continue without advisor noise.
 
 ## Install
 

package/node_modules/@fiale-plus/pi-rogue-advisor/src/binary-gate-features.test.ts

@@ -16,4 +16,12 @@ describe("binary gate feature extraction", () => {
     expect(features.get("safety:production")).toBe(1);
     expect(features.get("safety:deploy")).toBe(1);
   });
+
+  it("emits stuck/no-progress cues for the binary gate", () => {
+    const features = extractBinaryGateFeatureCounts("goal loop stuck with repeated planning and no concrete progress");
+
+    expect(features.get("stuck:stuck")).toBe(1);
+    expect(features.get("stuck:repeated_planning")).toBe(1);
+    expect(features.get("stuck:no_concrete_progress")).toBe(1);
+  });
 });

package/node_modules/@fiale-plus/pi-rogue-advisor/src/binary-gate-features.ts

@@ -160,6 +160,13 @@ export function extractBinaryGateFeatureCounts(text: string): Map<string, number
     }
   }
 
+  const stuckWords = ["stuck", "looping", "spinning", "no progress", "no concrete progress", "same failure", "repeated failure", "repeated planning", "self talk", "forever thinking", "alternative action", "blocked"];
+  for (const stuckWord of stuckWords) {
+    if (lower.includes(stuckWord)) {
+      inc(counts, `stuck:${replaceSpaces(stuckWord)}`);
+    }
+  }
+
   const contextWords = ["need more context", "missing context", "clarify", "not enough info", "unspecified", "unknown", "ambiguous"];
   for (const contextWord of contextWords) {
     if (lower.includes(contextWord)) {

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

@@ -36,6 +36,32 @@ describe("advisor router heuristics", () => {
     expect(routeNote(route)).toMatch(/^\[advisor:rules: review, reason: [a-z0-9 ,.'-]+\]$/);
   });
 
+  it("escalates material stuck/no-progress prompts", () => {
+    const input: AdvisorRouteInput = { phase: "preflight", text: "the goal loop is stuck with repeated planning and no concrete progress after several turns" };
+    const route = heuristicRoute(input);
+
+    expect(route.label).toBe("escalate_to_advisor");
+    expect(route.escalate).toBe(true);
+    expect(route.reason).toContain("no-progress");
+  });
+
+  it("escalates stuck evidence even when low-risk edit cues are present", () => {
+    const input: AdvisorRouteInput = { phase: "preflight", text: "small README edit is stuck with no concrete progress after several turns" };
+    const route = heuristicRoute(input);
+
+    expect(route.label).toBe("escalate_to_advisor");
+    expect(route.reason).toContain("no-progress");
+  });
+
+  it("keeps routine docs cleanup out of advisor escalation", () => {
+    const input: AdvisorRouteInput = { phase: "preflight", text: "routine docs and formatting cleanup in README" };
+    const route = heuristicRoute(input);
+
+    expect(route.label).toBe("continue");
+    expect(route.escalate).toBe(false);
+    expect(route.review).toBe("off");
+  });
+
   it("flags safety-sensitive prompts", () => {
     const input: AdvisorRouteInput = { phase: "preflight", text: "run rm -rf on prod" };
     const route = heuristicRoute(input);

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

@@ -125,6 +125,7 @@ const QUICK_EDIT_RE = /\b(quick edit|small edit|tiny edit|rename|format(?:ting)?
 const ROUTINE_CLEANUP_RE = /\b(routine docs?|docs? and formatting|formatting cleanup|generated changes|large diff|docs?\/formatting)\b/i;
 const COMPLEX_RE = /\b(architecture|architectural|refactor|design|trade[- ]?off|concurrency|security|auth|migration|performance|scale|scalability|framework|system design|schema|data model|protocol|advisor routing|advisor flow|router logic|call vs skip|skip vs call|compare|recommend|benchmark|evaluate|experiment|train|strategy|choose|make sense|worth(?: it)?|kpi|kpis|how it works|where it comes from|what would you choose|what do you think|next step|pick between|buy|usage|sustained speed|available models|running model kpis)\b/i;
 const DEBUG_RE = /\b(debug|bug|error|stack trace|traceback|fail(?:ed|ure)?|broken|investigate|why is|cannot|can't|crash|regression)\b/i;
+const STUCK_RE = /\b(stuck|looping|spinning|no[- ]?progress|no concrete progress|same failure|repeated failure|repeated planning|self[- ]?talk|forever thinking|strategy change|alternative action|blocked)\b/i;
 const CONTEXT_RE = /\b(need more context|missing context|clarify|not enough info|unspecified|unknown|ambiguous)\b/i;
 const SAFETY_RE = /\b(rm\s+-rf|sudo\b|shutdown\b|reboot\b|mkfs(?:\.[\w-]+)?\b|chmod\s+-R\b|chown\b|git\s+push\b[\s\S]*--force(?:-with-lease)?|curl\b[\s\S]*\|\s*(?:sh|bash)\b|wget\b[\s\S]*\|\s*(?:sh|bash)\b|drop\s+table\b|delete\s+database\b|credential\b|password\b|secret\b)\b/i;
 const COMPACTION_RE = /\b(compact(?:ed|ion)?|missing history|history might flip|prior constraint|resume(?:d)? after compaction)\b/i;
@@ -293,6 +294,11 @@ function hasComplexSignal(text: string): boolean {
   return COMPLEX_RE.test(text) || DEBUG_RE.test(text);
 }
 
+function hasMaterialStuckSignal(text: string): boolean {
+  if (!STUCK_RE.test(text)) return false;
+  return /\b(goal|loop|autoresearch|tool|test|command|failure|failed|turns?|again|same|repeated|concrete|progress|blocked|alternative|recovery)\b/i.test(text);
+}
+
 function hasCompactionLowRiskSignal(text: string): boolean {
   return COMPACTION_RE.test(text) && /\blow[- ]?risk\b/i.test(text);
 }
@@ -342,6 +348,9 @@ function preflightSignals(input: AdvisorRouteInput): { label: PreflightLabel; co
   if (isSafetySensitive(text)) {
     return { label: "escalate_to_advisor", confidence: 0.98, reason: "Safety-sensitive keywords detected.", safety: true };
   }
+  if (hasMaterialStuckSignal(text)) {
+    return { label: "escalate_to_advisor", confidence: 0.86, reason: "Material stuck/no-progress signal detected.", safety: false };
+  }
   if (hasRoutineCleanupSignal(text) || (hasQuickEditSignal(text) && !hasComplexSignal(text))) {
     return { label: "continue", confidence: 0.9, reason: "Small-edit or routine-cleanup signal detected.", safety: false };
   }
@@ -424,7 +433,7 @@ export function buildRouterPrompt(input: AdvisorRouteInput): string {
     input.failed !== undefined ? `Failed: ${String(input.failed)}` : "",
     phase === "preflight"
       ? [
-        "Guidance: continue for tiny edits and direct answers; escalate_to_advisor for architecture, design, tradeoffs, security, or high uncertainty; need_more_context when underspecified; low_confidence when mixed signals.",
+        "Guidance: continue for tiny edits, direct answers, docs/formatting cleanup, and other low-risk reactive tasks; escalate_to_advisor for architecture, refactors, design, tradeoffs, security, irreversible actions, high uncertainty, or material stuck/no-progress evidence; need_more_context when underspecified; low_confidence when mixed signals. If advisor guidance conflicts with local evidence, the working model must reconcile explicitly rather than blindly follow it.",
       ].join(" ")
       : [
         "Guidance: on_track for clearly complete work; course_correct for partial work that needs changes; not_done when incomplete or failing; abstain when there is not enough signal.",

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.");

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

@@ -6,6 +6,8 @@ const STATE_FILE = "repetition-guard.json";
 const MAX_ASSISTANT_TURNS = 6;
 const REPEAT_COUNT = 3;
 const REPEAT_THRESHOLD = 0.8;
+const NO_PROGRESS_COUNT = 3;
+const BOUNDED_RECOVERY_COUNT = 5;
 
 export interface RepetitionGuardTurn {
   at: string;
@@ -18,9 +20,17 @@ export interface RepetitionGuardRepeat {
   text: string;
 }
 
+export interface NoProgressSignal {
+  at: string;
+  count: number;
+  text: string;
+  reason: string;
+}
+
 export interface RepetitionGuardState {
   recentAssistantTurns: RepetitionGuardTurn[];
   assistantRepeat?: RepetitionGuardRepeat;
+  noProgress?: NoProgressSignal;
 }
 
 export function defaultRepetitionGuardState(): RepetitionGuardState {
@@ -70,7 +80,18 @@ export function detectAssistantRepetition(state: RepetitionGuardState, minCount
   };
 }
 
-export function recordAssistantTurn(state: RepetitionGuardState, text: string): RepetitionGuardState {
+export function looksLikeNoProgressTurn(text: string): boolean {
+  const normalized = normalizeTurn(text);
+  if (normalized.length < 24) return false;
+
+  const planning = /\b(i will|i'll|let me|going to|we need to|we should|next i|plan|planning|approach|think through|summarize|restate)\b/i.test(text);
+  if (!planning) return false;
+
+  const concreteProgress = /\b(changed|edited|created|wrote|updated|implemented|removed|ran|tested|passed|failed|verified|validated|found|inspected|read|opened|committed|pushed|fixed|completed|result|error|diff)\b/i.test(text);
+  return !concreteProgress;
+}
+
+export function recordAssistantTurn(state: RepetitionGuardState, text: string, options: { activeOrchestration?: boolean } = {}): RepetitionGuardState {
   const trimmed = String(text ?? "").trim();
   if (!trimmed) return state;
   const next: RepetitionGuardState = {
@@ -78,7 +99,22 @@ export function recordAssistantTurn(state: RepetitionGuardState, text: string):
     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 };
+  const noProgressCount = options.activeOrchestration && looksLikeNoProgressTurn(trimmed)
+    ? (state.noProgress?.count ?? 0) + 1
+    : 0;
+
+  return {
+    ...next,
+    assistantRepeat: repeat ?? undefined,
+    noProgress: noProgressCount > 0
+      ? {
+          at: new Date().toISOString(),
+          count: noProgressCount,
+          text: truncate(trimmed, 240),
+          reason: "repeated planning/self-talk without concrete progress while orchestration is active",
+        }
+      : undefined,
+  };
 }
 
 function parseState(raw: string): RepetitionGuardState {
@@ -96,6 +132,14 @@ function parseState(raw: string): RepetitionGuardState {
             text: parsed.assistantRepeat.text,
           }
         : undefined,
+      noProgress: parsed.noProgress && typeof parsed.noProgress.text === "string"
+        ? {
+            at: String(parsed.noProgress.at ?? new Date().toISOString()),
+            count: Number(parsed.noProgress.count) || NO_PROGRESS_COUNT,
+            text: parsed.noProgress.text,
+            reason: String(parsed.noProgress.reason ?? "no concrete progress detected"),
+          }
+        : undefined,
     };
   } catch {
     return defaultRepetitionGuardState();
@@ -110,6 +154,44 @@ function writeGuardState(ctx: any, state: RepetitionGuardState): void {
   writeText(sessionFile(FEATURE, ctx, STATE_FILE), `${JSON.stringify(state, null, 2)}\n`);
 }
 
+export function clearNoProgressRecovery(ctx: any): void {
+  const state = readGuardState(ctx);
+  if (!state.noProgress) return;
+  writeGuardState(ctx, { ...state, noProgress: undefined });
+}
+
+function hasActiveOrchestration(ctx: any): boolean {
+  if (readText(sessionFile(FEATURE, ctx, "goal.md")).trim()) return true;
+  for (const file of ["loop.json", "autoresearch.json"]) {
+    try {
+      const parsed = JSON.parse(readText(sessionFile(FEATURE, ctx, file), "{}"));
+      if (parsed?.enabled || parsed?.instruction) return true;
+    } catch {
+      // ignore malformed state files; they should not trigger recovery
+    }
+  }
+  return false;
+}
+
+function recoveryPrompt(repeat?: RepetitionGuardRepeat, noProgress?: NoProgressSignal): string | null {
+  if (noProgress && noProgress.count < NO_PROGRESS_COUNT) noProgress = undefined;
+  if (!repeat && !noProgress) return null;
+  const count = Math.max(repeat?.count ?? 0, noProgress?.count ?? 0);
+  const bounded = count >= BOUNDED_RECOVERY_COUNT;
+  const signal = repeat
+    ? `Repeated assistant output (${repeat.count} turns): ${truncate(repeat.text, 180)}`
+    : `No-progress streak (${noProgress?.count} turns): ${truncate(noProgress?.text ?? "", 180)}`;
+
+  return [
+    bounded ? "Pi-Rogue bounded no-progress recovery:" : "Pi-Rogue no-progress recovery:",
+    signal,
+    noProgress?.reason ? `Reason: ${noProgress.reason}.` : "Reason: repeated output suggests the current approach is stuck.",
+    bounded
+      ? "Recovery is bounded now: do not stack another retry. If one safe, concrete alternative action is available, take exactly that action; otherwise stop and ask the user for direction with the current blocker."
+      : "Summarize the current state in one sentence, choose one concrete alternative action, and take it now. Do not only restate the plan or repeat the same response.",
+  ].join("\n");
+}
+
 export function registerNoveltyGuard(pi: ExtensionAPI): void {
   const p = pi as any;
   if (p.__piRogueNoveltyGuardRegistered) return;
@@ -117,16 +199,16 @@ export function registerNoveltyGuard(pi: ExtensionAPI): void {
 
   pi.on("before_agent_start", async (event, ctx) => {
     const state = readGuardState(ctx);
-    const repeat = detectAssistantRepetition(state) ?? state.assistantRepeat;
-    if (!repeat) return { systemPrompt: event.systemPrompt };
+    const active = hasActiveOrchestration(ctx);
+    const noProgress = active ? state.noProgress : undefined;
+    if (!active && state.noProgress) {
+      clearNoProgressRecovery(ctx);
+    }
+    const prompt = recoveryPrompt(detectAssistantRepetition(state) ?? state.assistantRepeat, noProgress);
+    if (!prompt) 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"),
+      systemPrompt: [event.systemPrompt, prompt].join("\n\n"),
     };
   });
 
@@ -136,10 +218,13 @@ export function registerNoveltyGuard(pi: ExtensionAPI): void {
     if (!text) return;
 
     const previous = readGuardState(ctx);
-    const next = recordAssistantTurn(previous, text);
+    const next = recordAssistantTurn(previous, text, { activeOrchestration: hasActiveOrchestration(ctx) });
     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");
     }
+    if (next.noProgress && next.noProgress.count >= NO_PROGRESS_COUNT && (!previous.noProgress || next.noProgress.count > previous.noProgress.count)) {
+      ctx.ui.notify("No-progress recovery detected repeated planning without concrete progress; the next turn will take one alternative action or stop.", "warning");
+    }
   });
 }