@monotykamary/pi-loop 0.1.12

package/src/session/response-parser.ts

@@ -0,0 +1,37 @@
+/**
+ * Response parser for supervisor model decisions.
+ */
+
+import type { SteeringDecision, InterventionASI } from '../types.js';
+
+/**
+ * Parse a supervisor decision from text response.
+ * Handles JSON extraction from markdown code blocks or raw JSON.
+ */
+export function parseDecision(text: string): SteeringDecision {
+  const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/) ?? text.match(/(\{[\s\S]*\})/);
+  const jsonStr = jsonMatch?.[1] ?? text.trim();
+
+  try {
+    const parsed = JSON.parse(jsonStr) as Partial<SteeringDecision>;
+    const action = parsed.action;
+    if (action !== 'continue' && action !== 'steer' && action !== 'done') {
+      return safeContinue('Invalid action in supervisor response');
+    }
+    return {
+      action,
+      message: typeof parsed.message === 'string' ? parsed.message.trim() : undefined,
+      reasoning: typeof parsed.reasoning === 'string' ? parsed.reasoning : '',
+      confidence: typeof parsed.confidence === 'number' ? parsed.confidence : 0.5,
+      asi:
+        parsed.asi && typeof parsed.asi === 'object' ? (parsed.asi as InterventionASI) : undefined,
+    };
+  } catch {
+    return safeContinue('Failed to parse supervisor JSON decision');
+  }
+}
+
+/** Create a safe "continue" decision with a reason. */
+export function safeContinue(reason: string): SteeringDecision {
+  return { action: 'continue', reasoning: reason, confidence: 0 };
+}

package/src/state/manager.ts

@@ -0,0 +1,164 @@
+/**
+ * LoopStateManager — manages in-memory loop state and session persistence.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
+import type { LoopState, LoopIntervention, ConversationMessage, ReframeTier } from '../types.js';
+import { detectIneffectivePattern, type IneffectivePattern } from './patterns.js';
+import {
+  getReframeTier,
+  escalateReframeTier as escalateReframeTierInState,
+  resetReframeTier as resetReframeTierInState,
+} from './reframe.js';
+
+const ENTRY_TYPE = 'loop-state';
+
+const DEFAULT_PROVIDER: string | null = null;
+const DEFAULT_MODEL_ID: string | null = null;
+
+export class LoopStateManager {
+  private state: LoopState | null = null;
+  private pi: ExtensionAPI;
+
+  constructor(pi: ExtensionAPI) {
+    this.pi = pi;
+  }
+
+  start(outcome: string, provider: string, modelId: string): void {
+    this.state = {
+      active: true,
+      outcome,
+      provider,
+      modelId,
+      interventions: [],
+      startedAt: Date.now(),
+      turnCount: 0,
+      snapshotBuffer: [],
+      lastAnalyzedTurn: -1,
+      justSteered: false,
+      reframeTier: 0,
+      lastSteerTurn: -1,
+    };
+    this.persist();
+  }
+
+  stop(): void {
+    if (!this.state) return;
+    this.state.active = false;
+    this.state.outcome = ''; // Clear the goal so /supervise starts fresh, not in append mode
+    this.persist();
+  }
+
+  isActive(): boolean {
+    return this.state?.active === true;
+  }
+
+  getState(): LoopState | null {
+    return this.state;
+  }
+
+  addIntervention(intervention: LoopIntervention): void {
+    if (!this.state) return;
+    this.state.interventions.push(intervention);
+    this.state.justSteered = true;
+    this.state.lastSteerTurn = intervention.turnCount;
+    this.persist();
+  }
+
+  clearJustSteered(): void {
+    if (!this.state) return;
+    this.state.justSteered = false;
+  }
+
+  incrementTurnCount(): void {
+    if (!this.state) return;
+    this.state.turnCount++;
+  }
+
+  setModel(provider: string, modelId: string): void {
+    if (!this.state) return;
+    this.state.provider = provider;
+    this.state.modelId = modelId;
+    this.persist();
+  }
+
+  updateOutcome(outcome: string): void {
+    if (!this.state) return;
+    this.state.outcome = outcome;
+    this.persist();
+  }
+
+  updateSnapshotBuffer(messages: ConversationMessage[]): void {
+    if (!this.state) return;
+    this.state.snapshotBuffer = messages;
+    this.state.lastAnalyzedTurn = this.state.turnCount;
+  }
+
+  getSnapshotBuffer(): ConversationMessage[] {
+    return this.state?.snapshotBuffer ?? [];
+  }
+
+  shouldAnalyzeMidRun(turnIndex: number): boolean {
+    if (!this.state) return false;
+    // Check if we just steered (verify it worked), or safety valve every 8th turn
+    if (this.state.justSteered) return true;
+    if (turnIndex > 0 && turnIndex % 8 === 0) return true;
+    return false;
+  }
+
+  // ---- Reframe tier management ----
+
+  getReframeTier(): ReframeTier {
+    return getReframeTier(this.state);
+  }
+
+  escalateReframeTier(): void {
+    if (!this.state) return;
+    if (escalateReframeTierInState(this.state)) {
+      this.persist();
+    }
+  }
+
+  resetReframeTier(): void {
+    if (!this.state) return;
+    resetReframeTierInState(this.state);
+    this.persist();
+  }
+
+  // ---- Pattern detection ----
+
+  detectIneffectivePattern(): IneffectivePattern {
+    if (!this.state) return { detected: false, similarCount: 0, turnsSinceLastSteer: 0 };
+    return detectIneffectivePattern(this.state);
+  }
+
+  // ---- Persistence ----
+
+  /** Restore state from session entries (finds the most recent loop-state entry). */
+  loadFromSession(ctx: ExtensionContext): void {
+    const entries = ctx.sessionManager.getBranch();
+    for (let i = entries.length - 1; i >= 0; i--) {
+      const entry = entries[i];
+      if (entry.type === 'custom' && (entry as any).customType === ENTRY_TYPE) {
+        const loaded = (entry as any).data as LoopState;
+        // Restore ephemeral fields
+        this.state = {
+          ...loaded,
+          snapshotBuffer: [],
+          lastAnalyzedTurn: -1,
+          justSteered: false,
+        };
+        return;
+      }
+    }
+    this.state = null;
+  }
+
+  /** Persist current state to session (public for compaction handler). */
+  persist(): void {
+    if (!this.state) return;
+    // Don't persist ephemeral fields that are runtime-only
+    const { snapshotBuffer, lastAnalyzedTurn, justSteered, ...toPersist } = this.state;
+    this.pi.appendEntry(ENTRY_TYPE, toPersist);
+  }
+}

package/src/state/patterns.ts

@@ -0,0 +1,81 @@
+/**
+ * Pattern detection for ineffective steering interventions.
+ */
+
+import type { LoopIntervention, LoopState } from '../types.js';
+
+export interface IneffectivePattern {
+  detected: boolean;
+  similarCount: number;
+  turnsSinceLastSteer: number;
+}
+
+/**
+ * Detect if recent interventions show a pattern of ineffectiveness.
+ * Returns similarity info if the last 2+ steering messages are similar.
+ */
+export function detectIneffectivePattern(
+  state: Pick<LoopState, 'interventions' | 'turnCount' | 'lastSteerTurn'>
+): IneffectivePattern {
+  const turnsSinceLastSteer = state.turnCount - (state.lastSteerTurn ?? 0);
+
+  // Check stagnation: no progress after 3+ turns since last steer
+  const stagnating =
+    state.lastSteerTurn !== undefined && state.lastSteerTurn >= 0 && turnsSinceLastSteer >= 3;
+
+  const recent = state.interventions.slice(-3);
+  if (recent.length < 2) {
+    // Still detect stagnation even with fewer than 2 interventions
+    return { detected: stagnating, similarCount: recent.length, turnsSinceLastSteer };
+  }
+
+  // Simple similarity: check if messages share common keywords or have similar length
+  const messages = recent.map((iv) => iv.message.toLowerCase());
+  let similarCount = 1;
+
+  for (let i = 1; i < messages.length; i++) {
+    if (areMessagesSimilar(messages[i - 1], messages[i])) {
+      similarCount++;
+    }
+  }
+
+  // Detected if 2+ recent messages are similar OR stagnating (no progress after 3+ turns)
+  const detected = similarCount >= 2 || stagnating;
+
+  return { detected, similarCount, turnsSinceLastSteer };
+}
+
+function areMessagesSimilar(a: string, b: string): boolean {
+  // Simple similarity heuristics
+  const normalize = (s: string) => s.replace(/[^\w\s]/g, '').trim();
+  const normA = normalize(a);
+  const normB = normalize(b);
+
+  // Exact match after normalization
+  if (normA === normB) return true;
+
+  // Check for common directive keywords
+  const directiveWords = [
+    'focus',
+    'implement',
+    'add',
+    'fix',
+    'create',
+    'build',
+    'need',
+    'should',
+    'must',
+  ];
+  const aDirectives = directiveWords.filter((w) => normA.includes(w));
+  const bDirectives = directiveWords.filter((w) => normB.includes(w));
+
+  // If they share 2+ directive words, likely similar
+  const commonDirectives = aDirectives.filter((w) => bDirectives.includes(w));
+  if (commonDirectives.length >= 2) return true;
+
+  // Length similarity (within 30%)
+  const lenRatio = Math.min(normA.length, normB.length) / Math.max(normA.length, normB.length);
+  if (lenRatio > 0.7 && commonDirectives.length >= 1) return true;
+
+  return false;
+}

package/src/state/reframe.ts

@@ -0,0 +1,33 @@
+/**
+ * Reframe tier state management.
+ */
+
+import type { ReframeTier, LoopState } from '../types.js';
+
+/** Maximum reframe tier value */
+const MAX_REFRAME_TIER: ReframeTier = 4;
+
+/** Get the current reframe tier from state */
+export function getReframeTier(state: LoopState | null): ReframeTier {
+  return state?.reframeTier ?? 0;
+}
+
+/** Get next tier value */
+function getNextTier(tier: ReframeTier): ReframeTier {
+  return Math.min(tier + 1, MAX_REFRAME_TIER) as ReframeTier;
+}
+
+/** Escalate reframe tier in state */
+export function escalateReframeTier(state: LoopState): boolean {
+  const current = state.reframeTier ?? 0;
+  if (current < MAX_REFRAME_TIER) {
+    state.reframeTier = getNextTier(current);
+    return true;
+  }
+  return false;
+}
+
+/** Reset reframe tier to 0 */
+export function resetReframeTier(state: LoopState): void {
+  state.reframeTier = 0;
+}

package/src/subagent-detector.ts

@@ -0,0 +1,94 @@
+/**
+ * Subagent detection via process tree inspection.
+ *
+ * This is extension-agnostic: we don't care HOW subagents were created
+ * (pi-messenger, manual spawn, or other extensions). We just check if
+ * there are child 'pi' processes still running.
+ */
+
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execAsync = promisify(exec);
+
+interface SubagentStatus {
+  hasActiveSubagents: boolean;
+  count: number;
+  pids: number[];
+}
+
+/**
+ * Check for child pi processes spawned by the current process.
+ * Works on macOS and Linux via ps. Windows returns false (not implemented).
+ */
+export async function checkChildPiProcesses(): Promise<SubagentStatus> {
+  const platform = process.platform;
+
+  if (platform === 'darwin' || platform === 'linux') {
+    return checkUnixChildProcesses();
+  }
+
+  // Windows: not implemented, assume no subagents
+  return { hasActiveSubagents: false, count: 0, pids: [] };
+}
+
+async function checkUnixChildProcesses(): Promise<SubagentStatus> {
+  try {
+    const ppid = process.pid;
+
+    // Get all pi processes with their parent PID
+    // Format: ppid pid command
+    const { stdout } = await execAsync(`ps -eo ppid,pid,comm | grep -E "\\bpi\\b" || true`);
+
+    const pids: number[] = [];
+
+    for (const line of stdout.trim().split('\n')) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 3) continue;
+
+      const childPpid = parseInt(parts[0], 10);
+      const childPid = parseInt(parts[1], 10);
+      const comm = parts[2];
+
+      // Check if this pi process is our direct child
+      // Also check for grandchildren (subagents spawning subagents)
+      if (childPpid === ppid && comm === 'pi') {
+        pids.push(childPid);
+      }
+    }
+
+    return {
+      hasActiveSubagents: pids.length > 0,
+      count: pids.length,
+      pids,
+    };
+  } catch {
+    return { hasActiveSubagents: false, count: 0, pids: [] };
+  }
+}
+
+/**
+ * Poll until no child pi processes remain or timeout.
+ * Returns true if all subagents completed, false if timeout.
+ */
+export async function waitForSubagents(
+  checkIntervalMs: number = 2000,
+  timeoutMs: number = 60000
+): Promise<{ completed: boolean; finalStatus: SubagentStatus }> {
+  const start = Date.now();
+
+  while (Date.now() - start < timeoutMs) {
+    const status = await checkChildPiProcesses();
+    if (!status.hasActiveSubagents) {
+      return { completed: true, finalStatus: status };
+    }
+    await sleep(checkIntervalMs);
+  }
+
+  const finalStatus = await checkChildPiProcesses();
+  return { completed: !finalStatus.hasActiveSubagents, finalStatus };
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/types.ts

@@ -0,0 +1,83 @@
+/**
+ * Core types for the pi-loop extension.
+ */
+
+export type LoopAction = 'continue' | 'steer' | 'done';
+
+/** A single intervention record */
+export interface LoopIntervention {
+  turnCount: number;
+  message: string;
+  reasoning: string;
+  timestamp: number;
+  /** Self-generated actionable side information */
+  asi?: InterventionASI;
+}
+
+/** Reframe tier tracks escalation of intervention strategies */
+export type ReframeTier = 0 | 1 | 2 | 3 | 4;
+
+/** Actionable Side Information — free-form observations from interventions */
+export interface InterventionASI {
+  /** Any observations worth remembering for future decisions */
+  [key: string]: unknown;
+}
+
+/** Full loop state — persisted to session */
+export interface LoopState {
+  active: boolean;
+  outcome: string;
+  provider: string; // e.g. "anthropic"
+  modelId: string; // e.g. "claude-haiku-4-5-20251001"
+  interventions: LoopIntervention[];
+  startedAt: number;
+  turnCount: number;
+  // Incremental snapshot buffer (not persisted, rebuilt on load)
+  snapshotBuffer?: ConversationMessage[];
+  lastAnalyzedTurn?: number;
+  justSteered?: boolean; // flag to check if steer worked
+  // Reframe escalation tracking
+  reframeTier?: ReframeTier;
+  lastSteerTurn?: number; // track when we last steered to detect ineffectiveness
+}
+
+/** Decision returned by the observer LLM */
+export interface SteeringDecision {
+  action: LoopAction;
+  message?: string;
+  reasoning: string;
+  confidence: number;
+  /** Self-generated actionable side information when steering */
+  asi?: InterventionASI;
+}
+
+/** Content block types for rich message capture */
+export type ContentBlock =
+  | { type: 'text'; text: string }
+  | { type: 'image'; source: string; mimeType?: string }
+  | { type: 'tool_call'; id: string; name: string; input: Record<string, unknown> }
+  | {
+      type: 'tool_result';
+      toolCallId: string;
+      content: (ContentBlock | string)[];
+      isError?: boolean;
+    };
+
+/** A simplified message for building the supervisor context - now with full tool support */
+export interface ConversationMessage {
+  role: 'user' | 'assistant' | 'tool_results';
+  content: string;
+  /** Rich content blocks for full fidelity capture (images, tool calls, tool results) */
+  blocks?: ContentBlock[];
+  /** Raw tool results associated with this turn (for assistant messages) */
+  toolResults?: ToolResultEntry[];
+}
+
+/** Captured tool result entry */
+export interface ToolResultEntry {
+  toolCallId: string;
+  toolName: string;
+  input: Record<string, unknown>;
+  content: ContentBlock[];
+  isError: boolean;
+}

package/src/ui/animations.ts

@@ -0,0 +1,70 @@
+/**
+ * Animation utilities for the supervisor widget.
+ */
+
+import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
+import type { WidgetState, WidgetAction } from './types.js';
+import type { LoopIntervention } from '../types.js';
+import { WIDGET_ID, ANIMATION_STEP_MS } from './types.js';
+
+/** Type for the render function callback */
+export type RenderFn = (
+  ctx: ExtensionContext,
+  snap: { outcome: string; interventions: LoopIntervention[] },
+  action: WidgetAction,
+  lastThinking: string,
+  hideFromBottom: number
+) => void;
+
+/** Start the line-by-line clear animation - hides lines from bottom to top */
+export function startLineClearAnimation(
+  ctx: ExtensionContext,
+  state: WidgetState,
+  renderFn: RenderFn
+): void {
+  if (!state.lastActiveState || state.lastThinkingLines.length === 0) return;
+
+  const isSteering = state.lastActionType === 'steering';
+  const targetVisibleCount = 0;
+
+  const animateStep = () => {
+    const currentVisible = state.lastThinkingLines.length - state.hiddenFromBottomCount;
+
+    if (currentVisible <= targetVisibleCount) {
+      if (isSteering) {
+        state.lastThinkingLines = [];
+        state.hiddenFromBottomCount = 0;
+        const reframeTier =
+          state.storedAction?.type === 'steering' ? (state.storedAction.reframeTier ?? 0) : 0;
+        renderFn(
+          ctx,
+          state.lastActiveState!,
+          { type: 'steering', message: '', reframeTier },
+          '',
+          0
+        );
+        return;
+      } else {
+        state.lastActiveState = null;
+        state.lastThinking = '';
+        state.lastThinkingLines = [];
+        state.hiddenFromBottomCount = 0;
+        state.storedAction = null;
+        ctx.ui.setWidget(WIDGET_ID, undefined);
+        return;
+      }
+    }
+
+    state.hiddenFromBottomCount++;
+    const reframeTier =
+      state.storedAction?.type === 'steering' ? (state.storedAction.reframeTier ?? 0) : 0;
+    const fallbackAction: WidgetAction = isSteering
+      ? { type: 'steering', message: '', reframeTier }
+      : { type: 'done', reframeTier: 0 };
+    renderFn(ctx, state.lastActiveState!, fallbackAction, '', state.hiddenFromBottomCount);
+
+    state.animationTimer = setTimeout(animateStep, ANIMATION_STEP_MS);
+  };
+
+  animateStep();
+}

package/src/ui/model-picker.ts

@@ -0,0 +1,79 @@
+/**
+ * model-picker — wraps pi's internal ModelSelectorComponent for use in
+ * the /loop model command. Shows the same model selector the user
+ * sees when pressing Ctrl+P in pi, with search and API-key availability.
+ */
+
+import {
+  ModelRuntime,
+  ModelSelectorComponent,
+  SettingsManager,
+  getAgentDir,
+} from '@earendil-works/pi-coding-agent';
+import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
+import type { Model } from '@earendil-works/pi-ai';
+
+/**
+ * Open the interactive model picker.
+ * Returns the selected Model, or null if the user cancelled.
+ */
+export async function pickModel(
+  ctx: ExtensionContext,
+  currentProvider?: string,
+  currentModelId?: string
+): Promise<Model<any> | null> {
+  if (ctx.mode !== 'tui') {
+    if (!ctx.hasUI) return null;
+    const all = ctx.modelRegistry.getAll();
+    if (all.length === 0) {
+      ctx.ui.notify('No models available.', 'info');
+      return null;
+    }
+    const items = all.map((m) => `${m.name ?? m.id} (${m.provider}/${m.id})`);
+    const pick = await ctx.ui.select('Pick a model', items);
+    if (pick === undefined) return null;
+    const idx = items.indexOf(pick);
+    if (idx < 0) return null;
+    return all[idx] ?? null;
+  }
+  // Resolve the currently-selected supervisor model (to pre-highlight it)
+  const currentModel =
+    currentProvider && currentModelId
+      ? ctx.modelRegistry.find(currentProvider, currentModelId)
+      : undefined;
+
+  // Minimal in-memory settings — we only need the selector, not persistence
+  const settingsManager = SettingsManager.inMemory();
+
+  // pi 0.80.8: ModelSelectorComponent takes the canonical ModelRuntime
+  // (previously the sync ModelRegistry facade). ExtensionContext only exposes
+  // modelRegistry, so build a runtime from the agent dir for the picker.
+  const modelRuntime = await ModelRuntime.create({
+    authPath: `${getAgentDir()}/auth.json`,
+    modelsPath: `${getAgentDir()}/models.json`,
+  });
+
+  return ctx.ui.custom<Model<any> | null>((tui, _theme, _kb, done) => {
+    const component = new ModelSelectorComponent(
+      tui,
+      currentModel,
+      settingsManager,
+      modelRuntime,
+      [], // no scoped-model cycling — we want the full model list
+      (model) => done(model),
+      () => done(null)
+    );
+
+    // Give focus so the search input is active immediately
+    component.focused = true;
+
+    return {
+      render: (width) => component.render(width),
+      invalidate: () => component.invalidate(),
+      handleInput: (data) => {
+        component.handleInput(data);
+        tui.requestRender();
+      },
+    };
+  });
+}