@monotykamary/pi-loop 0.1.12

package/src/core/prompt-builder.ts

@@ -0,0 +1,217 @@
+/**
+ * Prompt builder - constructs user prompts for the supervisor LLM.
+ */
+
+import type { LoopState, ConversationMessage, LoopIntervention } from '../types.js';
+import { extractMetrics } from './content-extractor.js';
+import { getReframeGuidance } from './reframe.js';
+
+/** Build the user-facing prompt for the supervisor LLM. */
+export function buildUserPrompt(
+  state: LoopState,
+  snapshot: ConversationMessage[],
+  agentIsIdle: boolean,
+  ineffectivePattern?: { detected: boolean; similarCount: number; turnsSinceLastSteer: number }
+): string {
+  // Build intervention history with full ASI display
+  const interventionHistory =
+    state.interventions.length === 0
+      ? 'None yet.'
+      : state.interventions
+          .slice(-5)
+          .map((iv, i) => {
+            let entry = `[${i + 1}] Turn ${iv.turnCount}: "${iv.message}"`;
+
+            // Display ASI prominently if present
+            if (iv.asi && Object.keys(iv.asi).length > 0) {
+              const asiEntries = Object.entries(iv.asi)
+                .map(([k, v]) => `${k}: ${JSON.stringify(v)}`)
+                .join(', ');
+              entry += `\n    ASI {${asiEntries}}`;
+            }
+            return entry;
+          })
+          .join('\n');
+
+  // Build ASI pattern summary for loop closing
+  const asiSummary = buildASISummary(state.interventions);
+
+  // Extract metrics from all conversation messages
+  const allMetrics: Record<string, number> = {};
+  for (const msg of snapshot) {
+    const msgMetrics = extractMetrics(msg.content);
+    Object.assign(allMetrics, msgMetrics);
+  }
+  const metricsText =
+    Object.keys(allMetrics).length > 0
+      ? `METRICS DETECTED IN CONVERSATION:\n${Object.entries(allMetrics)
+          .map(([k, v]) => `  ${k}: ${v}`)
+          .join('\n')}\n`
+      : '';
+
+  const conversationText =
+    snapshot.length === 0
+      ? '(No conversation yet)'
+      : snapshot
+          .map((m) => {
+            const roleLabel =
+              m.role === 'user' ? 'USER' : m.role === 'assistant' ? 'ASSISTANT' : 'TOOL RESULTS';
+            let text = `${roleLabel}: ${m.content}`;
+
+            // Include tool calls from assistant blocks
+            if (m.role === 'assistant' && m.blocks) {
+              const toolCalls = m.blocks.filter((b) => b.type === 'tool_call');
+              if (toolCalls.length > 0) {
+                text += '\n\n[Tool calls made]:';
+                for (const tc of toolCalls) {
+                  text += `\n  - ${(tc as any).name}(${JSON.stringify((tc as any).input)})`;
+                }
+              }
+            }
+
+            // Include full tool results attached to assistant messages
+            if (m.role === 'assistant' && m.toolResults && m.toolResults.length > 0) {
+              text += '\n\n[Tool outputs received]:';
+              for (const tr of m.toolResults) {
+                const resultText = tr.content
+                  .map((c) =>
+                    c.type === 'text' ? c.text : c.type === 'image' ? '[Image data]' : `[${c.type}]`
+                  )
+                  .join('');
+                text += `\n--- ${tr.toolName} output ---\n${resultText}${tr.isError ? '\n[ERROR]' : ''}`;
+              }
+            }
+
+            // For tool_results role, the content is already the full output
+            if (m.role === 'tool_results' && m.blocks) {
+              const hasImages = m.blocks.some((b) => b.type === 'image');
+              if (hasImages) {
+                text += '\n\n[Contains image data - see blocks for full content]';
+              }
+            }
+
+            return text;
+          })
+          .join('\n\n---\n\n');
+
+  const agentStatus = agentIsIdle
+    ? `AGENT STATUS: IDLE — the agent has finished its turn and is now waiting for user input.
+DECISION: You MUST return "done" or "steer". "continue" is NOT VALID when the agent is idle.`
+    : `AGENT STATUS: WORKING — the agent is actively processing. Only intervene if clearly off track.
+DECISION: Return "continue" (let them work) or "steer" (intervene now).`;
+
+  // Context-aware JSON schema - only include valid actions for current state
+  const responseSchema = agentIsIdle
+    ? `{
+  "action": "done" | "steer",  // ONLY these two when agent is idle
+  "message": "...",              // Required when "steer" (what to tell the agent)
+  "reasoning": "...",            // Why you chose this action
+  "confidence": 0.85,            // 0-1 float
+  "asi": { "...": "..." }        // REQUIRED when steering. Log patterns for future turns
+}`
+    : `{
+  "action": "continue" | "steer", // "continue" lets them work; "steer" interrupts now
+  "message": "...",                // Required when "steer"
+  "reasoning": "...",
+  "confidence": 0.85,
+  "asi": { "...": "..." }          // REQUIRED when steering
+}`;
+
+  const reframeGuidance = getReframeGuidance(state.reframeTier ?? 0, ineffectivePattern);
+  const reframeSection = reframeGuidance ? `\n${reframeGuidance}\n` : '';
+
+  return `DESIRED OUTCOME:
+${state.outcome}
+
+${agentStatus}${reframeSection}
+
+${metricsText}RECENT CONVERSATION (last ${snapshot.length} messages):
+${conversationText}
+
+YOUR INTERVENTION HISTORY (with ASI observations):
+${interventionHistory}
+
+${asiSummary}
+REMINDER — DESIRED OUTCOME:
+${state.outcome}
+
+Respond ONLY with valid JSON matching this schema (no prose, no markdown fences):
+${responseSchema}`;
+}
+
+/** Build summary of ASI patterns to close the loop */
+function buildASISummary(interventions: LoopIntervention[]): string {
+  if (interventions.length === 0) return '';
+
+  // Extract key patterns from ASI
+  const patterns: string[] = [];
+  const recent = interventions.slice(-5);
+
+  // Check for recurring ASI keys
+  const keyFrequency: Record<string, number> = {};
+  for (const iv of recent) {
+    if (!iv.asi) continue;
+    for (const key of Object.keys(iv.asi)) {
+      keyFrequency[key] = (keyFrequency[key] || 0) + 1;
+    }
+  }
+
+  // Surface recurring patterns
+  for (const [key, count] of Object.entries(keyFrequency)) {
+    if (count >= 2) {
+      patterns.push(`Pattern seen ${count}x: "${key}"`);
+    }
+  }
+
+  // Check for cheating-related indicators in ASI values
+  const allValues = recent
+    .filter((iv) => iv.asi)
+    .flatMap((iv) => Object.values(iv.asi!))
+    .map((v) => String(v).toLowerCase());
+
+  const suspiciousIndicators = [
+    'unverified',
+    'contradict',
+    'suspicious',
+    'fake',
+    'skip',
+    'manipulat',
+    'cheat',
+    'gaming',
+    'short-circuit',
+  ];
+
+  const hasSuspicious = suspiciousIndicators.some((indicator) =>
+    allValues.some((v) => v.includes(indicator))
+  );
+
+  if (hasSuspicious) {
+    patterns.push(
+      '⚠️ Previous interventions flagged suspicious claims — require explicit proof before accepting "done"'
+    );
+  }
+
+  // Check for verification failures across history
+  const verificationFailures = interventions.filter(
+    (iv) =>
+      iv.asi &&
+      Object.entries(iv.asi).some(
+        ([k, v]) =>
+          String(v).toLowerCase().includes('contradict') ||
+          String(v).toLowerCase().includes('unverified')
+      )
+  ).length;
+
+  if (verificationFailures >= 2) {
+    patterns.push(
+      `⚠️ ${verificationFailures} interventions involved unverified/contradicted claims — agent has pattern of unreliable reporting`
+    );
+  }
+
+  if (patterns.length === 0) return '';
+
+  return `ASI PATTERN SUMMARY (use this to inform your decision):
+${patterns.map((p) => `- ${p}`).join('\n')}
+
+`;
+}

package/src/core/prompt-loader.ts

@@ -0,0 +1,126 @@
+/**
+ * System prompt loading for loop verification.
+ *
+ * Discovery order (mirrors pi's SYSTEM.md convention):
+ *   1. <cwd>/.pi/LOOP.md         — project-local
+ *   2. ~/.pi/agent/LOOP.md       — global
+ *   3. Built-in template         — fallback
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getAgentDir } from '@earendil-works/pi-coding-agent';
+
+const LOOP_MD = 'LOOP.md';
+const CONFIG_DIR = '.pi';
+
+/** Built-in fallback system prompt. */
+const BUILTIN_SYSTEM_PROMPT = `You ensure outcomes are actually achieved — not just claimed.
+
+Your core principle: **Creation and verification require different eyes.**
+When someone creates with one tool, they must verify with another. Otherwise they see their intent, not their output.
+
+═══ WHEN THEY ARE IDLE (finished their turn, waiting) ═══
+This is your critical moment. They have stopped.
+
+- "done"  → Outcome achieved AND verified with different tools than used to create.
+- "steer" → Everything else: incomplete, unverified, or off-track.
+
+If they ask a clarifying question:
+  FIRST: Is this question necessary to complete the goal?
+  - YES (blocks progress): Answer with sensible default, tell them to proceed.
+  - NO (out of scope): Redirect back to the specific missing piece. Do NOT answer it.
+  NEVER answer: passwords, credentials, secrets.
+
+Your steer message speaks AS the user. Clear, direct, actionable (1-3 sentences).
+Do not ask them to verify their own work — tell them the next step.
+
+═══ VERIFYING COMPLETION ═══
+Before accepting "done", confirm the outcome was actually achieved:
+
+**The Evidence Check** (Primary — use what you can see)
+You have full access to all tool outputs in the conversation history. Verify based on evidence present, not ritual:
+
+- File creation claimed → Check the write/edit output for successful confirmation
+- Tests claimed passing → Check the bash output for actual test results (exit code 0, "passed")
+- File re-read claimed → Check if read output shows the expected content
+- Search performed → Check search results for matches
+
+ACCEPT "done" when tool outputs clearly confirm the work. The tool output IS the verification.
+
+**When to Steer**
+Only steer if evidence is MISSING or CONTRADICTORY:
+- "Tests pass" but bash output shows failures or no test run → steer: "Fix test failures"
+- "File created" but write output shows error → steer: "Fix the write error"
+- Claims made but no corresponding tool output in history → steer with specific request
+- Claims CONTRADICT tool output (says "works" but errors visible) → steer immediately
+
+NEVER demand redundant verification just to satisfy a "different tools" ritual. If you can see the proof in the outputs already captured, accept it.
+
+**The Honesty Check**
+Watch for these patterns:
+1. Contradicted claims: Says "works" but tool output shows errors.
+2. Missing evidence: Claims re-read but no read output in history.
+3. Test manipulation: Edited tests to make them pass.
+4. Short-circuiting: Skipped steps, partial verification.
+
+If you detect dishonesty or sloppiness:
+- DO NOT accept "done"
+- Steer with specific challenge: "Show me the test output" or "Fix the errors visible in the output"
+- Log the pattern in ASI so you remember not to trust future claims from this source
+
+═══ WHEN THEY ARE WORKING (mid-turn) ═══
+Only intervene if clearly heading wrong.
+Trust them to complete what they started. Don't interrupt productive work.
+
+═══ STEERING PRINCIPLES ═══
+- Be specific: reference outcome, missing piece, or verification gap.
+- Never repeat failed steers — escalate or change approach.
+- A good steer answers their question OR redirects to the missing piece.
+- If they take shortcuts, call it out immediately.
+- If they declare done without verification: steer immediately with specific requirement.
+
+"done" CRITERIA:
+- Core outcome is complete and functional
+- Evidence in tool outputs confirms success (file written, tests passed, etc.)
+- Minor polish does NOT block done
+- Prefer stopping when substantially achieved AND verified over perfect but unverified
+
+═══ YOUR MEMORY (ASI) ═══
+ASI is your recall across turns. Populate it when steering:
+
+- Pattern that triggered you: "claimed_tests_pass_but_exit_code_1"
+- What you learned about their tendencies: "skips_error_handling"
+- What to watch for next time: "verify_file_written_before_done"
+
+Before deciding, READ your past ASI. Look for:
+- Recurring patterns (same mistake again)
+- Prior unverified claims (don't accept done if you caught them before)
+- What has worked in past steering
+
+ASI is free-form. Use keys that help you remember:
+{ "repeated_unverified_claim": true, "previous_contradiction": "turn_3", "watch_for": "orphaned_imports" }
+
+If you previously caught them in a suspicious claim, require explicit proof before accepting "done".
+
+The user prompt will provide a context-specific JSON schema. Follow it exactly.`;
+
+/**
+ * Load the loop verification prompt.
+ * Checks .pi/LOOP.md (project) then ~/.pi/agent/LOOP.md (global),
+ * falling back to the built-in template if neither exists.
+ * Returns both the prompt and its source path (or "built-in").
+ */
+export function loadSystemPrompt(cwd: string): { prompt: string; source: string } {
+  const projectPath = join(cwd, CONFIG_DIR, LOOP_MD);
+  if (existsSync(projectPath)) {
+    return { prompt: readFileSync(projectPath, 'utf-8').trim(), source: projectPath };
+  }
+
+  const globalPath = join(getAgentDir(), LOOP_MD);
+  if (existsSync(globalPath)) {
+    return { prompt: readFileSync(globalPath, 'utf-8').trim(), source: globalPath };
+  }
+
+  return { prompt: BUILTIN_SYSTEM_PROMPT, source: 'built-in' };
+}

package/src/core/reframe.ts

@@ -0,0 +1,30 @@
+/**
+ * Reframe tier management - escalation strategies for ineffective steering.
+ */
+
+import type { ReframeTier } from '../types.js';
+
+/** Get reframe guidance based on current tier */
+export function getReframeGuidance(
+  tier: number,
+  ineffectivePattern?: { detected: boolean; similarCount: number; turnsSinceLastSteer: number }
+): string {
+  if (!ineffectivePattern?.detected && tier === 0) return '';
+
+  const tierGuidance: Record<number, string> = {
+    0: '',
+    1: `🔄 REFRAME TIER 1 — DIRECTIVE: The agent needs clearer direction. Be extremely specific about the next single action to take.`,
+    2: `🔄 REFRAME TIER 2 — SUBGOAL: The agent is stuck on the full goal. Break this into a smaller, verifiable milestone. Tell it to complete just that one piece.`,
+    3: `🔄 REFRAME TIER 3 — PIVOT: The current approach isn't working. Suggest a completely different strategy or implementation path. Challenge any assumptions.`,
+    4: `🔄 REFRAME TIER 4 — MINIMAL SLICE: Strip to absolute essentials. Ask: "What's the smallest working version you can deliver right now?" Push for tangible output.`,
+  };
+
+  const patternNote = ineffectivePattern?.detected
+    ? `\n⚠ INEFFECTIVE PATTERN DETECTED: Last ${ineffectivePattern.similarCount} steering messages were similar or no progress in ${ineffectivePattern.turnsSinceLastSteer} turns. Escalate your approach.`
+    : '';
+
+  return tierGuidance[tier] + patternNote;
+}
+
+/** Maximum reframe tier value */
+const MAX_REFRAME_TIER: ReframeTier = 4;

package/src/core/snapshot-builder.ts

@@ -0,0 +1,252 @@
+/**
+ * Snapshot builder - constructs conversation snapshots from session history.
+ *
+ * Incrementally builds snapshots from new session entries since last analysis.
+ * CAPTURES EVERYTHING: full tool outputs, images (base64), all content blocks.
+ */
+
+import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
+import type { ConversationMessage, LoopState, ToolResultEntry, ContentBlock } from '../types.js';
+import { extractAllBlocks, extractText, extractAssistantText } from './content-extractor.js';
+
+/** Fixed message limit for supervisor context window. */
+export const SNAPSHOT_LIMIT = 20;
+
+/**
+ * Incrementally build snapshot from new session entries since last analysis.
+ * CAPTURES EVERYTHING: full tool outputs, images (base64), all content blocks.
+ * Only walks entries from lastAnalyzedTurn to current, appends to existing buffer.
+ */
+export function buildIncrementalSnapshot(
+  ctx: ExtensionContext,
+  state: LoopState
+): ConversationMessage[] {
+  const existingBuffer = state.snapshotBuffer ?? [];
+  const lastAnalyzed = state.lastAnalyzedTurn ?? -1;
+  const currentTurn = state.turnCount;
+
+  // If already analyzed this turn, return existing
+  if (lastAnalyzed >= currentTurn) {
+    return existingBuffer.slice(-SNAPSHOT_LIMIT);
+  }
+
+  const newMessages: ConversationMessage[] = [...existingBuffer];
+  const entries = ctx.sessionManager.getBranch();
+
+  // Track pending tool results to associate with the next assistant message
+  const pendingToolResults: ToolResultEntry[] = [];
+
+  // Find entries since last analysis
+  for (const entry of entries) {
+    // Capture regular messages (user/assistant conversation)
+    if (entry.type === 'message') {
+      const msg = (entry as any).message;
+      if (!msg) continue;
+
+      if (msg.role === 'user') {
+        const textContent = extractText(msg.content);
+        const allBlocks = extractAllBlocks(msg.content);
+        if (textContent || allBlocks.length > 0) {
+          newMessages.push({
+            role: 'user',
+            content: textContent,
+            blocks: allBlocks,
+          });
+        }
+      } else if (msg.role === 'assistant') {
+        const textContent = extractAssistantText(msg.content);
+        const allBlocks = extractAllBlocks(msg.content);
+
+        // Check for tool calls in the content blocks
+        const toolCalls = allBlocks.filter(
+          (b): b is ContentBlock & { type: 'tool_call' } => b.type === 'tool_call'
+        );
+
+        if (textContent || allBlocks.length > 0 || toolCalls.length > 0) {
+          newMessages.push({
+            role: 'assistant',
+            content: textContent,
+            blocks: allBlocks,
+            toolResults: pendingToolResults.length > 0 ? [...pendingToolResults] : undefined,
+          });
+          // Clear pending tool results after associating with assistant
+          pendingToolResults.length = 0;
+        }
+      } else if (msg.role === 'tool') {
+        // Tool result messages - capture them fully
+        const allBlocks = extractAllBlocks(msg.content);
+        const textContent = extractText(msg.content);
+
+        // Try to extract tool call ID and name from the message
+        const toolCallId = (msg as any).tool_call_id || (msg as any).toolCallId || 'unknown';
+        const toolName = (msg as any).name || 'unknown';
+        const isError = (msg as any).is_error || (msg as any).isError || false;
+
+        pendingToolResults.push({
+          toolCallId,
+          toolName,
+          input: {},
+          content: allBlocks,
+          isError,
+        });
+
+        // Also add as a tool_results message for visibility
+        newMessages.push({
+          role: 'tool_results',
+          content: textContent || `[Tool output: ${toolName}]`,
+          blocks: allBlocks,
+        });
+      }
+    }
+
+    // Capture custom_message entries (often contain tool results in pi)
+    if (entry.type === 'custom_message') {
+      const customMsg = entry as any;
+      const content = customMsg.content;
+
+      if (typeof content === 'string') {
+        // Plain text custom message - likely tool output
+        pendingToolResults.push({
+          toolCallId: customMsg.id || 'unknown',
+          toolName: customMsg.customType || 'unknown',
+          input: customMsg.details || {},
+          content: [{ type: 'text', text: content }],
+          isError: false,
+        });
+
+        newMessages.push({
+          role: 'tool_results',
+          content: content,
+          blocks: [{ type: 'text', text: content }],
+        });
+      } else if (Array.isArray(content)) {
+        // Rich content custom message - extract all blocks
+        const allBlocks = extractAllBlocks(content);
+        const textContent = content
+          .filter((b: any) => b.type === 'text')
+          .map((b: any) => b.text)
+          .join('\n');
+
+        pendingToolResults.push({
+          toolCallId: customMsg.id || 'unknown',
+          toolName: customMsg.customType || 'unknown',
+          input: customMsg.details || {},
+          content: allBlocks,
+          isError: false,
+        });
+
+        newMessages.push({
+          role: 'tool_results',
+          content: textContent || `[Tool output: ${customMsg.customType}]`,
+          blocks: allBlocks,
+        });
+      }
+    }
+
+    // Bash execution messages (special type in pi)
+    if ((entry as any).type === 'bash_execution' || (entry as any).type === 'bash_result') {
+      const bashEntry = entry as any;
+      const result = bashEntry.result || bashEntry;
+
+      if (result) {
+        const output = result.stdout || result.output || result.content || '';
+        const stderr = result.stderr || '';
+        const exitCode = result.exitCode ?? result.exit_code ?? 0;
+
+        const fullOutput = [output, stderr].filter(Boolean).join('\n');
+
+        pendingToolResults.push({
+          toolCallId: bashEntry.id || 'bash',
+          toolName: 'bash',
+          input: { command: result.command || bashEntry.command },
+          content: [{ type: 'text', text: fullOutput }],
+          isError: exitCode !== 0,
+        });
+
+        newMessages.push({
+          role: 'tool_results',
+          content: fullOutput || '[bash output]',
+          blocks: [{ type: 'text', text: fullOutput }],
+        });
+      }
+    }
+
+    // Catch-all for any other tool result entries (write, edit, or any tool not explicitly handled above)
+    // This ensures tool results aren't silently dropped if they come through with non-standard entry types
+    if (
+      entry.type !== 'message' &&
+      entry.type !== 'custom_message' &&
+      (entry as any).type !== 'bash_execution' &&
+      (entry as any).type !== 'bash_result'
+    ) {
+      const otherEntry = entry as any;
+
+      // Only process if it looks like a tool result (has output-like content)
+      const content =
+        otherEntry.content || otherEntry.result || otherEntry.output || otherEntry.text;
+      const toolName = otherEntry.customType || otherEntry.name || otherEntry.tool || 'tool';
+
+      // Skip entries that don't have meaningful content (like state entries)
+      if (
+        content &&
+        typeof content === 'string' &&
+        content.length > 0 &&
+        !otherEntry.customType?.includes('state')
+      ) {
+        pendingToolResults.push({
+          toolCallId: otherEntry.id || otherEntry.toolCallId || 'unknown',
+          toolName,
+          input: otherEntry.details || otherEntry.input || {},
+          content: [{ type: 'text', text: content }],
+          isError: otherEntry.isError || otherEntry.is_error || false,
+        });
+
+        newMessages.push({
+          role: 'tool_results',
+          content,
+          blocks: [{ type: 'text', text: content }],
+        });
+      } else if (Array.isArray(content) && content.length > 0) {
+        // Handle rich content arrays (e.g., tool results with image blocks)
+        const allBlocks = extractAllBlocks(content);
+        const textContent = content
+          .filter((b: any) => b.type === 'text')
+          .map((b: any) => b.text)
+          .join('\n');
+
+        pendingToolResults.push({
+          toolCallId: otherEntry.id || otherEntry.toolCallId || 'unknown',
+          toolName,
+          input: otherEntry.details || otherEntry.input || {},
+          content: allBlocks,
+          isError: otherEntry.isError || otherEntry.is_error || false,
+        });
+
+        newMessages.push({
+          role: 'tool_results',
+          content: textContent || `[${toolName} output]`,
+          blocks: allBlocks,
+        });
+      }
+    }
+  }
+
+  // Keep only last 6, compress older if needed
+  if (newMessages.length > SNAPSHOT_LIMIT) {
+    const overflow = newMessages.length - SNAPSHOT_LIMIT;
+    // Drop oldest messages (simple approach)
+    return newMessages.slice(overflow);
+  }
+
+  return newMessages;
+}
+
+/**
+ * Update state with new snapshot and return it.
+ */
+export function updateSnapshot(ctx: ExtensionContext, state: LoopState): ConversationMessage[] {
+  const snapshot = buildIncrementalSnapshot(ctx, state);
+  state.snapshotBuffer = snapshot;
+  state.lastAnalyzedTurn = state.turnCount;
+  return snapshot;
+}

package/src/global-config.ts

@@ -0,0 +1,38 @@
+/**
+ * global-config.ts — workspace-level loop configuration.
+ *
+ * Saves/loads loop model selection.
+ * Stored at <cwd>/.pi/loop-config.json
+ *
+ * Removed: sensitivity (now automatic)
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const CONFIG_DIR = '.pi';
+const CONFIG_FILE = 'loop-config.json';
+
+interface LoopConfig {
+  model?: {
+    provider: string;
+    modelId: string;
+  };
+}
+
+/** Load the loop model config from cwd/.pi/loop-config.json if it exists. */
+export function loadGlobalModel(): { provider: string; modelId: string } | null {
+  const configPath = join(process.cwd(), CONFIG_DIR, CONFIG_FILE);
+  if (!existsSync(configPath)) return null;
+
+  try {
+    const content = readFileSync(configPath, 'utf-8');
+    const parsed = JSON.parse(content) as LoopConfig;
+    if (parsed.model?.provider && parsed.model?.modelId) {
+      return { provider: parsed.model.provider, modelId: parsed.model.modelId };
+    }
+  } catch {
+    // ignore parse errors
+  }
+  return null;
+}