@ilya-lesikov/pi-pi 0.8.0 → 0.9.0

package/extensions/orchestrator/state.test.ts

@@ -5,6 +5,7 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import lockfile from "proper-lockfile";
 import {
   createTask,
+  formatModeIndicator,
   getActiveTask,
   getEffectiveMode,
   getFirstPhase,
@@ -410,4 +411,12 @@ describe("getEffectiveMode", () => {
 
     expect(getEffectiveMode(state)).toBeUndefined();
   });
+
+  it("formatModeIndicator: autonomous stays autonomous, quick shows nothing, else guided (#4)", () => {
+    expect(formatModeIndicator({ ...baseState(), mode: "autonomous" }, "implement")).toBe("autonomous");
+    expect(formatModeIndicator({ ...baseState(), effectiveMode: "autonomous" }, "implement")).toBe("autonomous");
+    expect(formatModeIndicator({ ...baseState(), mode: "guided" }, "implement")).toBe("guided");
+    expect(formatModeIndicator({ ...baseState() }, "implement")).toBe("guided");
+    expect(formatModeIndicator({ ...baseState(), mode: "autonomous" }, "quick")).toBeUndefined();
+  });
 });

package/extensions/orchestrator/state.ts

@@ -58,6 +58,14 @@ export interface TaskState {
   autonomousConfig?: AutonomousConfig;
   plannerFailureAutoRetried?: boolean;
   reviewerFailureAutoRetried?: boolean;
+  // Set once afterImplement has run for the current implement phase (either at
+  // the guided/autonomous transition or the autonomous terminal handoff), so the
+  // hooks never run twice for the same completion.
+  afterImplementRan?: boolean;
+  // Per-repo interleaved Plannotator review cursor (#3a). repoPaths is the ordered
+  // set of repos to review; index is the next repo. Persisted so the loop resumes
+  // on the next /pp after the agent fixes one repo's feedback. Undefined = no loop.
+  plannotatorCursor?: { repoPaths: string[]; index: number };
 }
 
 export interface TaskInfo {
@@ -93,6 +101,13 @@ export function getEffectivePhaseMode(state: TaskState): TaskMode {
   return getEffectiveMode(state) ?? "guided";
 }
 
+// Display-only: reflects the task's chosen mode regardless of per-phase interactivity.
+// Returns undefined for quick tasks so the footer omits the mode segment entirely.
+export function formatModeIndicator(state: TaskState, type: TaskType): TaskMode | undefined {
+  if (type === "quick") return undefined;
+  return getEffectiveMode(state) === "autonomous" ? "autonomous" : "guided";
+}
+
 export function createTask(cwd: string, type: TaskType, description: string, mode?: TaskMode): string {
   const log = getLogger();
   const id = crypto.randomUUID().slice(0, 12);

package/extensions/orchestrator/transition-controller.test.ts

@@ -205,3 +205,103 @@ describe("TransitionController phase transition flow", () => {
     expect(onResume).toHaveBeenCalledOnce();
   });
 });
+
+describe("TransitionController done supersession (task-boundary discard cannot be swallowed)", () => {
+  it("a done request supersedes a PENDING transition in place (no swallowed discard)", async () => {
+    const { host, session, calls, completeCompaction } = makeHost({ idle: false });
+    const c = new TransitionController(host, session);
+    // A phase transition is pending (not yet compacting: waiting for agent_end).
+    const staleResume = vi.fn();
+    const pPhase = c.requestTransition({ kind: "phase", summary: "phase", onResume: staleResume, instruction: "Begin working." });
+    expect(c.getState()).toBe("pending");
+    // A new-task done arrives before agent_end. It must replace the pending req.
+    const pDone = c.requestTransition({ kind: "done", discard: true, summary: "DISCARD" });
+    expect(c.getState()).toBe("pending");
+    expect(c.currentSummary()).toBe("DISCARD");
+    expect(c.isDiscardTransition()).toBe(true);
+
+    c.onAgentEnd();
+    expect(calls.compactStarted).toBe(1);
+    completeCompaction();
+    await Promise.all([pPhase, pDone]);
+    // The superseded phase resume/instruction must NOT have run.
+    expect(staleResume).not.toHaveBeenCalled();
+    expect(calls.userMessages).toHaveLength(0);
+    expect(c.getState()).toBe("running");
+  });
+
+  it("queues a done request behind a COMPACTING transition and runs its discard after", async () => {
+    const { host, session, calls, completeCompaction } = makeHost({ idle: false });
+    const c = new TransitionController(host, session);
+    const staleResume = vi.fn();
+    const pPhase = c.requestTransition({ kind: "phase", summary: "phase", onResume: staleResume, instruction: "Begin working." });
+    c.onAgentEnd();
+    expect(c.getState()).toBe("compacting");
+
+    // done arrives mid-compaction — must be queued, not dropped, not double-resumed.
+    let doneResolved = false;
+    const pDone = c.requestTransition({ kind: "done", discard: true, summary: "DISCARD" }).then(() => { doneResolved = true; });
+    expect(calls.compactStarted).toBe(1);
+
+    // First (phase) compaction settles. The superseded phase instruction must be
+    // suppressed because a done is queued behind it; the queued done then runs.
+    completeCompaction();
+    await pPhase;
+    expect(staleResume).toHaveBeenCalledOnce(); // phase onResume still ran (it was the active req)
+    // The queued done must not have resolved yet — its own compaction must run.
+    expect(doneResolved).toBe(false);
+    expect(calls.compactStarted).toBe(2);
+    expect(c.currentSummary()).toBe("DISCARD");
+    expect(c.isDiscardTransition()).toBe(true);
+
+    completeCompaction();
+    await pDone;
+    expect(doneResolved).toBe(true);
+    expect(c.getState()).toBe("running");
+    // The superseded phase instruction ("Begin working.") must NOT have been sent.
+    expect(calls.userMessages).toHaveLength(0);
+  });
+
+  it("queues a done request behind a RESUMING transition", async () => {
+    const { host, session, calls, completeCompaction } = makeHost({ idle: false });
+    const c = new TransitionController(host, session);
+    // onResume that lets us inject the done request while state === "resuming".
+    let injected: Promise<void> | null = null;
+    const pPhase = c.requestTransition({
+      kind: "phase",
+      summary: "phase",
+      onResume: () => {
+        expect(c.getState()).toBe("resuming");
+        injected = c.requestTransition({ kind: "done", discard: true, summary: "DISCARD" });
+      },
+      instruction: "Begin working.",
+    });
+    c.onAgentEnd();
+    completeCompaction();
+    await pPhase;
+    // A done was queued during resuming — it must run its own compaction now.
+    expect(injected).not.toBeNull();
+    expect(calls.compactStarted).toBe(2);
+    completeCompaction();
+    await injected!;
+    expect(c.getState()).toBe("running");
+    expect(c.isDiscardTransition()).toBe(false);
+  });
+
+  it("last-wins when two done requests queue behind an in-flight transition", async () => {
+    const { host, session, calls, completeCompaction } = makeHost({ idle: false });
+    const c = new TransitionController(host, session);
+    const pPhase = c.requestTransition({ kind: "phase", summary: "phase", onResume: () => {}, instruction: "go" });
+    c.onAgentEnd();
+    const pDone1 = c.requestTransition({ kind: "done", discard: true, summary: "FIRST" });
+    const pDone2 = c.requestTransition({ kind: "done", discard: true, summary: "SECOND" });
+
+    completeCompaction(); // phase settles -> queued done runs
+    await pPhase;
+    expect(c.currentSummary()).toBe("SECOND");
+    completeCompaction(); // done settles -> both queued callers resolve
+    await Promise.all([pDone1, pDone2]);
+    expect(c.getState()).toBe("running");
+    expect(calls.compactStarted).toBe(2);
+  });
+});

package/extensions/orchestrator/transition-controller.ts

@@ -26,6 +26,13 @@ export interface TransitionRequest {
   kind: TransitionKind;
   // Compaction summary used by the session_before_compact handler.
   summary?: string;
+  // Task-boundary discard: the previous task is finished/replaced and its
+  // conversation must be genuinely dropped (not softly summarized) so it cannot
+  // leak into the next task. Drives session_before_compact to keep no verbatim
+  // transcript beyond the summary. Only set on finished/replaced-task "done"
+  // transitions (startTask/finishTask/task-complete) — NOT pause/stop (those
+  // resume later and must preserve context).
+  discard?: boolean;
   // Runs after compaction completes (or is skipped), before the resume message.
   // Used for phase transitions to switch model + inject context/artifacts and to
   // spawn planners at the right moment. Throwing here is logged, not fatal.
@@ -80,6 +87,11 @@ export class TransitionController {
   private active: TransitionRequest | null = null;
   // Resolvers for callers that await the transition (done/stop/new-task paths).
   private waiters: Array<() => void> = [];
+  // A single "done" transition queued behind an in-flight (compacting/resuming)
+  // transition it supersedes. Run once the current transition settles so its
+  // discard compaction is guaranteed to execute. Last-wins (never a queue).
+  private pendingNext: TransitionRequest | null = null;
+  private pendingNextWaiters: Array<() => void> = [];
 
   constructor(
     private readonly host: TransitionHost,
@@ -141,6 +153,13 @@ export class TransitionController {
     return this.active?.summary ?? "";
   }
 
+  // True when the in-flight transition is a task-boundary discard (see
+  // TransitionRequest.discard). Lets session_before_compact drop the verbatim
+  // transcript window instead of keeping the default recent tokens.
+  isDiscardTransition(): boolean {
+    return this.active?.discard === true;
+  }
+
   // Outbound plain user-message. The ONLY path for main-session user messaging.
   // Plain user messages (pi.sendUserMessage) ALWAYS start a turn — even with
   // deliverAs:"steer" when idle (SDK prompt()) — so this only serves the
@@ -168,8 +187,29 @@ export class TransitionController {
   requestTransition(req: TransitionRequest): Promise<void> {
     const log = getLogger();
     if (this.state !== "running") {
-      // A transition is already in flight. Coalesce: ignore the new request but
-      // still attach the waiter so the caller is released when this settles.
+      // A transition is already in flight. A task-boundary discard (kind:"done")
+      // must NOT be silently skipped by an in-flight/aborted transition — that
+      // is the concrete cause of prior-task context leaking into the next task.
+      if (req.kind === "done") {
+        if (this.state === "pending") {
+          // Not compacting yet (waiting for agent_end). Replace the pending
+          // request in place: its onResume/instruction is dropped (superseded),
+          // its waiters ride along and resolve when the done transition settles.
+          log.debug({ s: "controller", superseded: this.active?.kind }, "done supersedes pending transition");
+          this.active = req;
+          const promise = new Promise<void>((resolve) => this.waiters.push(resolve));
+          if (this.host.isIdle()) this.beginCompaction();
+          return promise;
+        }
+        // compacting/resuming: a compaction is already in flight for the old
+        // request. Queue the done request to run once it settles so its discard
+        // compaction actually executes; suppress the superseded instruction.
+        // Last-wins if one is already queued (never an unbounded queue).
+        log.debug({ s: "controller", state: this.state }, "done queued behind in-flight transition");
+        this.pendingNext = req;
+        return new Promise<void>((resolve) => this.pendingNextWaiters.push(resolve));
+      }
+      // phase (or other) while not running: keep conservative coalescing.
       if (req.kind === "phase") {
         log.warn({ s: "controller", state: this.state }, "phase transition coalesced while not running — onResume/instruction dropped");
       } else {
@@ -247,7 +287,10 @@ export class TransitionController {
     } catch (err: any) {
       getLogger().error({ s: "controller", err: err?.message ?? String(err) }, "onResume failed");
     }
-    if (req?.instruction) {
+    // Suppress the superseded transition's resume instruction when a done
+    // request is queued to supersede it (its followUp would resume a task that
+    // is about to be discarded).
+    if (req?.instruction && !this.pendingNext) {
       this.send(req.instruction, "instruction");
     }
     this.active = null;
@@ -255,5 +298,20 @@ export class TransitionController {
     const waiters = this.waiters;
     this.waiters = [];
     for (const w of waiters) w();
+    // A done transition queued while this one was in flight: run it now. We are
+    // post-compaction with no agent turn in flight, so begin its compaction
+    // directly rather than through the isIdle/agent_end gate. Its queued callers
+    // ride the new transition's waiters, so they resolve only AFTER the discard
+    // compaction settles.
+    if (this.pendingNext) {
+      const next = this.pendingNext;
+      const resolvers = this.pendingNextWaiters;
+      this.pendingNext = null;
+      this.pendingNextWaiters = [];
+      this.active = next;
+      this.state = "pending";
+      for (const r of resolvers) this.waiters.push(r);
+      this.beginCompaction();
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ilya-lesikov/pi-pi",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Pi-Pi Coding Agent: based on Pi Coding Agent, but twice as good",
   "keywords": [
     "pi-package",

package/AGENTS.md

@@ -1,28 +0,0 @@
-# Repository Guidelines
-
-All rules in this document are requirements — not suggestions. ALWAYS follow them.
-
-## Highest-priority rule (MANDATORY)
-
-- NEVER add comments unless they document a non-obvious public API or explain genuinely non-obvious logic. NEVER add comments that restate what the code does, repeat the field/function name, describe obvious error handling, or act as section separators. When in doubt, don't comment.
-- ALWAYS verify, don't assume — check the actual state before making changes.
-- ALWAYS start with the simplest possible solution. If it works, stop. Add complexity only when justified by a concrete, current requirement — NEVER for hypothetical future needs.
-- NEVER leave TODOs, stubs, or partial implementations.
-- ALWAYS stay within the scope of what was asked. When asked to update a plan — only update the plan, don't change code. When asked to brainstorm/discuss — only discuss, don't write code. When asked to do X — do X and nothing else. NEVER make unsolicited changes.
-
-## Code style
-
-### Design (MANDATORY)
-
-- ALWAYS prefer stupid and simple over abstract and extendable.
-- ALWAYS prefer a bit of duplication over complex abstractions.
-- ALWAYS prefer clarity over brevity in names.
-- ALWAYS minimize interfaces, generics, embedding.
-- ALWAYS prefer fewer types. Prefer no types over few. Prefer data types over types with behavior.
-- ALWAYS prefer functions over methods. ALWAYS prefer public fields over getters/setters.
-- ALWAYS keep everything private/internal as much as possible.
-- ALWAYS validate early, validate a lot. ALWAYS keep APIs stupid and minimal.
-- NEVER prefer global state. ALWAYS prefer simplicity over micro-optimizations.
-- ALWAYS use libraries for complex things instead of reinventing the wheel.
-- NEVER add comments unless they document a non-obvious public API or explain genuinely non-obvious logic. NEVER add obvious/redundant comments, NEVER add comments restating what code does. When in doubt, don't comment.
-