@brettinternet/pi-loop 0.1.4 → 0.1.6

package/README.md

@@ -1,45 +1,61 @@
 # pi-loop
 
-Run a prompt repeatedly, with a fresh session for every iteration. Each new session uses the model selected in the preceding session (including a custom non-default model); changing models mid-loop takes effect on the next iteration. If that model is unavailable, the loop pauses rather than falling back to the default.
+Run a prompt repeatedly, each iteration in a fresh session.
 
-```bash
+```sh
 pi install npm:@brettinternet/pi-loop
 ```
 
 ```text
-/loop <count> [--delay <duration>] <prompt>
-/loop for <duration> --delay <duration> <prompt>
-/loop <count>
-/loop +<count>
-/loop -<count>
-/loop time <duration>
-/loop delay <duration>
-/loop prompt <text>
-/loop append <text>
-/loop status
-/loop
-/loop pause
-/loop end
-/loop resume
-/loop next
+/loop 5 Fix the next failing test
+/loop 10 --delay 30m Check CI and fix failures
+/loop for 8h --delay 1h Review new issues
+/loop 10 /wait 10m /skill:myskill skill argument here
 ```
 
-Durations use `ms`, `s`, `m`, `h`, or `d`. Delays range from 1 second to 24 hours. Timed loops run for at most 30 days. During a loop, `/loop time <duration>` switches to a deadline from now or resets the current deadline; timed mode requires a non-zero delay. `/loop <count>` switches back to a count of future iterations.
-
-Errors retry after 30 seconds, 1 minute, and 2 minutes, then pause. Aborting pauses the loop. `/loop pause` pauses after the active iteration settles; if the loop is between iterations, it pauses immediately. Resuming then starts the next iteration. An agent `loop_pause` request pauses mid-iteration for human blockers, and resuming continues that iteration. Recovery preserves the loop so you can resume or advance it.
+The last example chains commands. Built-in interactive commands can't be chained.
 
-Chain commands in the prompt:
+## Control a running loop
 
 ```text
-/loop 10 /wait 10m /skill:myskill skill argument here
+/loop status          show state
+/loop 3               run 3 more iterations from now
+/loop +2              add 2 iterations
+/loop -1              remove 1 iteration
+/loop time 2h         stop 2h from now (requires a delay)
+/loop delay 5m        change the gap between iterations
+/loop prompt <text>   replace the prompt
+/loop append <text>   append to the prompt
+/loop pause           pause after this iteration
+/loop resume          resume
+/loop next            skip a paused iteration and start the next
+/loop end             stop gracefully
+/loop                 same as end
 ```
 
-Built-in interactive commands cannot be chained.
+Durations use `ms`, `s`, `m`, `h`, or `d`. Delays range from 1s to 24h. Timed loops require `--delay` and run at most 30 days.
+
+## Behavior
+
+| Event | Result |
+| --- | --- |
+| Model or thinking level changed mid-loop | The next iteration uses it; both initially match the session that invoked `/loop` |
+| Model unavailable | Loop pauses; no fallback to the default |
+| Error | Retries after 30s, 1m, and 2m, then pauses |
+| Abort | Loop pauses |
+| `/loop pause` between iterations | Pauses immediately |
+| Agent calls `loop_pause` | Pauses mid-iteration; resume continues that iteration |
+| Pending `/wait` or `until` watch | Iteration waits for its wake-up turn or cancellation |
+| Paused wait or recurring watch | Iteration waits until resumed or completed |
+
+Use `/loop delay` for a fixed gap, `/wait` for a same-session follow-up, and `until` for a condition that may become true sooner.
+
+## Run ID
 
-While a loop is active, every child command receives its stable run ID as `PI_LOOP_RUN_ID`:
+Every command run during a loop gets the loop's ID:
 
 ```text
 PI_LOOP_RUN_ID=3992f183-e054-4068-a13e-11281d1747e2
 ```
 
-The value is always the full UUID, remains unchanged across every iteration and replacement session in that loop, and differs between independent loops. When the loop ends or its session closes, pi-loop restores the previous value or removes the variable if it was previously unset.
+The UUID stays the same for every iteration of one loop and differs between loops. When the loop ends, the previous value is restored or the variable is removed.

package/index.ts

@@ -9,6 +9,8 @@ import type {
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 
+type ThinkingLevel = ReturnType<ExtensionAPI["getThinkingLevel"]>;
+
 export const LOOP_STATE_ENTRY = "pi-loop-state-v1";
 export const LOOP_WIDGET_KEY = "pi-loop";
 export const LOOP_RUN_ID_ENV = "PI_LOOP_RUN_ID";
@@ -49,6 +51,7 @@ export interface LoopState {
   ownerSessionId?: string;
   ownerSessionFile?: string;
   model?: { provider: string; id: string };
+  thinkingLevel?: ThinkingLevel;
 }
 
 export type ParsedLoopCommand =
@@ -445,6 +448,11 @@ export function parseLoopState(value: unknown): LoopState | undefined {
   if (value.ownerSessionId !== undefined && typeof value.ownerSessionId !== "string") return undefined;
   if (value.ownerSessionFile !== undefined && typeof value.ownerSessionFile !== "string") return undefined;
   const model = value.model;
+  const thinkingLevel = value.thinkingLevel;
+  if (
+    thinkingLevel !== undefined &&
+    !["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(thinkingLevel as string)
+  ) return undefined;
   if (
     model !== undefined &&
     (!isRecord(model) || typeof model.provider !== "string" || !model.provider ||
@@ -472,6 +480,7 @@ export function parseLoopState(value: unknown): LoopState | undefined {
     ...(isRecord(model) && typeof model.provider === "string" && typeof model.id === "string"
       ? { model: { provider: model.provider, id: model.id } }
       : {}),
+    ...(thinkingLevel !== undefined ? { thinkingLevel: thinkingLevel as ThinkingLevel } : {}),
   };
 }
 
@@ -639,6 +648,24 @@ export default function loopExtension(pi: ExtensionAPI): void {
   let pendingFailure: PendingFailure | undefined;
   let currentSessionManagerRef: unknown;
   let herdrBlocked = false;
+  const pendingWakes = new Map<string, boolean>();
+  let waitingForWake = false;
+  let wakeContext: ExtensionContext | undefined;
+
+  for (const channel of ["pi-until:busy", "pi-wait:busy"]) {
+    pi.events.on(channel, (value) => {
+      if (typeof value !== "boolean") return;
+      pendingWakes.set(channel, value);
+      if (!waitingForWake || [...pendingWakes.values()].some(Boolean)) return;
+      const ctx = wakeContext;
+      if (!ctx || !ctx.isIdle()) return;
+      const state = currentState(ctx);
+      if (!state || !statusIsActive(state) || transitionInFlight) return;
+      waitingForWake = false;
+      handledSettlementKey = stateKey(ctx, state);
+      scheduleContinuation(ctx, state);
+    });
+  }
 
   function reportHerdrBlocked(state: LoopState | undefined): void {
     const blocked = state?.status === "paused";
@@ -946,14 +973,14 @@ export default function loopExtension(pi: ExtensionAPI): void {
     replacement: ReplacementContext,
     state: LoopState,
   ): Promise<void> {
-    // The replacement owns the new extension runtime. Restore its model before
-    // starting a turn, rather than using the invalidated previous runtime.
-    if (state.model) {
+    // The replacement owns the new extension runtime. Restore its model and
+    // thinking level before starting a turn, rather than using the previous runtime.
+    if (state.model || state.thinkingLevel !== undefined) {
       await replacement.sendUserMessage(
         `/loop __restore_model ${state.runId} ${state.currentIteration}`,
         { expandPromptTemplates: true },
       );
-      if (replacement.model?.provider !== state.model.provider || replacement.model.id !== state.model.id) {
+      if (state.model && (replacement.model?.provider !== state.model.provider || replacement.model.id !== state.model.id)) {
         throw new Error(`loop model unavailable: ${state.model.provider}/${state.model.id}`);
       }
     }
@@ -1131,6 +1158,7 @@ export default function loopExtension(pi: ExtensionAPI): void {
     const next: LoopState = {
       ...withoutPause,
       ...(ctx.model ? { model: { provider: ctx.model.provider, id: ctx.model.id } } : {}),
+      thinkingLevel: pi.getThinkingLevel(),
       currentIteration: state.currentIteration + 1,
       remainingBudget: state.endsAt === undefined ? nextBudget - 1 : 0,
       pendingRetune: null,
@@ -1184,11 +1212,14 @@ export default function loopExtension(pi: ExtensionAPI): void {
 
     if (parsed.kind === "restoreModel") {
       const state = currentState(ctx);
-      if (!state || state.runId !== parsed.runId || state.currentIteration !== parsed.iteration || !state.model) return;
-      const model = ctx.modelRegistry.find(state.model.provider, state.model.id);
-      if (!model || !(await pi.setModel(model))) {
-        throw new Error(`loop model unavailable: ${state.model.provider}/${state.model.id}`);
+      if (!state || state.runId !== parsed.runId || state.currentIteration !== parsed.iteration) return;
+      if (state.model) {
+        const model = ctx.modelRegistry.find(state.model.provider, state.model.id);
+        if (!model || !(await pi.setModel(model))) {
+          throw new Error(`loop model unavailable: ${state.model.provider}/${state.model.id}`);
+        }
       }
+      if (state.thinkingLevel !== undefined) pi.setThinkingLevel(state.thinkingLevel);
       return;
     }
 
@@ -1476,6 +1507,7 @@ export default function loopExtension(pi: ExtensionAPI): void {
       retryCount: 0,
       phase: "running",
       ...(ctx.model ? { model: { provider: ctx.model.provider, id: ctx.model.id } } : {}),
+      thinkingLevel: pi.getThinkingLevel(),
       ...(timed ? { endsAt: Date.now() + parsed.duration } : {}),
       ...(contextIdentity(ctx).id ? { ownerSessionId: contextIdentity(ctx).id } : {}),
       ...(contextIdentity(ctx).file ? { ownerSessionFile: contextIdentity(ctx).file } : {}),
@@ -1523,6 +1555,9 @@ export default function loopExtension(pi: ExtensionAPI): void {
     clearCommandInterruption();
     pendingFailure = undefined;
     currentSessionManagerRef = ctx.sessionManager;
+    pendingWakes.clear();
+    waitingForWake = false;
+    wakeContext = ctx;
     transitionInFlight = false;
     handledSettlementKey = undefined;
     const loaded = latestStateFromContext(ctx);
@@ -1593,6 +1628,12 @@ export default function loopExtension(pi: ExtensionAPI): void {
       return;
     }
     if (handledSettlementKey === key) return;
+    if ([...pendingWakes.values()].some(Boolean)) {
+      waitingForWake = true;
+      wakeContext = ctx;
+      return;
+    }
+    waitingForWake = false;
     handledSettlementKey = key;
     scheduleContinuation(ctx, loaded);
   });
@@ -1604,6 +1645,9 @@ export default function loopExtension(pi: ExtensionAPI): void {
     clearCommandInterruption();
     pendingFailure = undefined;
     currentSessionManagerRef = ctx.sessionManager;
+    pendingWakes.clear();
+    waitingForWake = false;
+    wakeContext = ctx;
     handledSettlementKey = undefined;
     const loaded = latestStateFromContext(ctx);
     const owned = loaded && stateBelongsToContext(loaded, ctx) ? loaded : undefined;
@@ -1633,6 +1677,9 @@ export default function loopExtension(pi: ExtensionAPI): void {
     reportHerdrBlocked(undefined);
     clearWidget(ctx);
     currentSessionManagerRef = undefined;
+    waitingForWake = false;
+    wakeContext = undefined;
+    pendingWakes.clear();
   });
 
   pi.registerCommand("loop", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brettinternet/pi-loop",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Run a prompt repeatedly in fresh Pi sessions",
   "type": "module",
   "license": "MIT",