opencode-forge 0.1.5

package/dist/tui.js

@@ -0,0 +1,2061 @@
+// src/tui.tsx
+import { insert as _$insert } from "@opentui/solid";
+import { use as _$use } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { effect as _$effect } from "@opentui/solid";
+import { memo as _$memo } from "@opentui/solid";
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { createEffect, createMemo, createSignal, onCleanup, Show, For } from "solid-js";
+import { SyntaxStyle } from "@opentui/core";
+import { readFileSync, existsSync as existsSync6, writeFileSync } from "fs";
+import { homedir as homedir2, platform as platform2 } from "os";
+import { join as join6 } from "path";
+import { execSync } from "child_process";
+import { Database as Database5 } from "bun:sqlite";
+
+// src/version.ts
+var VERSION = "0.1.5";
+
+// src/storage/database.ts
+import { mkdirSync, existsSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+function resolveDataDir() {
+  const defaultBase = join(homedir(), platform() === "win32" ? "AppData" : ".local", "share");
+  const xdgDataHome = process.env["XDG_DATA_HOME"] || defaultBase;
+  const forgeDir = join(xdgDataHome, "opencode", "forge");
+  const legacyGraphDir = join(xdgDataHome, "opencode", "graph");
+  return existsSync(legacyGraphDir) && !existsSync(forgeDir) ? legacyGraphDir : forgeDir;
+}
+// src/storage/kv-queries.ts
+function mapRow(row) {
+  return {
+    projectId: row.project_id,
+    key: row.key,
+    data: row.data,
+    expiresAt: row.expires_at,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+var CLEANUP_INTERVAL_MS = 300000;
+var lastCleanupAt = 0;
+function createKvQuery(db) {
+  const getStmt = db.prepare(`SELECT project_id, key, data, expires_at, created_at, updated_at
+     FROM project_kv
+     WHERE project_id = ? AND key = ? AND expires_at > ?`);
+  const setStmt = db.prepare(`INSERT INTO project_kv (project_id, key, data, expires_at, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT(project_id, key) DO UPDATE SET
+       data = excluded.data,
+       expires_at = excluded.expires_at,
+       updated_at = excluded.updated_at`);
+  const deleteStmt = db.prepare(`DELETE FROM project_kv WHERE project_id = ? AND key = ?`);
+  const listStmt = db.prepare(`SELECT project_id, key, data, expires_at, created_at, updated_at
+     FROM project_kv
+     WHERE project_id = ? AND expires_at > ?
+     ORDER BY updated_at DESC`);
+  const listByPrefixStmt = db.prepare(`SELECT project_id, key, data, expires_at, created_at, updated_at
+     FROM project_kv
+     WHERE project_id = ? AND key LIKE ? AND expires_at > ?
+     ORDER BY updated_at DESC`);
+  const deleteExpiredStmt = db.prepare(`DELETE FROM project_kv WHERE expires_at < ?`);
+  return {
+    get(projectId, key) {
+      const row = getStmt.get(projectId, key, Date.now());
+      return row ? mapRow(row) : undefined;
+    },
+    set(projectId, key, data, expiresAt) {
+      const now = Date.now();
+      setStmt.run(projectId, key, data, expiresAt, now, now);
+      if (now - lastCleanupAt > CLEANUP_INTERVAL_MS) {
+        lastCleanupAt = now;
+        setImmediate(() => {
+          try {
+            deleteExpiredStmt.run(now);
+          } catch {}
+        });
+      }
+    },
+    delete(projectId, key) {
+      deleteStmt.run(projectId, key);
+    },
+    list(projectId) {
+      const rows = listStmt.all(projectId, Date.now());
+      return rows.map(mapRow);
+    },
+    listByPrefix(projectId, prefix) {
+      const rows = listByPrefixStmt.all(projectId, `${prefix}%`, Date.now());
+      return rows.map(mapRow);
+    },
+    deleteExpired() {
+      const result = deleteExpiredStmt.run(Date.now());
+      return result.changes;
+    }
+  };
+}
+// src/utils/session-stats.ts
+function extractActivity(parts) {
+  const toolCalls = [];
+  const textLines = [];
+  const toolLines = [];
+  const subtaskLines = [];
+  const reasoningLines = [];
+  for (const p of parts) {
+    if (p.type === "text" && typeof p.text === "string" && p.text.trim()) {
+      textLines.push(p.text.trim());
+    } else if (p.type === "tool" && p.tool && p.state) {
+      const s = p.state;
+      const name = p.tool;
+      const status = s.status;
+      if (status === "completed") {
+        const title = s.title ?? name;
+        toolCalls.push({ tool: name, title, status: "completed" });
+        toolLines.push(`[done] ${name}: ${title}`);
+      } else if (status === "running") {
+        const title = s.title ?? name;
+        toolCalls.push({ tool: name, title, status: "running" });
+        toolLines.push(`[running] ${name}: ${title}`);
+      } else if (status === "error") {
+        const msg = s.error ?? "error";
+        toolCalls.push({ tool: name, title: msg, status: "error" });
+        toolLines.push(`[error] ${name}: ${msg}`);
+      } else if (status === "pending") {
+        toolCalls.push({ tool: name, title: name, status: "pending" });
+        toolLines.push(`[pending] ${name}`);
+      }
+    } else if (p.type === "subtask" && p.description) {
+      const agentLabel = p.agent ? `${p.agent}: ` : "";
+      subtaskLines.push(`-> ${agentLabel}${p.description}`);
+    } else if (p.type === "reasoning" && typeof p.text === "string" && p.text.trim()) {
+      reasoningLines.push(p.text.trim());
+    }
+  }
+  let summary = "";
+  if (textLines.length > 0) {
+    summary = textLines.join(`
+`);
+  } else if (toolLines.length > 0) {
+    summary = toolLines.join(`
+`);
+  } else if (subtaskLines.length > 0) {
+    summary = subtaskLines.join(`
+`);
+  } else if (reasoningLines.length > 0) {
+    summary = reasoningLines.join(`
+`);
+  }
+  if (!summary && toolCalls.length === 0)
+    return null;
+  return { summary, toolCalls };
+}
+async function fetchSessionStats(api, sessionId, directory) {
+  if (!directory || !sessionId) {
+    return null;
+  }
+  try {
+    const messagesResult = await api.client.session.messages({
+      sessionID: sessionId,
+      directory
+    });
+    const messages = messagesResult.data ?? [];
+    const assistantMessages = messages.filter((m) => m.info.role === "assistant");
+    let lastActivity = null;
+    for (let i = assistantMessages.length - 1;i >= Math.max(0, assistantMessages.length - 3); i--) {
+      const result = extractActivity(assistantMessages[i].parts);
+      if (result) {
+        lastActivity = result;
+        break;
+      }
+    }
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalReasoningTokens = 0;
+    let totalCacheRead = 0;
+    let totalCacheWrite = 0;
+    let totalCost = 0;
+    for (const msg of messages) {
+      totalCost += msg.info.cost ?? 0;
+      const tokens = msg.info.tokens;
+      if (tokens) {
+        totalInputTokens += tokens.input ?? 0;
+        totalOutputTokens += tokens.output ?? 0;
+        totalReasoningTokens += tokens.reasoning ?? 0;
+        totalCacheRead += tokens.cache?.read ?? 0;
+        totalCacheWrite += tokens.cache?.write ?? 0;
+      }
+    }
+    const sessionResult = await api.client.session.get({
+      sessionID: sessionId,
+      directory
+    });
+    const session = sessionResult.data;
+    const fileChanges = session?.summary ? {
+      additions: session.summary.additions,
+      deletions: session.summary.deletions,
+      files: session.summary.files
+    } : null;
+    const timing = session?.time?.created && session?.time?.updated ? {
+      created: session.time.created,
+      updated: session.time.updated,
+      durationMs: new Date(session.time.updated).getTime() - new Date(session.time.created).getTime()
+    } : null;
+    return {
+      tokens: {
+        input: totalInputTokens,
+        output: totalOutputTokens,
+        reasoning: totalReasoningTokens,
+        cacheRead: totalCacheRead,
+        cacheWrite: totalCacheWrite,
+        total: totalInputTokens + totalOutputTokens + totalReasoningTokens + totalCacheRead + totalCacheWrite
+      },
+      cost: totalCost,
+      messages: {
+        total: messages.length,
+        assistant: assistantMessages.length
+      },
+      fileChanges,
+      timing,
+      lastActivity
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/logger.ts
+var MAX_LOG_FILE_SIZE = 10 * 1024 * 1024;
+function slugify(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-").substring(0, 50);
+}
+
+// src/utils/plan-execution.ts
+var PLAN_EXECUTION_LABELS = [
+  "New session",
+  "Execute here",
+  "Loop (worktree)",
+  "Loop"
+];
+function extractPlanTitle(planContent) {
+  const headingMatch = planContent.match(/^#+\s+(.+)$/m);
+  if (headingMatch?.[1]) {
+    const title = headingMatch[1].trim();
+    return title.length > 60 ? `${title.substring(0, 57)}...` : title;
+  }
+  const firstLine = planContent.split(`
+`)[0]?.trim();
+  if (firstLine) {
+    return firstLine.length > 60 ? `${firstLine.substring(0, 57)}...` : firstLine;
+  }
+  return "Implementation Plan";
+}
+function extractLoopName(planContent) {
+  const loopNameMatch = planContent.match(/^(?:\s*(?:-\s*)?)?(?:\*\*)?Loop Name(?:\*\*)?:\s*(.+)$/m);
+  if (loopNameMatch?.[1]) {
+    const name = loopNameMatch[1].trim();
+    return name.length > 60 ? name.substring(0, 60) : name;
+  }
+  const title = extractPlanTitle(planContent);
+  return title;
+}
+function extractLoopNames(planContent) {
+  const displayName = extractLoopName(planContent);
+  const executionName = sanitizeLoopName(displayName);
+  return { displayName, executionName };
+}
+function sanitizeLoopName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").substring(0, 60) || "loop";
+}
+function normalizeModeLabel(label) {
+  return label.toLowerCase();
+}
+function matchExecutionLabel(input) {
+  const normalized = normalizeModeLabel(input);
+  for (const label of PLAN_EXECUTION_LABELS) {
+    if (normalized === label.toLowerCase() || normalized.startsWith(label.toLowerCase())) {
+      return label;
+    }
+  }
+  return null;
+}
+
+// src/utils/loop-launch.ts
+import { Database } from "bun:sqlite";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/constants/loop.ts
+var LOOP_PERMISSION_RULESET = [
+  { permission: "*", pattern: "*", action: "allow" },
+  { permission: "external_directory", pattern: "*", action: "deny" },
+  { permission: "bash", pattern: "git push *", action: "deny" }
+];
+// src/services/loop.ts
+var DEFAULT_COMPLETION_SIGNAL = "ALL_PHASES_COMPLETE";
+function buildCompletionSignalInstructions(signal) {
+  return `
+
+---
+
+**IMPORTANT - Completion Signal:** When you have completed ALL phases of this plan successfully, you MUST output the following phrase exactly: ${signal}
+
+Before outputting the completion signal, you MUST:
+1. Verify each phase's acceptance criteria are met
+2. Run all verification commands listed in the plan and confirm they pass
+3. If tests were required, confirm they exist AND pass
+
+Do NOT output this phrase until every phase is truly complete and all verification steps pass. The loop will continue until this signal is detected.`;
+}
+function generateUniqueName(baseName, existingNames) {
+  const maxLength = 25;
+  const truncated = baseName.length > maxLength ? baseName.substring(0, maxLength) : baseName;
+  if (!existingNames.includes(truncated)) {
+    return truncated;
+  }
+  let counter = 1;
+  let candidate = `${truncated}-${counter}`;
+  while (existingNames.includes(candidate)) {
+    counter++;
+    candidate = `${truncated}-${counter}`;
+  }
+  return candidate;
+}
+
+// src/utils/loop-launch.ts
+async function launchFreshLoop(options) {
+  const { planText, title, directory, projectId, isWorktree, api } = options;
+  const { displayName, executionName } = extractLoopNames(planText);
+  const dbPath = options.dbPath ?? join2(resolveDataDir(), "graph.db");
+  const existingNames = [];
+  if (existsSync2(dbPath)) {
+    let db = null;
+    try {
+      db = new Database(dbPath, { readonly: true });
+      const stmt = db.prepare("SELECT data FROM project_kv WHERE project_id = ? AND key LIKE ? AND expires_at > ?");
+      const rows = stmt.all(projectId, "loop:%", Date.now());
+      for (const row of rows) {
+        try {
+          const state = JSON.parse(row.data);
+          if (state?.worktreeName) {
+            existingNames.push(state.worktreeName);
+          }
+        } catch {}
+      }
+    } catch {} finally {
+      try {
+        db?.close();
+      } catch {}
+    }
+  }
+  const uniqueWorktreeName = generateUniqueName(executionName, existingNames);
+  let sessionId;
+  let sessionDirectory;
+  let worktreeBranch;
+  if (isWorktree) {
+    const worktreeResult = await api.client.worktree.create({
+      worktreeCreateInput: { name: uniqueWorktreeName }
+    });
+    if (worktreeResult.error || !worktreeResult.data) {
+      return null;
+    }
+    sessionDirectory = worktreeResult.data.directory;
+    worktreeBranch = worktreeResult.data.branch;
+    const createResult = await api.client.session.create({
+      title: `Loop: ${title}`,
+      directory: sessionDirectory
+    });
+    if (createResult.error || !createResult.data) {
+      return null;
+    }
+    sessionId = createResult.data.id;
+  } else {
+    const createResult = await api.client.session.create({
+      title: `Loop: ${title}`,
+      directory
+    });
+    if (createResult.error || !createResult.data) {
+      return null;
+    }
+    sessionId = createResult.data.id;
+    sessionDirectory = directory;
+  }
+  const dbExists = existsSync2(dbPath);
+  if (dbExists) {
+    let db = null;
+    try {
+      db = new Database(dbPath);
+      const queries = createKvQuery(db);
+      const now = Date.now();
+      const TTL_MS = 7 * 24 * 60 * 60 * 1000;
+      queries.set(projectId, `plan:${uniqueWorktreeName}`, JSON.stringify(planText), now + TTL_MS);
+      const loopState = {
+        active: true,
+        sessionId,
+        worktreeName: uniqueWorktreeName,
+        worktreeDir: sessionDirectory,
+        worktreeBranch,
+        iteration: 1,
+        maxIterations: 0,
+        completionSignal: DEFAULT_COMPLETION_SIGNAL,
+        startedAt: new Date().toISOString(),
+        prompt: planText,
+        phase: "coding",
+        audit: true,
+        errorCount: 0,
+        auditCount: 0,
+        worktree: isWorktree
+      };
+      queries.set(projectId, `loop:${uniqueWorktreeName}`, JSON.stringify(loopState), now + TTL_MS);
+      queries.set(projectId, `loop-session:${sessionId}`, JSON.stringify(uniqueWorktreeName), now + TTL_MS);
+    } catch {} finally {
+      try {
+        db?.close();
+      } catch {}
+    }
+  }
+  let promptText = planText;
+  if (DEFAULT_COMPLETION_SIGNAL) {
+    promptText += buildCompletionSignalInstructions(DEFAULT_COMPLETION_SIGNAL);
+  }
+  try {
+    await api.client.session.promptAsync({
+      sessionID: sessionId,
+      directory: sessionDirectory,
+      parts: [{ type: "text", text: promptText }],
+      agent: "code"
+    });
+  } catch {
+    return null;
+  }
+  return {
+    sessionId,
+    loopName: displayName,
+    worktreeName: uniqueWorktreeName,
+    isWorktree,
+    worktreeDir: sessionDirectory,
+    worktreeBranch
+  };
+}
+
+// src/utils/tui-plan-store.ts
+import { Database as Database2 } from "bun:sqlite";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+function getDbPath() {
+  return join3(resolveDataDir(), "graph.db");
+}
+function resolvePlanKey(projectId, sessionID, dbPathOverride) {
+  const dbPath = dbPathOverride || getDbPath();
+  if (!existsSync3(dbPath)) {
+    return `plan:${sessionID}`;
+  }
+  let db = null;
+  try {
+    db = new Database2(dbPath, { readonly: true });
+    const now = Date.now();
+    const mappingRow = db.prepare("SELECT data FROM project_kv WHERE project_id = ? AND key = ? AND expires_at > ?").get(projectId, `loop-session:${sessionID}`, now);
+    if (mappingRow) {
+      try {
+        const worktreeName = JSON.parse(mappingRow.data);
+        if (typeof worktreeName === "string" && worktreeName) {
+          return `plan:${worktreeName}`;
+        }
+      } catch {}
+    }
+  } catch {} finally {
+    try {
+      db?.close();
+    } catch {}
+  }
+  return `plan:${sessionID}`;
+}
+function readPlan(projectId, sessionID, dbPathOverride) {
+  const dbPath = dbPathOverride || getDbPath();
+  if (!existsSync3(dbPath))
+    return null;
+  let db = null;
+  try {
+    db = new Database2(dbPath, { readonly: true });
+    const now = Date.now();
+    const planKey = resolvePlanKey(projectId, sessionID, dbPath);
+    const row = db.prepare("SELECT data FROM project_kv WHERE project_id = ? AND key = ? AND expires_at > ?").get(projectId, planKey, now);
+    if (!row)
+      return null;
+    const data = row.data;
+    if (typeof data === "string" && data.startsWith('"')) {
+      try {
+        return JSON.parse(data);
+      } catch {
+        return data;
+      }
+    }
+    return data;
+  } catch {
+    return null;
+  } finally {
+    try {
+      db?.close();
+    } catch {}
+  }
+}
+function writePlan(projectId, sessionID, content, dbPathOverride) {
+  const dbPath = dbPathOverride || getDbPath();
+  if (!existsSync3(dbPath))
+    return false;
+  let db = null;
+  try {
+    db = new Database2(dbPath);
+    const now = Date.now();
+    const ttl = 7 * 24 * 60 * 60 * 1000;
+    const planKey = resolvePlanKey(projectId, sessionID, dbPath);
+    db.prepare("INSERT OR REPLACE INTO project_kv (project_id, key, data, expires_at, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)").run(projectId, planKey, JSON.stringify(content), now + ttl, now, now);
+    return true;
+  } catch {
+    return false;
+  } finally {
+    try {
+      db?.close();
+    } catch {}
+  }
+}
+function deletePlan(projectId, sessionID, dbPathOverride) {
+  const dbPath = dbPathOverride || getDbPath();
+  if (!existsSync3(dbPath))
+    return false;
+  let db = null;
+  try {
+    db = new Database2(dbPath);
+    const planKey = resolvePlanKey(projectId, sessionID, dbPath);
+    const result = db.prepare("DELETE FROM project_kv WHERE project_id = ? AND key = ?").run(projectId, planKey);
+    return (result.changes || 0) > 0;
+  } catch {
+    return false;
+  } finally {
+    try {
+      db?.close();
+    } catch {}
+  }
+}
+
+// src/utils/tui-graph-status.ts
+import { Database as Database3 } from "bun:sqlite";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+function getDbPath2() {
+  return join4(resolveDataDir(), "graph.db");
+}
+function readGraphStatus(projectId, dbPathOverride) {
+  const dbPath = dbPathOverride || getDbPath2();
+  if (!existsSync4(dbPath))
+    return null;
+  let db = null;
+  try {
+    db = new Database3(dbPath, { readonly: true });
+    const now = Date.now();
+    const row = db.prepare("SELECT data FROM project_kv WHERE project_id = ? AND key = ? AND expires_at > ?").get(projectId, "graph:status", now);
+    if (!row)
+      return null;
+    try {
+      return JSON.parse(row.data);
+    } catch {
+      return null;
+    }
+  } catch {
+    return null;
+  } finally {
+    try {
+      db?.close();
+    } catch {}
+  }
+}
+function formatGraphStatus(status) {
+  if (!status) {
+    return { text: "unavailable", color: "textMuted" };
+  }
+  switch (status.state) {
+    case "ready":
+      if (status.stats) {
+        return {
+          text: `ready · ${status.stats.files} files`,
+          color: "success"
+        };
+      }
+      return {
+        text: "ready",
+        color: "success"
+      };
+    case "indexing":
+      return { text: "indexing", color: "warning" };
+    case "initializing":
+      return { text: "initializing", color: "info" };
+    case "error":
+      return { text: "error", color: "error" };
+    case "unavailable":
+    default:
+      return { text: "unavailable", color: "textMuted" };
+  }
+}
+
+// src/utils/tui-refresh-helpers.ts
+import { Database as Database4 } from "bun:sqlite";
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+function getDbPath3() {
+  return join5(resolveDataDir(), "graph.db");
+}
+function readLoopStates(projectId, dbPathOverride) {
+  const dbPath = dbPathOverride || getDbPath3();
+  if (!existsSync5(dbPath))
+    return [];
+  let db = null;
+  try {
+    db = new Database4(dbPath, { readonly: true });
+    const now = Date.now();
+    const stmt = db.prepare("SELECT key, data FROM project_kv WHERE project_id = ? AND key LIKE ? AND expires_at > ?");
+    const rows = stmt.all(projectId, "loop:%", now);
+    const loops = [];
+    for (const row of rows) {
+      try {
+        const state = JSON.parse(row.data);
+        if (!state.worktreeName || !state.sessionId)
+          continue;
+        loops.push({
+          name: state.worktreeName,
+          phase: state.phase ?? "coding",
+          iteration: state.iteration ?? 0,
+          maxIterations: state.maxIterations ?? 0,
+          sessionId: state.sessionId,
+          active: state.active ?? false,
+          startedAt: state.startedAt,
+          completedAt: state.completedAt,
+          terminationReason: state.terminationReason,
+          worktreeBranch: state.worktreeBranch,
+          worktree: state.worktree ?? false,
+          worktreeDir: state.worktreeDir
+        });
+      } catch {}
+    }
+    return loops;
+  } catch {
+    return [];
+  } finally {
+    try {
+      db?.close();
+    } catch {}
+  }
+}
+function readLoopByName(projectId, loopName, dbPathOverride) {
+  const dbPath = dbPathOverride || getDbPath3();
+  if (!existsSync5(dbPath))
+    return null;
+  let db = null;
+  try {
+    db = new Database4(dbPath, { readonly: true });
+    const now = Date.now();
+    const key = `loop:${loopName}`;
+    const row = db.prepare("SELECT data FROM project_kv WHERE project_id = ? AND key = ? AND expires_at > ?").get(projectId, key, now);
+    if (!row)
+      return null;
+    const state = JSON.parse(row.data);
+    if (!state.worktreeName || !state.sessionId)
+      return null;
+    return {
+      name: state.worktreeName,
+      phase: state.phase ?? "coding",
+      iteration: state.iteration ?? 0,
+      maxIterations: state.maxIterations ?? 0,
+      sessionId: state.sessionId,
+      active: state.active ?? false,
+      startedAt: state.startedAt,
+      completedAt: state.completedAt,
+      terminationReason: state.terminationReason,
+      worktreeBranch: state.worktreeBranch,
+      worktree: state.worktree ?? false,
+      worktreeDir: state.worktreeDir
+    };
+  } catch {
+    return null;
+  } finally {
+    try {
+      db?.close();
+    } catch {}
+  }
+}
+
+// src/tui.tsx
+function loadTuiConfig() {
+  try {
+    const defaultBase = join6(homedir2(), platform2() === "win32" ? "AppData" : ".config");
+    const configDir = process.env["XDG_CONFIG_HOME"] || defaultBase;
+    const configRoot = join6(configDir, "opencode");
+    const configPath = existsSync6(join6(configRoot, "forge-config.jsonc")) ? join6(configRoot, "forge-config.jsonc") : existsSync6(join6(configRoot, "memory-config.jsonc")) ? join6(configRoot, "memory-config.jsonc") : join6(configRoot, "graph-config.jsonc");
+    const raw = readFileSync(configPath, "utf-8");
+    const stripped = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    const parsed = JSON.parse(stripped);
+    return parsed?.tui;
+  } catch {
+    return;
+  }
+}
+function resolveProjectId(directory) {
+  const cachePath = join6(directory, ".git", "opencode");
+  if (existsSync6(cachePath)) {
+    try {
+      const id = readFileSync(cachePath, "utf-8").trim();
+      if (id)
+        return id;
+    } catch {}
+  }
+  try {
+    const output = execSync("git rev-list --max-parents=0 --all", {
+      cwd: directory,
+      encoding: "utf-8"
+    }).trim();
+    const commits = output.split(`
+`).filter(Boolean).sort();
+    if (commits[0])
+      return commits[0];
+  } catch {}
+  return null;
+}
+function cancelLoop(projectId, loopName) {
+  const dbPath = join6(resolveDataDir(), "graph.db");
+  if (!existsSync6(dbPath))
+    return null;
+  let db = null;
+  try {
+    db = new Database5(dbPath);
+    const key = `loop:${loopName}`;
+    const now = Date.now();
+    const row = db.prepare("SELECT data, project_id FROM project_kv WHERE project_id = ? AND key = ? AND expires_at > ?").get(projectId, key, now);
+    if (!row)
+      return null;
+    const state = JSON.parse(row.data);
+    if (!state.active)
+      return null;
+    const updatedState = {
+      ...state,
+      active: false,
+      completedAt: new Date().toISOString(),
+      terminationReason: "cancelled"
+    };
+    db.prepare("UPDATE project_kv SET data = ?, updated_at = ? WHERE project_id = ? AND key = ?").run(JSON.stringify(updatedState), now, projectId, key);
+    return state.sessionId ?? null;
+  } catch {
+    return null;
+  } finally {
+    try {
+      db?.close();
+    } catch {}
+  }
+}
+async function restartLoop(projectId, loopName, api) {
+  const dbPath = join6(resolveDataDir(), "graph.db");
+  if (!existsSync6(dbPath))
+    return null;
+  let db = null;
+  try {
+    db = new Database5(dbPath);
+    const key = `loop:${loopName}`;
+    const now = Date.now();
+    const row = db.prepare("SELECT data, project_id FROM project_kv WHERE project_id = ? AND key = ? AND expires_at > ?").get(projectId, key, now);
+    if (!row)
+      return null;
+    const state = JSON.parse(row.data);
+    if (state.active) {
+      try {
+        await api.client.session.abort({
+          sessionID: state.sessionId
+        });
+      } catch {}
+      const oldSessionKey = `loop-session:${state.sessionId}`;
+      db.prepare("DELETE FROM project_kv WHERE project_id = ? AND key = ?").run(projectId, oldSessionKey);
+    }
+    const directory = state.worktreeDir;
+    if (!directory)
+      return null;
+    const createResult = await api.client.session.create({
+      directory,
+      title: loopName,
+      permission: LOOP_PERMISSION_RULESET
+    });
+    if (createResult.error || !createResult.data)
+      return null;
+    const newSessionId = createResult.data.id;
+    const sessionKey = `loop-session:${newSessionId}`;
+    const ttl = 30 * 24 * 60 * 60 * 1000;
+    db.prepare("INSERT OR REPLACE INTO project_kv (project_id, key, data, expires_at, updated_at) VALUES (?, ?, ?, ?, ?)").run(projectId, sessionKey, JSON.stringify(loopName), now + ttl, now);
+    const newState = {
+      ...state,
+      active: true,
+      sessionId: newSessionId,
+      phase: "coding",
+      errorCount: 0,
+      auditCount: 0,
+      startedAt: new Date().toISOString(),
+      completedAt: undefined,
+      terminationReason: undefined
+    };
+    db.prepare("UPDATE project_kv SET data = ?, updated_at = ? WHERE project_id = ? AND key = ?").run(JSON.stringify(newState), now, projectId, key);
+    let promptText = state.prompt ?? "";
+    if (state.completionSignal) {
+      const completionInstructions = `
+
+---
+
+**IMPORTANT - Completion Signal:** When you have completed ALL phases of this plan successfully, you MUST output the following phrase exactly: ${state.completionSignal}
+
+Before outputting the completion signal, you MUST:
+1. Verify each phase's acceptance criteria are met
+2. Run all verification commands listed in the plan and confirm they pass
+3. If tests were required, confirm they exist AND pass
+
+Do NOT output this phrase until every phase is truly complete and all verification steps pass. The loop will continue until this signal is detected.`;
+      promptText += completionInstructions;
+    }
+    await api.client.session.promptAsync({
+      sessionID: newSessionId,
+      directory,
+      parts: [{
+        type: "text",
+        text: promptText
+      }],
+      agent: "code"
+    });
+    return newSessionId;
+  } catch {
+    return null;
+  } finally {
+    try {
+      db?.close();
+    } catch {}
+  }
+}
+function formatTokens(n) {
+  return n >= 1000 ? `${(n / 1000).toFixed(1)}k` : `${n}`;
+}
+function formatDuration(ms) {
+  const hours = Math.floor(ms / (1000 * 60 * 60));
+  const minutes = Math.floor(ms % (1000 * 60 * 60) / (1000 * 60));
+  const seconds = Math.floor(ms % (1000 * 60) / 1000);
+  if (hours > 0) {
+    return `${hours}h ${minutes}m ${seconds}s`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds}s`;
+  }
+  return `${seconds}s`;
+}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength)
+    return text;
+  return text.slice(0, maxLength - 3) + "...";
+}
+function truncateMiddle(text, maxLength) {
+  if (text.length <= maxLength)
+    return text;
+  const keep = maxLength - 5;
+  const start = Math.ceil(keep / 2);
+  const end = Math.floor(keep / 2);
+  return text.slice(0, start) + "....." + text.slice(text.length - end);
+}
+function PlanViewerDialog(props) {
+  const theme = () => props.api.theme.current;
+  const [editing, setEditing] = createSignal(false);
+  const [executing, setExecuting] = createSignal(false);
+  const [content, setContent] = createSignal(props.planContent);
+  let textareaRef;
+  const handleSave = () => {
+    const text = textareaRef?.plainText ?? content();
+    const saved = writePlan(props.projectId, props.sessionId, text);
+    props.api.ui.toast({
+      message: saved ? "Plan saved" : "Failed to save plan",
+      variant: saved ? "success" : "error",
+      duration: 3000
+    });
+    if (saved) {
+      setContent(text);
+      setEditing(false);
+    }
+  };
+  const handleExport = () => {
+    const planText = content();
+    const title = extractPlanTitle(planText);
+    const slugifiedTitle = slugify(title);
+    const directory = props.api.state.path.directory;
+    const filename = `${slugifiedTitle}.md`;
+    const filepath = join6(directory, filename);
+    try {
+      writeFileSync(filepath, planText, "utf-8");
+      props.api.ui.toast({
+        message: `Exported plan to ${filename}`,
+        variant: "success",
+        duration: 3000
+      });
+    } catch (error) {
+      props.api.ui.toast({
+        message: `Failed to export plan: ${error.message}`,
+        variant: "error",
+        duration: 3000
+      });
+    }
+  };
+  function getModeDescription(label) {
+    switch (label) {
+      case "New session":
+        return "Create a new session and send the plan to the code agent";
+      case "Execute here":
+        return "Execute the plan in the current session using the code agent";
+      case "Loop (worktree)":
+        return "Execute using iterative development loop in an isolated git worktree";
+      case "Loop":
+        return "Execute using iterative development loop in the current directory";
+      default:
+        return "";
+    }
+  }
+  const handleExecuteMode = async (mode) => {
+    const planText = content();
+    const title = extractPlanTitle(planText);
+    const directory = props.api.state.path.directory;
+    const pid = resolveProjectId(directory);
+    if (!pid) {
+      props.api.ui.toast({
+        message: "Failed to resolve project ID",
+        variant: "error",
+        duration: 3000
+      });
+      return;
+    }
+    const matchedLabel = matchExecutionLabel(mode);
+    switch (matchedLabel) {
+      case "New session": {
+        props.api.ui.dialog.clear();
+        props.api.ui.toast({
+          message: "Creating new session for plan execution...",
+          variant: "info",
+          duration: 3000
+        });
+        try {
+          const createResult = await props.api.client.session.create({
+            title,
+            directory
+          });
+          if (createResult.error || !createResult.data) {
+            props.api.ui.toast({
+              message: "Failed to create new session",
+              variant: "error",
+              duration: 3000
+            });
+            return;
+          }
+          const newSessionId = createResult.data.id;
+          if (pid) {
+            deletePlan(pid, props.sessionId);
+          }
+          await props.api.client.session.promptAsync({
+            sessionID: newSessionId,
+            directory,
+            agent: "code",
+            parts: [{
+              type: "text",
+              text: planText
+            }]
+          });
+          props.api.ui.toast({
+            message: `New session created: ${title}`,
+            variant: "success",
+            duration: 3000
+          });
+          props.onRefresh?.();
+          try {
+            props.api.route.navigate("session", {
+              sessionID: newSessionId
+            });
+          } catch {}
+        } catch {
+          props.api.ui.toast({
+            message: "Failed to create new session",
+            variant: "error",
+            duration: 3000
+          });
+        }
+        break;
+      }
+      case "Execute here": {
+        props.api.ui.dialog.clear();
+        props.api.ui.toast({
+          message: "Switching to code agent for plan execution...",
+          variant: "info",
+          duration: 3000
+        });
+        const inPlacePrompt = `The architect agent has created an implementation plan. You are now the code agent taking over this session. Your job is to execute the plan — edit files, run commands, create tests, and implement every phase. Do NOT just describe or summarize the changes. Actually make them.
+
+Implementation Plan:
+${planText}`;
+        try {
+          await props.api.client.session.promptAsync({
+            sessionID: props.sessionId,
+            directory,
+            agent: "code",
+            parts: [{
+              type: "text",
+              text: inPlacePrompt
+            }]
+          });
+          props.api.ui.toast({
+            message: "Executing plan in current session",
+            variant: "success",
+            duration: 3000
+          });
+          props.onRefresh?.();
+        } catch {
+          props.api.ui.toast({
+            message: "Failed to execute plan in current session",
+            variant: "error",
+            duration: 3000
+          });
+        }
+        break;
+      }
+      case "Loop (worktree)":
+      case "Loop": {
+        const isWorktree = matchedLabel === "Loop (worktree)";
+        props.api.ui.dialog.clear();
+        props.api.ui.toast({
+          message: isWorktree ? "Starting loop in worktree..." : "Starting loop in-place...",
+          variant: "info",
+          duration: 3000
+        });
+        try {
+          const launchResult = await launchFreshLoop({
+            planText,
+            title,
+            directory,
+            projectId: pid,
+            isWorktree,
+            api: props.api
+          });
+          if (launchResult) {
+            if (pid) {
+              deletePlan(pid, props.sessionId);
+            }
+            props.api.ui.toast({
+              message: isWorktree ? `Loop started in worktree: ${launchResult.loopName}` : `Loop started: ${launchResult.loopName}`,
+              variant: "success",
+              duration: 3000
+            });
+            props.onRefresh?.();
+          }
+        } catch {
+          props.api.ui.toast({
+            message: "Failed to start loop",
+            variant: "error",
+            duration: 3000
+          });
+        }
+        break;
+      }
+      default: {
+        props.api.ui.toast({
+          message: "Unknown execution mode",
+          variant: "error",
+          duration: 3000
+        });
+      }
+    }
+  };
+  return (() => {
+    var _el$ = _$createElement("box"), _el$2 = _$createElement("box"), _el$3 = _$createElement("text"), _el$4 = _$createElement("b"), _el$6 = _$createElement("text"), _el$8 = _$createElement("text"), _el$0 = _$createElement("text"), _el$10 = _$createElement("text"), _el$21 = _$createElement("box"), _el$26 = _$createElement("text");
+    _$insertNode(_el$, _el$2);
+    _$insertNode(_el$, _el$21);
+    _$setProp(_el$, "flexDirection", "column");
+    _$setProp(_el$, "paddingX", 2);
+    _$insertNode(_el$2, _el$3);
+    _$insertNode(_el$2, _el$6);
+    _$insertNode(_el$2, _el$8);
+    _$insertNode(_el$2, _el$0);
+    _$insertNode(_el$2, _el$10);
+    _$setProp(_el$2, "flexShrink", 0);
+    _$setProp(_el$2, "paddingBottom", 1);
+    _$setProp(_el$2, "flexDirection", "row");
+    _$setProp(_el$2, "gap", 2);
+    _$insertNode(_el$3, _el$4);
+    _$insertNode(_el$4, _$createTextNode(`Plan`));
+    _$insertNode(_el$6, _$createTextNode(`[view]`));
+    _$setProp(_el$6, "onMouseUp", () => {
+      setEditing(false);
+      setExecuting(false);
+    });
+    _$insertNode(_el$8, _$createTextNode(`[edit]`));
+    _$setProp(_el$8, "onMouseUp", () => {
+      setEditing(true);
+      setExecuting(false);
+    });
+    _$insertNode(_el$0, _$createTextNode(`[execute]`));
+    _$setProp(_el$0, "onMouseUp", () => {
+      setEditing(false);
+      setExecuting(true);
+    });
+    _$insertNode(_el$10, _$createTextNode(`[export]`));
+    _$setProp(_el$10, "onMouseUp", handleExport);
+    _$insert(_el$, _$createComponent(Show, {
+      get when() {
+        return _$memo(() => !!!editing())() && !executing();
+      },
+      get children() {
+        var _el$12 = _$createElement("scrollbox"), _el$13 = _$createElement("markdown");
+        _$insertNode(_el$12, _el$13);
+        _$setProp(_el$12, "minHeight", 20);
+        _$setProp(_el$12, "maxHeight", "75%");
+        _$setProp(_el$12, "borderStyle", "rounded");
+        _$setProp(_el$12, "paddingX", 1);
+        _$effect((_p$) => {
+          var _v$ = theme().border, _v$2 = content(), _v$3 = SyntaxStyle.create(), _v$4 = theme().markdownText;
+          _v$ !== _p$.e && (_p$.e = _$setProp(_el$12, "borderColor", _v$, _p$.e));
+          _v$2 !== _p$.t && (_p$.t = _$setProp(_el$13, "content", _v$2, _p$.t));
+          _v$3 !== _p$.a && (_p$.a = _$setProp(_el$13, "syntaxStyle", _v$3, _p$.a));
+          _v$4 !== _p$.o && (_p$.o = _$setProp(_el$13, "fg", _v$4, _p$.o));
+          return _p$;
+        }, {
+          e: undefined,
+          t: undefined,
+          a: undefined,
+          o: undefined
+        });
+        return _el$12;
+      }
+    }), _el$21);
+    _$insert(_el$, _$createComponent(Show, {
+      get when() {
+        return editing();
+      },
+      get children() {
+        var _el$14 = _$createElement("textarea");
+        _$use((value) => {
+          textareaRef = value;
+        }, _el$14);
+        _$setProp(_el$14, "focused", true);
+        _$setProp(_el$14, "minHeight", 20);
+        _$setProp(_el$14, "maxHeight", "75%");
+        _$setProp(_el$14, "paddingX", 1);
+        _$effect((_$p) => _$setProp(_el$14, "initialValue", content(), _$p));
+        return _el$14;
+      }
+    }), _el$21);
+    _$insert(_el$, _$createComponent(Show, {
+      get when() {
+        return executing();
+      },
+      get children() {
+        var _el$15 = _$createElement("box"), _el$16 = _$createElement("box"), _el$17 = _$createElement("text"), _el$18 = _$createElement("b"), _el$20 = _$createElement("select");
+        _$insertNode(_el$15, _el$16);
+        _$insertNode(_el$15, _el$20);
+        _$setProp(_el$15, "flexDirection", "column");
+        _$setProp(_el$15, "paddingBottom", 1);
+        _$setProp(_el$15, "gap", 1);
+        _$setProp(_el$15, "minHeight", 20);
+        _$setProp(_el$15, "maxHeight", "75%");
+        _$insertNode(_el$16, _el$17);
+        _$setProp(_el$16, "paddingBottom", 1);
+        _$insertNode(_el$17, _el$18);
+        _$insertNode(_el$18, _$createTextNode(`Select Execution Mode`));
+        _$setProp(_el$20, "focused", true);
+        _$setProp(_el$20, "onSelect", (_, option) => {
+          if (option?.value) {
+            handleExecuteMode(option.value);
+          }
+        });
+        _$setProp(_el$20, "showDescription", false);
+        _$setProp(_el$20, "itemSpacing", 1);
+        _$setProp(_el$20, "wrapSelection", true);
+        _$setProp(_el$20, "selectedTextColor", "#ffffff");
+        _$setProp(_el$20, "minHeight", 12);
+        _$setProp(_el$20, "flexGrow", 1);
+        _$effect((_p$) => {
+          var _v$5 = theme().text, _v$6 = PLAN_EXECUTION_LABELS.map((label) => ({
+            name: label,
+            description: getModeDescription(label),
+            value: label
+          })), _v$7 = theme().text, _v$8 = theme().text, _v$9 = theme().borderActive;
+          _v$5 !== _p$.e && (_p$.e = _$setProp(_el$17, "fg", _v$5, _p$.e));
+          _v$6 !== _p$.t && (_p$.t = _$setProp(_el$20, "options", _v$6, _p$.t));
+          _v$7 !== _p$.a && (_p$.a = _$setProp(_el$20, "textColor", _v$7, _p$.a));
+          _v$8 !== _p$.o && (_p$.o = _$setProp(_el$20, "focusedTextColor", _v$8, _p$.o));
+          _v$9 !== _p$.i && (_p$.i = _$setProp(_el$20, "selectedBackgroundColor", _v$9, _p$.i));
+          return _p$;
+        }, {
+          e: undefined,
+          t: undefined,
+          a: undefined,
+          o: undefined,
+          i: undefined
+        });
+        return _el$15;
+      }
+    }), _el$21);
+    _$insertNode(_el$21, _el$26);
+    _$setProp(_el$21, "paddingTop", 1);
+    _$setProp(_el$21, "flexShrink", 0);
+    _$setProp(_el$21, "flexDirection", "row");
+    _$setProp(_el$21, "gap", 2);
+    _$insert(_el$21, _$createComponent(Show, {
+      get when() {
+        return editing();
+      },
+      get children() {
+        var _el$22 = _$createElement("text");
+        _$insertNode(_el$22, _$createTextNode(`Save`));
+        _$setProp(_el$22, "onMouseUp", handleSave);
+        _$effect((_$p) => _$setProp(_el$22, "fg", theme().success, _$p));
+        return _el$22;
+      }
+    }), _el$26);
+    _$insert(_el$21, _$createComponent(Show, {
+      get when() {
+        return executing();
+      },
+      get children() {
+        var _el$24 = _$createElement("text");
+        _$insertNode(_el$24, _$createTextNode(`Back to plan`));
+        _$setProp(_el$24, "onMouseUp", () => setExecuting(false));
+        _$effect((_$p) => _$setProp(_el$24, "fg", theme().textMuted, _$p));
+        return _el$24;
+      }
+    }), _el$26);
+    _$insertNode(_el$26, _$createTextNode(`Close (esc)`));
+    _$setProp(_el$26, "onMouseUp", () => props.api.ui.dialog.clear());
+    _$effect((_p$) => {
+      var _v$0 = theme().text, _v$1 = executing() ? theme().textMuted : editing() ? theme().text : theme().info, _v$10 = editing() ? theme().text : theme().textMuted, _v$11 = executing() ? theme().text : theme().textMuted, _v$12 = theme().textMuted, _v$13 = theme().textMuted;
+      _v$0 !== _p$.e && (_p$.e = _$setProp(_el$3, "fg", _v$0, _p$.e));
+      _v$1 !== _p$.t && (_p$.t = _$setProp(_el$6, "fg", _v$1, _p$.t));
+      _v$10 !== _p$.a && (_p$.a = _$setProp(_el$8, "fg", _v$10, _p$.a));
+      _v$11 !== _p$.o && (_p$.o = _$setProp(_el$0, "fg", _v$11, _p$.o));
+      _v$12 !== _p$.i && (_p$.i = _$setProp(_el$10, "fg", _v$12, _p$.i));
+      _v$13 !== _p$.n && (_p$.n = _$setProp(_el$26, "fg", _v$13, _p$.n));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined,
+      a: undefined,
+      o: undefined,
+      i: undefined,
+      n: undefined
+    });
+    return _el$;
+  })();
+}
+function LoopDetailsDialog(props) {
+  const theme = () => props.api.theme.current;
+  const [currentLoop, setCurrentLoop] = createSignal(props.loop);
+  const [stats, setStats] = createSignal(null);
+  const [loading, setLoading] = createSignal(true);
+  const directory = props.api.state.path.directory;
+  const pid = resolveProjectId(directory);
+  const refreshLoopState = () => {
+    if (pid && currentLoop().name) {
+      const freshLoop = readLoopByName(pid, currentLoop().name);
+      if (freshLoop) {
+        setCurrentLoop(freshLoop);
+      }
+    }
+  };
+  refreshLoopState();
+  createEffect(() => {
+    const loop = currentLoop();
+    if (loop.sessionId && directory) {
+      setLoading(true);
+      fetchSessionStats(props.api, loop.sessionId, directory).then((result) => {
+        setStats(result);
+        setLoading(false);
+      }).catch(() => {
+        setStats(null);
+        setLoading(false);
+      });
+    } else {
+      setLoading(false);
+    }
+  });
+  const handleCancel = () => {
+    props.api.ui.dialog.clear();
+    const directory2 = props.api.state.path.directory;
+    const pid2 = resolveProjectId(directory2);
+    if (!pid2)
+      return;
+    const sessionId = cancelLoop(pid2, currentLoop().name);
+    if (sessionId) {
+      props.api.client.session.abort({
+        sessionID: sessionId
+      }).catch(() => {});
+    }
+    props.api.ui.toast({
+      message: sessionId ? `Cancelled loop: ${currentLoop().name}` : `Loop ${currentLoop().name} is not active`,
+      variant: sessionId ? "success" : "info",
+      duration: 3000
+    });
+    props.onRefresh?.();
+  };
+  const handleRestart = async () => {
+    props.api.ui.dialog.clear();
+    const directory2 = props.api.state.path.directory;
+    const pid2 = resolveProjectId(directory2);
+    if (!pid2)
+      return;
+    const newSessionId = await restartLoop(pid2, currentLoop().name, props.api);
+    const label = currentLoop().active ? "Force restarting" : "Restarting";
+    props.api.ui.toast({
+      message: newSessionId ? `${label} loop: ${currentLoop().name}` : `Failed to restart loop: ${currentLoop().name}`,
+      variant: newSessionId ? "success" : "error",
+      duration: 3000
+    });
+    props.onRefresh?.();
+  };
+  const statusBadge = () => {
+    const loop = currentLoop();
+    if (loop.active)
+      return {
+        text: loop.phase,
+        color: loop.phase === "auditing" ? theme().warning : theme().success
+      };
+    if (loop.terminationReason === "completed")
+      return {
+        text: "completed",
+        color: theme().success
+      };
+    if (loop.terminationReason === "cancelled" || loop.terminationReason === "user_aborted")
+      return {
+        text: "cancelled",
+        color: theme().textMuted
+      };
+    return {
+      text: "ended",
+      color: theme().error
+    };
+  };
+  return (() => {
+    var _el$28 = _$createElement("box"), _el$29 = _$createElement("box"), _el$30 = _$createElement("box"), _el$31 = _$createElement("text"), _el$32 = _$createElement("b"), _el$33 = _$createElement("text"), _el$34 = _$createElement("b"), _el$35 = _$createTextNode(`[`), _el$36 = _$createTextNode(`]`), _el$37 = _$createElement("box"), _el$38 = _$createElement("text"), _el$39 = _$createTextNode(`Iteration `), _el$90 = _$createElement("box"), _el$99 = _$createElement("text");
+    _$insertNode(_el$28, _el$29);
+    _$insertNode(_el$28, _el$90);
+    _$setProp(_el$28, "flexDirection", "column");
+    _$setProp(_el$28, "paddingX", 2);
+    _$insertNode(_el$29, _el$30);
+    _$insertNode(_el$29, _el$37);
+    _$setProp(_el$29, "flexDirection", "column");
+    _$setProp(_el$29, "flexShrink", 0);
+    _$insertNode(_el$30, _el$31);
+    _$insertNode(_el$30, _el$33);
+    _$setProp(_el$30, "flexDirection", "row");
+    _$setProp(_el$30, "gap", 1);
+    _$setProp(_el$30, "alignItems", "center");
+    _$insertNode(_el$31, _el$32);
+    _$insert(_el$32, () => currentLoop().name);
+    _$insertNode(_el$33, _el$34);
+    _$insertNode(_el$34, _el$35);
+    _$insertNode(_el$34, _el$36);
+    _$insert(_el$34, () => statusBadge().text, _el$36);
+    _$insertNode(_el$37, _el$38);
+    _$insertNode(_el$38, _el$39);
+    _$insert(_el$38, () => currentLoop().iteration, null);
+    _$insert(_el$38, (() => {
+      var _c$ = _$memo(() => currentLoop().maxIterations > 0);
+      return () => _c$() ? `/${currentLoop().maxIterations}` : "";
+    })(), null);
+    _$insert(_el$28, _$createComponent(Show, {
+      get when() {
+        return loading();
+      },
+      get children() {
+        var _el$40 = _$createElement("box"), _el$41 = _$createElement("text");
+        _$insertNode(_el$40, _el$41);
+        _$setProp(_el$40, "paddingTop", 1);
+        _$insertNode(_el$41, _$createTextNode(`Loading stats...`));
+        _$effect((_$p) => _$setProp(_el$41, "fg", theme().textMuted, _$p));
+        return _el$40;
+      }
+    }), _el$90);
+    _$insert(_el$28, _$createComponent(Show, {
+      get when() {
+        return !loading();
+      },
+      get children() {
+        var _el$43 = _$createElement("box");
+        _$setProp(_el$43, "flexDirection", "column");
+        _$setProp(_el$43, "paddingTop", 1);
+        _$setProp(_el$43, "flexShrink", 0);
+        _$insert(_el$43, _$createComponent(Show, {
+          get when() {
+            return stats();
+          },
+          get fallback() {
+            return (() => {
+              var _el$101 = _$createElement("box"), _el$102 = _$createElement("text");
+              _$insertNode(_el$101, _el$102);
+              _$insertNode(_el$102, _$createTextNode(`Session stats unavailable`));
+              _$effect((_$p) => _$setProp(_el$102, "fg", theme().textMuted, _$p));
+              return _el$101;
+            })();
+          },
+          get children() {
+            var _el$44 = _$createElement("box"), _el$45 = _$createElement("box"), _el$46 = _$createElement("text"), _el$47 = _$createElement("span"), _el$49 = _$createTextNode(`...`), _el$50 = _$createElement("box"), _el$51 = _$createElement("text"), _el$52 = _$createElement("span"), _el$54 = _$createElement("box"), _el$55 = _$createElement("text"), _el$56 = _$createElement("span"), _el$58 = _$createTextNode(` total (`), _el$59 = _$createTextNode(` assistant)`), _el$60 = _$createElement("box"), _el$61 = _$createElement("text"), _el$62 = _$createElement("span"), _el$64 = _$createTextNode(` in / `), _el$65 = _$createTextNode(` out / `), _el$66 = _$createTextNode(` reasoning`), _el$67 = _$createElement("box"), _el$68 = _$createElement("text"), _el$69 = _$createElement("span"), _el$71 = _$createTextNode(`$`);
+            _$insertNode(_el$44, _el$45);
+            _$insertNode(_el$44, _el$50);
+            _$insertNode(_el$44, _el$54);
+            _$insertNode(_el$44, _el$60);
+            _$insertNode(_el$44, _el$67);
+            _$setProp(_el$44, "flexDirection", "column");
+            _$insertNode(_el$45, _el$46);
+            _$insertNode(_el$46, _el$47);
+            _$insertNode(_el$46, _el$49);
+            _$insertNode(_el$47, _$createTextNode(`Session: `));
+            _$insert(_el$46, () => currentLoop().sessionId.slice(0, 8), _el$49);
+            _$insertNode(_el$50, _el$51);
+            _$insertNode(_el$51, _el$52);
+            _$insertNode(_el$52, _$createTextNode(`Phase: `));
+            _$insert(_el$51, () => currentLoop().phase, null);
+            _$insertNode(_el$54, _el$55);
+            _$insertNode(_el$55, _el$56);
+            _$insertNode(_el$55, _el$58);
+            _$insertNode(_el$55, _el$59);
+            _$insertNode(_el$56, _$createTextNode(`Messages: `));
+            _$insert(_el$55, () => stats().messages.total, _el$58);
+            _$insert(_el$55, () => stats().messages.assistant, _el$59);
+            _$insertNode(_el$60, _el$61);
+            _$insertNode(_el$61, _el$62);
+            _$insertNode(_el$61, _el$64);
+            _$insertNode(_el$61, _el$65);
+            _$insertNode(_el$61, _el$66);
+            _$insertNode(_el$62, _$createTextNode(`Tokens: `));
+            _$insert(_el$61, () => formatTokens(stats().tokens.input), _el$64);
+            _$insert(_el$61, () => formatTokens(stats().tokens.output), _el$65);
+            _$insert(_el$61, () => formatTokens(stats().tokens.reasoning), _el$66);
+            _$insertNode(_el$67, _el$68);
+            _$insertNode(_el$68, _el$69);
+            _$insertNode(_el$68, _el$71);
+            _$insertNode(_el$69, _$createTextNode(`Cost: `));
+            _$insert(_el$68, () => stats().cost.toFixed(4), null);
+            _$insert(_el$44, _$createComponent(Show, {
+              get when() {
+                return stats().fileChanges;
+              },
+              get children() {
+                var _el$72 = _$createElement("box"), _el$73 = _$createElement("text"), _el$74 = _$createElement("span"), _el$76 = _$createTextNode(` changed (+`), _el$77 = _$createTextNode(`/-`), _el$78 = _$createTextNode(`)`);
+                _$insertNode(_el$72, _el$73);
+                _$insertNode(_el$73, _el$74);
+                _$insertNode(_el$73, _el$76);
+                _$insertNode(_el$73, _el$77);
+                _$insertNode(_el$73, _el$78);
+                _$insertNode(_el$74, _$createTextNode(`Files: `));
+                _$insert(_el$73, () => stats().fileChanges.files, _el$76);
+                _$insert(_el$73, () => stats().fileChanges.additions, _el$77);
+                _$insert(_el$73, () => stats().fileChanges.deletions, _el$78);
+                _$effect((_p$) => {
+                  var _v$14 = theme().text, _v$15 = {
+                    fg: theme().textMuted
+                  };
+                  _v$14 !== _p$.e && (_p$.e = _$setProp(_el$73, "fg", _v$14, _p$.e));
+                  _v$15 !== _p$.t && (_p$.t = _$setProp(_el$74, "style", _v$15, _p$.t));
+                  return _p$;
+                }, {
+                  e: undefined,
+                  t: undefined
+                });
+                return _el$72;
+              }
+            }), null);
+            _$insert(_el$44, _$createComponent(Show, {
+              get when() {
+                return stats().timing;
+              },
+              get children() {
+                var _el$79 = _$createElement("box"), _el$80 = _$createElement("text"), _el$81 = _$createElement("span");
+                _$insertNode(_el$79, _el$80);
+                _$insertNode(_el$80, _el$81);
+                _$insertNode(_el$81, _$createTextNode(`Duration: `));
+                _$insert(_el$80, () => formatDuration(stats().timing.durationMs), null);
+                _$effect((_p$) => {
+                  var _v$16 = theme().text, _v$17 = {
+                    fg: theme().textMuted
+                  };
+                  _v$16 !== _p$.e && (_p$.e = _$setProp(_el$80, "fg", _v$16, _p$.e));
+                  _v$17 !== _p$.t && (_p$.t = _$setProp(_el$81, "style", _v$17, _p$.t));
+                  return _p$;
+                }, {
+                  e: undefined,
+                  t: undefined
+                });
+                return _el$79;
+              }
+            }), null);
+            _$effect((_p$) => {
+              var _v$18 = theme().text, _v$19 = {
+                fg: theme().textMuted
+              }, _v$20 = theme().text, _v$21 = {
+                fg: theme().textMuted
+              }, _v$22 = theme().text, _v$23 = {
+                fg: theme().textMuted
+              }, _v$24 = theme().text, _v$25 = {
+                fg: theme().textMuted
+              }, _v$26 = theme().text, _v$27 = {
+                fg: theme().textMuted
+              };
+              _v$18 !== _p$.e && (_p$.e = _$setProp(_el$46, "fg", _v$18, _p$.e));
+              _v$19 !== _p$.t && (_p$.t = _$setProp(_el$47, "style", _v$19, _p$.t));
+              _v$20 !== _p$.a && (_p$.a = _$setProp(_el$51, "fg", _v$20, _p$.a));
+              _v$21 !== _p$.o && (_p$.o = _$setProp(_el$52, "style", _v$21, _p$.o));
+              _v$22 !== _p$.i && (_p$.i = _$setProp(_el$55, "fg", _v$22, _p$.i));
+              _v$23 !== _p$.n && (_p$.n = _$setProp(_el$56, "style", _v$23, _p$.n));
+              _v$24 !== _p$.s && (_p$.s = _$setProp(_el$61, "fg", _v$24, _p$.s));
+              _v$25 !== _p$.h && (_p$.h = _$setProp(_el$62, "style", _v$25, _p$.h));
+              _v$26 !== _p$.r && (_p$.r = _$setProp(_el$68, "fg", _v$26, _p$.r));
+              _v$27 !== _p$.d && (_p$.d = _$setProp(_el$69, "style", _v$27, _p$.d));
+              return _p$;
+            }, {
+              e: undefined,
+              t: undefined,
+              a: undefined,
+              o: undefined,
+              i: undefined,
+              n: undefined,
+              s: undefined,
+              h: undefined,
+              r: undefined,
+              d: undefined
+            });
+            return _el$44;
+          }
+        }));
+        return _el$43;
+      }
+    }), _el$90);
+    _$insert(_el$28, _$createComponent(Show, {
+      get when() {
+        return stats()?.lastActivity?.summary;
+      },
+      get children() {
+        var _el$83 = _$createElement("box"), _el$84 = _$createElement("box"), _el$85 = _$createElement("text"), _el$86 = _$createElement("b"), _el$88 = _$createElement("scrollbox"), _el$89 = _$createElement("text");
+        _$insertNode(_el$83, _el$84);
+        _$insertNode(_el$83, _el$88);
+        _$setProp(_el$83, "flexDirection", "column");
+        _$setProp(_el$83, "paddingTop", 1);
+        _$setProp(_el$83, "flexGrow", 1);
+        _$setProp(_el$83, "flexShrink", 1);
+        _$insertNode(_el$84, _el$85);
+        _$setProp(_el$84, "flexShrink", 0);
+        _$insertNode(_el$85, _el$86);
+        _$insertNode(_el$86, _$createTextNode(`Latest Output`));
+        _$insertNode(_el$88, _el$89);
+        _$setProp(_el$88, "maxHeight", 12);
+        _$setProp(_el$88, "borderStyle", "rounded");
+        _$setProp(_el$88, "paddingX", 1);
+        _$setProp(_el$89, "wrapMode", "word");
+        _$insert(_el$89, () => truncate(stats().lastActivity.summary, 500));
+        _$effect((_p$) => {
+          var _v$28 = theme().text, _v$29 = theme().border, _v$30 = theme().textMuted;
+          _v$28 !== _p$.e && (_p$.e = _$setProp(_el$85, "fg", _v$28, _p$.e));
+          _v$29 !== _p$.t && (_p$.t = _$setProp(_el$88, "borderColor", _v$29, _p$.t));
+          _v$30 !== _p$.a && (_p$.a = _$setProp(_el$89, "fg", _v$30, _p$.a));
+          return _p$;
+        }, {
+          e: undefined,
+          t: undefined,
+          a: undefined
+        });
+        return _el$83;
+      }
+    }), _el$90);
+    _$insertNode(_el$90, _el$99);
+    _$setProp(_el$90, "paddingTop", 1);
+    _$setProp(_el$90, "flexShrink", 0);
+    _$setProp(_el$90, "flexDirection", "row");
+    _$setProp(_el$90, "gap", 2);
+    _$setProp(_el$90, "paddingY", 2);
+    _$insert(_el$90, _$createComponent(Show, {
+      get when() {
+        return props.onBack;
+      },
+      get children() {
+        var _el$91 = _$createElement("text");
+        _$insertNode(_el$91, _$createTextNode(`Back`));
+        _$setProp(_el$91, "onMouseUp", () => props.onBack());
+        _$effect((_$p) => _$setProp(_el$91, "fg", theme().textMuted, _$p));
+        return _el$91;
+      }
+    }), _el$99);
+    _$insert(_el$90, _$createComponent(Show, {
+      get when() {
+        return currentLoop().active;
+      },
+      get children() {
+        return [(() => {
+          var _el$93 = _$createElement("text");
+          _$insertNode(_el$93, _$createTextNode(`Force Restart`));
+          _$setProp(_el$93, "onMouseUp", handleRestart);
+          _$effect((_$p) => _$setProp(_el$93, "fg", theme().warning, _$p));
+          return _el$93;
+        })(), (() => {
+          var _el$95 = _$createElement("text");
+          _$insertNode(_el$95, _$createTextNode(`Cancel loop`));
+          _$setProp(_el$95, "onMouseUp", handleCancel);
+          _$effect((_$p) => _$setProp(_el$95, "fg", theme().error, _$p));
+          return _el$95;
+        })()];
+      }
+    }), _el$99);
+    _$insert(_el$90, _$createComponent(Show, {
+      get when() {
+        return _$memo(() => !!!currentLoop().active)() && currentLoop().terminationReason !== "completed";
+      },
+      get children() {
+        var _el$97 = _$createElement("text");
+        _$insertNode(_el$97, _$createTextNode(`Restart`));
+        _$setProp(_el$97, "onMouseUp", handleRestart);
+        _$effect((_$p) => _$setProp(_el$97, "fg", theme().success, _$p));
+        return _el$97;
+      }
+    }), _el$99);
+    _$insertNode(_el$99, _$createTextNode(`Close (esc)`));
+    _$setProp(_el$99, "onMouseUp", () => props.api.ui.dialog.clear());
+    _$effect((_p$) => {
+      var _v$31 = theme().text, _v$32 = statusBadge().color, _v$33 = theme().textMuted, _v$34 = theme().textMuted;
+      _v$31 !== _p$.e && (_p$.e = _$setProp(_el$31, "fg", _v$31, _p$.e));
+      _v$32 !== _p$.t && (_p$.t = _$setProp(_el$33, "fg", _v$32, _p$.t));
+      _v$33 !== _p$.a && (_p$.a = _$setProp(_el$38, "fg", _v$33, _p$.a));
+      _v$34 !== _p$.o && (_p$.o = _$setProp(_el$99, "fg", _v$34, _p$.o));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined,
+      a: undefined,
+      o: undefined
+    });
+    return _el$28;
+  })();
+}
+function Sidebar(props) {
+  const [open, setOpen] = createSignal(true);
+  const [loops, setLoops] = createSignal([]);
+  const [hasPlan, setHasPlan] = createSignal(false);
+  const [graphStatusFormatted, setGraphStatusFormatted] = createSignal(null);
+  const theme = () => props.api.theme.current;
+  const directory = props.api.state.path.directory;
+  const pid = resolveProjectId(directory);
+  const title = createMemo(() => {
+    return props.opts.showVersion ? `Graph v${VERSION}` : "Graph";
+  });
+  const dot = (loop) => {
+    if (!loop.active) {
+      if (loop.terminationReason === "completed")
+        return theme().success;
+      if (loop.terminationReason === "cancelled" || loop.terminationReason === "user_aborted")
+        return theme().textMuted;
+      return theme().error;
+    }
+    if (loop.phase === "auditing")
+      return theme().warning;
+    return theme().success;
+  };
+  const statusText = (loop) => {
+    const max = loop.maxIterations > 0 ? `/${loop.maxIterations}` : "";
+    if (loop.active)
+      return `${loop.phase} · iter ${loop.iteration}${max}`;
+    if (loop.terminationReason === "completed")
+      return `completed · ${loop.iteration} iter${loop.iteration !== 1 ? "s" : ""}`;
+    return loop.terminationReason?.replace(/_/g, " ") ?? "ended";
+  };
+  function refreshSidebarData() {
+    if (!pid)
+      return;
+    const states = readLoopStates(pid);
+    const cutoff = Date.now() - 5 * 60 * 1000;
+    const visible = states.filter((l) => l.active || l.completedAt && new Date(l.completedAt).getTime() > cutoff);
+    visible.sort((a, b) => {
+      if (a.active && !b.active)
+        return -1;
+      if (!a.active && b.active)
+        return 1;
+      const aTime = a.completedAt ?? a.startedAt ?? "";
+      const bTime = b.completedAt ?? b.startedAt ?? "";
+      return bTime.localeCompare(aTime);
+    });
+    setLoops(visible);
+    if (props.sessionId) {
+      const plan = readPlan(pid, props.sessionId);
+      setHasPlan(plan !== null);
+    }
+    const status = readGraphStatus(pid);
+    setGraphStatusFormatted(formatGraphStatus(status));
+  }
+  const unsub = props.api.event.on("session.status", () => {
+    refreshSidebarData();
+  });
+  let pollTimer = null;
+  function startPolling() {
+    if (pollTimer)
+      return;
+    pollTimer = setInterval(() => {
+      refreshSidebarData();
+    }, 5000);
+  }
+  function stopPolling() {
+    if (pollTimer) {
+      clearInterval(pollTimer);
+      pollTimer = null;
+    }
+  }
+  refreshSidebarData();
+  createEffect(() => {
+    const hasActiveWorktreeLoops = loops().filter((l) => l.active && l.worktree).length > 0;
+    if (hasActiveWorktreeLoops) {
+      startPolling();
+    } else {
+      stopPolling();
+    }
+  });
+  onCleanup(() => {
+    unsub();
+    stopPolling();
+  });
+  const hasContent = createMemo(() => {
+    if (hasPlan())
+      return true;
+    if (props.opts.showLoops && loops().length > 0)
+      return true;
+    if (graphStatusFormatted())
+      return true;
+    return false;
+  });
+  const activeCount = createMemo(() => {
+    return loops().filter((l) => l.active).length;
+  });
+  return _$createComponent(Show, {
+    get when() {
+      return props.opts.sidebar;
+    },
+    get children() {
+      var _el$104 = _$createElement("box"), _el$105 = _$createElement("box"), _el$107 = _$createElement("text"), _el$108 = _$createElement("b");
+      _$insertNode(_el$104, _el$105);
+      _$insertNode(_el$105, _el$107);
+      _$setProp(_el$105, "flexDirection", "row");
+      _$setProp(_el$105, "gap", 1);
+      _$setProp(_el$105, "onMouseDown", () => hasContent() && setOpen((x) => !x));
+      _$insert(_el$105, _$createComponent(Show, {
+        get when() {
+          return hasContent();
+        },
+        get children() {
+          var _el$106 = _$createElement("text");
+          _$insert(_el$106, () => open() ? "▼" : "▶");
+          _$effect((_$p) => _$setProp(_el$106, "fg", theme().text, _$p));
+          return _el$106;
+        }
+      }), _el$107);
+      _$insertNode(_el$107, _el$108);
+      _$insert(_el$108, title);
+      _$insert(_el$107, (() => {
+        var _c$2 = _$memo(() => !!(!open() && hasPlan()));
+        return () => _c$2() ? (() => {
+          var _el$118 = _$createElement("span");
+          _$insertNode(_el$118, _$createTextNode(` · plan`));
+          _$effect((_$p) => _$setProp(_el$118, "style", {
+            fg: theme().info
+          }, _$p));
+          return _el$118;
+        })() : "";
+      })(), null);
+      _$insert(_el$107, (() => {
+        var _c$3 = _$memo(() => !!(!open() && graphStatusFormatted() && graphStatusFormatted().text.includes("ready")));
+        return () => _c$3() ? (() => {
+          var _el$120 = _$createElement("span");
+          _$insertNode(_el$120, _$createTextNode(` · ready`));
+          _$effect((_$p) => _$setProp(_el$120, "style", {
+            fg: theme().success
+          }, _$p));
+          return _el$120;
+        })() : "";
+      })(), null);
+      _$insert(_el$107, (() => {
+        var _c$4 = _$memo(() => !!(!open() && activeCount() > 0));
+        return () => _c$4() ? (() => {
+          var _el$122 = _$createElement("span");
+          _$insert(_el$122, () => ` (${activeCount()} active)`);
+          _$effect((_$p) => _$setProp(_el$122, "style", {
+            fg: theme().textMuted
+          }, _$p));
+          return _el$122;
+        })() : "";
+      })(), null);
+      _$insert(_el$104, _$createComponent(Show, {
+        get when() {
+          return open();
+        },
+        get children() {
+          return [_$createComponent(Show, {
+            get when() {
+              return hasPlan();
+            },
+            get children() {
+              var _el$109 = _$createElement("box"), _el$110 = _$createElement("text"), _el$112 = _$createElement("text");
+              _$insertNode(_el$109, _el$110);
+              _$insertNode(_el$109, _el$112);
+              _$setProp(_el$109, "flexDirection", "row");
+              _$setProp(_el$109, "gap", 1);
+              _$setProp(_el$109, "onMouseUp", () => {
+                if (!pid || !props.sessionId)
+                  return;
+                const plan = readPlan(pid, props.sessionId);
+                if (!plan) {
+                  props.api.ui.toast({
+                    message: "Plan not found",
+                    variant: "info",
+                    duration: 3000
+                  });
+                  return;
+                }
+                const refreshSidebar = refreshSidebarData;
+                props.api.ui.dialog.setSize("xlarge");
+                props.api.ui.dialog.replace(() => _$createComponent(PlanViewerDialog, {
+                  get api() {
+                    return props.api;
+                  },
+                  planContent: plan,
+                  projectId: pid,
+                  get sessionId() {
+                    return props.sessionId;
+                  },
+                  onRefresh: refreshSidebar
+                }));
+              });
+              _$insertNode(_el$110, _$createTextNode(`\uD83D\uDCCB`));
+              _$setProp(_el$110, "flexShrink", 0);
+              _$insertNode(_el$112, _$createTextNode(`Plan`));
+              _$effect((_p$) => {
+                var _v$35 = {
+                  fg: theme().info
+                }, _v$36 = theme().text;
+                _v$35 !== _p$.e && (_p$.e = _$setProp(_el$110, "style", _v$35, _p$.e));
+                _v$36 !== _p$.t && (_p$.t = _$setProp(_el$112, "fg", _v$36, _p$.t));
+                return _p$;
+              }, {
+                e: undefined,
+                t: undefined
+              });
+              return _el$109;
+            }
+          }), _$createComponent(Show, {
+            get when() {
+              return graphStatusFormatted();
+            },
+            get children() {
+              var _el$114 = _$createElement("box"), _el$115 = _$createElement("text"), _el$117 = _$createElement("text");
+              _$insertNode(_el$114, _el$115);
+              _$insertNode(_el$114, _el$117);
+              _$setProp(_el$114, "flexDirection", "row");
+              _$setProp(_el$114, "gap", 1);
+              _$insertNode(_el$115, _$createTextNode(`•`));
+              _$setProp(_el$115, "flexShrink", 0);
+              _$setProp(_el$117, "wrapMode", "word");
+              _$insert(_el$117, () => graphStatusFormatted().text);
+              _$effect((_p$) => {
+                var _v$37 = {
+                  fg: theme()[graphStatusFormatted().color]
+                }, _v$38 = theme().text;
+                _v$37 !== _p$.e && (_p$.e = _$setProp(_el$115, "style", _v$37, _p$.e));
+                _v$38 !== _p$.t && (_p$.t = _$setProp(_el$117, "fg", _v$38, _p$.t));
+                return _p$;
+              }, {
+                e: undefined,
+                t: undefined
+              });
+              return _el$114;
+            }
+          }), _$createComponent(Show, {
+            get when() {
+              return _$memo(() => !!props.opts.showLoops)() && loops().length > 0;
+            },
+            get children() {
+              return _$createComponent(For, {
+                get each() {
+                  return loops();
+                },
+                children: (loop) => (() => {
+                  var _el$123 = _$createElement("box"), _el$124 = _$createElement("text"), _el$126 = _$createElement("text"), _el$127 = _$createTextNode(` `), _el$128 = _$createElement("span");
+                  _$insertNode(_el$123, _el$124);
+                  _$insertNode(_el$123, _el$126);
+                  _$setProp(_el$123, "flexDirection", "row");
+                  _$setProp(_el$123, "gap", 1);
+                  _$setProp(_el$123, "onMouseUp", () => {
+                    if (loop.worktree) {
+                      props.api.ui.dialog.setSize("medium");
+                      props.api.ui.dialog.replace(() => _$createComponent(LoopDetailsDialog, {
+                        get api() {
+                          return props.api;
+                        },
+                        loop,
+                        onRefresh: refreshSidebarData
+                      }));
+                    } else {
+                      props.api.route.navigate("session", {
+                        sessionID: loop.sessionId
+                      });
+                    }
+                  });
+                  _$insertNode(_el$124, _$createTextNode(`•`));
+                  _$setProp(_el$124, "flexShrink", 0);
+                  _$insertNode(_el$126, _el$127);
+                  _$insertNode(_el$126, _el$128);
+                  _$setProp(_el$126, "wrapMode", "word");
+                  _$insert(_el$126, () => truncateMiddle(loop.name, 25), _el$127);
+                  _$insert(_el$128, () => statusText(loop));
+                  _$effect((_p$) => {
+                    var _v$39 = {
+                      fg: dot(loop)
+                    }, _v$40 = theme().text, _v$41 = {
+                      fg: theme().textMuted
+                    };
+                    _v$39 !== _p$.e && (_p$.e = _$setProp(_el$124, "style", _v$39, _p$.e));
+                    _v$40 !== _p$.t && (_p$.t = _$setProp(_el$126, "fg", _v$40, _p$.t));
+                    _v$41 !== _p$.a && (_p$.a = _$setProp(_el$128, "style", _v$41, _p$.a));
+                    return _p$;
+                  }, {
+                    e: undefined,
+                    t: undefined,
+                    a: undefined
+                  });
+                  return _el$123;
+                })()
+              });
+            }
+          })];
+        }
+      }), null);
+      _$effect((_$p) => _$setProp(_el$107, "fg", theme().text, _$p));
+      return _el$104;
+    }
+  });
+}
+var id = "oc-forge";
+var tui = async (api) => {
+  const tuiConfig = loadTuiConfig();
+  const opts = {
+    sidebar: tuiConfig?.sidebar ?? true,
+    showLoops: tuiConfig?.showLoops ?? true,
+    showVersion: tuiConfig?.showVersion ?? true
+  };
+  if (!opts.sidebar)
+    return;
+  api.command.register(() => {
+    const directory = api.state.path.directory;
+    const pid = resolveProjectId(directory);
+    if (!pid)
+      return [];
+    const states = readLoopStates(pid);
+    if (states.length === 0)
+      return [];
+    return [{
+      title: "Forge: Show loops",
+      value: "forge.loops.show",
+      description: `${states.length} loop${states.length !== 1 ? "s" : ""}`,
+      category: "Forge",
+      onSelect: () => {
+        const worktreeLoops = states.filter((l) => l.worktree);
+        const loopOptions = worktreeLoops.map((l) => {
+          const status = l.active ? l.phase : l.terminationReason?.replace(/_/g, " ") ?? "ended";
+          return {
+            title: l.name,
+            value: l.name,
+            description: status
+          };
+        });
+        const showLoopList = () => {
+          api.ui.dialog.setSize("large");
+          api.ui.dialog.replace(() => _$createComponent(api.ui.DialogSelect, {
+            title: "Loops",
+            options: loopOptions,
+            onSelect: (opt) => {
+              const loopName = opt.value;
+              const freshLoop = pid ? readLoopByName(pid, loopName) : null;
+              if (freshLoop) {
+                api.ui.dialog.setSize("medium");
+                api.ui.dialog.replace(() => _$createComponent(LoopDetailsDialog, {
+                  api,
+                  loop: freshLoop,
+                  onBack: showLoopList,
+                  onRefresh: () => {}
+                }));
+              } else {
+                api.ui.dialog.clear();
+              }
+            }
+          }));
+        };
+        showLoopList();
+      }
+    }];
+  });
+  api.command.register(() => {
+    const route = api.route.current;
+    if (route.name !== "session")
+      return [];
+    const directory = api.state.path.directory;
+    const pid = resolveProjectId(directory);
+    if (!pid)
+      return [];
+    const sessionID = route.params?.sessionID;
+    if (!sessionID)
+      return [];
+    const plan = readPlan(pid, sessionID);
+    if (!plan)
+      return [];
+    return [{
+      title: "Forge: View plan",
+      value: "forge.plan.view",
+      description: "View cached plan for this session",
+      category: "Forge",
+      onSelect: () => {
+        const freshPlan = readPlan(pid, sessionID);
+        if (!freshPlan) {
+          api.ui.toast({
+            message: "No plan found for this session",
+            variant: "info",
+            duration: 3000
+          });
+          return;
+        }
+        api.ui.dialog.setSize("large");
+        api.ui.dialog.replace(() => _$createComponent(PlanViewerDialog, {
+          api,
+          planContent: freshPlan,
+          projectId: pid,
+          sessionId: sessionID
+        }));
+      }
+    }];
+  });
+  api.slots.register({
+    order: 150,
+    slots: {
+      sidebar_content(_ctx, slotProps) {
+        return _$createComponent(Sidebar, {
+          api,
+          opts,
+          get sessionId() {
+            return slotProps.session_id;
+          }
+        });
+      }
+    }
+  });
+};
+var plugin = {
+  id,
+  tui
+};
+var tui_default = plugin;
+export {
+  readLoopStates,
+  readLoopByName,
+  tui_default as default
+};