@zcy2nn/agent-forge 1.0.1

package/dist/tools/ast-grep/types.d.ts

@@ -0,0 +1,30 @@
+export declare const CLI_LANGUAGES: readonly ["bash", "c", "cpp", "csharp", "css", "elixir", "go", "haskell", "html", "java", "javascript", "json", "kotlin", "lua", "nix", "php", "python", "ruby", "rust", "scala", "solidity", "swift", "typescript", "tsx", "yaml"];
+export type CliLanguage = (typeof CLI_LANGUAGES)[number];
+export interface CliMatch {
+    file: string;
+    range: {
+        byteOffset: {
+            start: number;
+            end: number;
+        };
+        start: {
+            line: number;
+            column: number;
+        };
+        end: {
+            line: number;
+            column: number;
+        };
+    };
+    lines: string;
+    text: string;
+    replacement?: string;
+    language: string;
+}
+export interface SgResult {
+    matches: CliMatch[];
+    totalMatches: number;
+    truncated: boolean;
+    truncatedReason?: 'timeout' | 'max_output_bytes' | 'max_matches';
+    error?: string;
+}

package/dist/tools/ast-grep/utils.d.ts

@@ -0,0 +1,4 @@
+import type { CliLanguage, SgResult } from './types';
+export declare function formatSearchResult(result: SgResult): string;
+export declare function formatReplaceResult(result: SgResult, isDryRun: boolean): string;
+export declare function getEmptyResultHint(pattern: string, lang: CliLanguage): string | null;

package/dist/tools/council.d.ts

@@ -0,0 +1,10 @@
+import { type PluginInput, type ToolDefinition } from '@opencode-ai/plugin';
+import type { CouncilManager } from '../council/council-manager';
+/**
+ * Creates the council_session tool for multi-LLM orchestration.
+ *
+ * This tool triggers a full council session: parallel councillors →
+ * formatted results returned to the council agent for synthesis.
+ * Available to the council agent.
+ */
+export declare function createCouncilTool(_ctx: PluginInput, councilManager: CouncilManager): Record<string, ToolDefinition>;

package/dist/tools/index.d.ts

@@ -0,0 +1,6 @@
+export { ast_grep_replace, ast_grep_search } from './ast-grep';
+export { createCouncilTool } from './council';
+export type { PresetManager } from './preset-manager';
+export { createPresetManager } from './preset-manager';
+export { createSkillTool } from './skill';
+export { createWebfetchTool } from './smartfetch';

package/dist/tools/preset-manager.d.ts

@@ -0,0 +1,27 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { PluginConfig } from '../config';
+/**
+ * Creates a preset manager for the /preset slash command.
+ *
+ * Uses the OpenCode SDK's client.config.update() to change agent models
+ * and temperatures without restarting. The server invalidates its agent
+ * cache and re-reads config on the next prompt.
+ *
+ * Note: activePreset is tracked in-memory only and resets on plugin reload.
+ * If the user manually edits config or another mechanism changes agents,
+ * this tracker may become stale until the next /preset call.
+ */
+export declare function createPresetManager(ctx: PluginInput, config: PluginConfig): {
+    handleCommandExecuteBefore: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+    registerCommand: (opencodeConfig: Record<string, unknown>) => void;
+};
+export type PresetManager = ReturnType<typeof createPresetManager>;

package/dist/tools/skill.d.ts

@@ -0,0 +1,9 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+import { type PluginConfig } from '../config';
+/**
+ * Create the skill loading tool.
+ *
+ * @param config - Plugin config, used for agent → skill permission resolution.
+ * @returns A record containing the `skill` tool definition.
+ */
+export declare function createSkillTool(config: PluginConfig): Record<string, ToolDefinition>;

package/dist/tools/smartfetch/binary.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryFetch } from './types';
+export declare function buildBinaryResultMessage(fetchResult: BinaryFetch, savedPath?: string): string;
+export declare function saveBinary(binaryDir: string, data: Uint8Array, contentType: string, filename?: string): Promise<string>;

package/dist/tools/smartfetch/cache.d.ts

@@ -0,0 +1,6 @@
+import { LRUCache } from 'lru-cache';
+import type { FetchResult } from './types';
+export declare const CACHE: LRUCache<string, FetchResult, unknown>;
+export declare function buildCacheKey(url: string, extractMain: boolean, preferLlmsTxt: 'auto' | 'always' | 'never', saveBinary: boolean): string;
+export declare function cacheFetchResult(fetchResult: FetchResult, extractMain: boolean, preferLlmsTxt: 'auto' | 'always' | 'never', saveBinary: boolean): void;
+export declare function isInvalidLlmsResult(fetchResult: FetchResult | undefined): boolean;

package/dist/tools/smartfetch/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const DOCS_HOST_SUFFIXES: string[];
+export declare const DOCS_HOST_PREFIXES: string[];
+export declare const MAX_REDIRECTS = 10;
+export declare const MAX_RESPONSE_BYTES: number;
+export declare const MAX_BINARY_DOWNLOAD_BYTES: number;
+export declare const DEFAULT_TIMEOUT_SECONDS = 30;
+export declare const MAX_TIMEOUT_SECONDS = 120;
+export declare const MAX_LLMS_PROBE_TIMEOUT_MS = 8000;
+export declare const MAX_MODEL_CONTENT_CHARS = 100000;
+export declare const DEFAULT_ACCEPT_LANGUAGE = "en;q=0.8,*;q=0.5";
+export declare const BINARY_PREFIXES: string[];
+export declare const WEBFETCH_DESCRIPTION = "Fetch a URL with better extraction for static/docs pages. Supports llms.txt probing, content-focused HTML extraction, metadata, redirects, and an optional prompt processed by a cheap secondary model.";

package/dist/tools/smartfetch/index.d.ts

@@ -0,0 +1,3 @@
+export { WEBFETCH_DESCRIPTION } from './constants';
+export { createWebfetchTool } from './tool';
+export type { BinaryFetch, CachedFetch, FetchResult, SmartfetchOptions, } from './types';

package/dist/tools/smartfetch/network.d.ts

@@ -0,0 +1,38 @@
+import type { BinaryFetch, DecodedBody, FetchResult, FetchWithRedirectsResult, LlmsProbeResult } from './types';
+export declare function normalizeUrl(input: string): {
+    url: string;
+    upgradedToHttps: boolean;
+    fallbackUrl: string | undefined;
+    originalUrl: string;
+};
+export declare function isDocsLikeUrl(url: URL): boolean;
+export declare function buildPermissionPatterns(normalized: ReturnType<typeof normalizeUrl>, shouldProbeLlmsTxt: boolean): string[];
+export declare function buildAllowedOrigins(patterns: string[]): Set<string>;
+export declare function canUseCanonicalCacheAlias(baseUrl: string, aliasUrl: string): boolean;
+export declare function isBinaryContentType(contentType: string): boolean;
+export declare function getBinaryKind(contentType: string): BinaryFetch['binaryKind'];
+export declare function looksLikeHtmlText(text: string): boolean;
+export declare function runWithScopedTimeout<T>(parentSignal: AbortSignal, timeoutMs: number, fn: (signal: AbortSignal) => Promise<T>): Promise<T>;
+export declare function readBodyLimited(response: Response, maxBytes?: number): Promise<{
+    data: Uint8Array<ArrayBuffer>;
+    truncated: boolean;
+}>;
+export declare function fetchWithRedirects(url: string, _timeoutMs: number, format: 'text' | 'markdown' | 'html', signal: AbortSignal, extraHeaders?: Record<string, string>, method?: 'GET' | 'HEAD', allowedOrigins?: Set<string>): Promise<FetchWithRedirectsResult>;
+export declare function fetchWithUpgradeFallback(normalized: ReturnType<typeof normalizeUrl>, timeoutMs: number, format: 'text' | 'markdown' | 'html', signal: AbortSignal, extraHeaders?: Record<string, string>, method?: 'GET' | 'HEAD', allowedOrigins?: Set<string>): Promise<{
+    result: FetchWithRedirectsResult;
+    upgradedToHttps: boolean;
+}>;
+export declare function isHtmlLikeContentType(contentType: string): boolean;
+export declare function decodeBody(data: Uint8Array, charset: string | undefined, contentType?: string): DecodedBody;
+export declare function looksLikeTextBody(data: Uint8Array): boolean;
+export declare function isGenericBinaryMime(contentType: string): boolean;
+export declare function extractHeaderMetadata(headers: Headers, finalUrl: string): {
+    contentType: string | undefined;
+    charset: string | undefined;
+    etag: string | undefined;
+    lastModified: string | undefined;
+    contentLength: number | undefined;
+    filename: string | undefined;
+};
+export declare function buildConditionalHeaders(cached: FetchResult | undefined): Record<string, string> | undefined;
+export declare function probeLlmsText(url: URL, timeoutMs: number, signal: AbortSignal, fallbackOrigin?: string): Promise<LlmsProbeResult>;

package/dist/tools/smartfetch/secondary-model.d.ts

@@ -0,0 +1,28 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { CachedFetch, SecondaryModel } from './types';
+type OpenCodeClient = PluginInput['client'];
+export declare function readSecondaryModelFromConfig(directory: string): Promise<SecondaryModel[]>;
+export declare function decideSecondaryModelUse(fetchResult: CachedFetch, prompt: string | undefined, secondaryModels: SecondaryModel[]): {
+    use: boolean;
+    reason: "no_prompt";
+} | {
+    use: boolean;
+    reason: "no_secondary_model_configured";
+} | {
+    use: boolean;
+    reason: "empty_content";
+} | {
+    use: boolean;
+    reason: "content_too_short";
+} | {
+    use: boolean;
+    reason: "prompt_present";
+};
+export declare function runSecondaryModelWithFallback(client: OpenCodeClient, directory: string, models: SecondaryModel[], prompt: string, content: string): Promise<{
+    model: SecondaryModel;
+    text: string;
+    inputTruncated: boolean;
+    inputChars: number;
+    sourceChars: number;
+}>;
+export {};

package/dist/tools/smartfetch/tool.d.ts

@@ -0,0 +1,3 @@
+import { type PluginInput, type ToolDefinition } from '@opencode-ai/plugin';
+import type { SmartfetchOptions } from './types';
+export declare function createWebfetchTool(pluginCtx: PluginInput, options?: SmartfetchOptions): ToolDefinition;

package/dist/tools/smartfetch/types.d.ts

@@ -0,0 +1,122 @@
+export type SmartfetchOptions = {
+    binaryDir?: string;
+};
+export type SecondaryModel = {
+    providerID: string;
+    modelID: string;
+};
+export type RedirectStep = {
+    from: string;
+    to: string;
+    status: number;
+};
+export type CachedFetch = {
+    requestedUrl: string;
+    finalUrl: string;
+    statusCode: number;
+    contentType: string;
+    charset?: string;
+    etag?: string;
+    lastModified?: string;
+    contentLength?: number;
+    filename?: string;
+    canonicalUrl?: string;
+    headings?: string[];
+    title?: string;
+    rawContent: string;
+    markdown: string;
+    text: string;
+    html: string;
+    extractedMain: boolean;
+    usedLlmsTxt: boolean;
+    sourceKind: 'llms_txt' | 'html' | 'text';
+    upgradedToHttps: boolean;
+    redirectChain: RedirectStep[];
+    truncated: boolean;
+    wordCount: number;
+    qualitySignals?: string[];
+    llmsProbeError?: string;
+    llmsProbeTruncated?: boolean;
+    cacheRevalidated?: boolean;
+    upstreamStatusCode?: number;
+    cacheHit?: boolean;
+    decodedCharset?: string;
+    decodeFallback?: boolean;
+    decodeWarning?: string;
+    secondaryModelInputTruncated?: boolean;
+    secondaryModelInputChars?: number;
+    secondaryModelSourceChars?: number;
+};
+export type BinaryFetch = {
+    requestedUrl: string;
+    finalUrl: string;
+    statusCode: number;
+    contentType: string;
+    charset?: string;
+    etag?: string;
+    lastModified?: string;
+    contentLength?: number;
+    filename?: string;
+    canonicalUrl?: string;
+    redirectChain: RedirectStep[];
+    upgradedToHttps: boolean;
+    truncated: boolean;
+    binary: true;
+    binaryKind: 'image' | 'audio' | 'video' | 'pdf' | 'binary';
+    downloadLimitBytes?: number;
+    metadataOnly?: boolean;
+    data?: Uint8Array;
+    llmsProbeError?: string;
+    llmsProbeTruncated?: boolean;
+    cacheRevalidated?: boolean;
+    upstreamStatusCode?: number;
+    cacheHit?: boolean;
+};
+export type FetchResult = CachedFetch | BinaryFetch;
+export type DecodedBody = {
+    text: string;
+    decodedCharset: string;
+    decodeFallback: boolean;
+    decodeWarning?: string;
+};
+export type ExtractedContent = {
+    title?: string;
+    rawContent: string;
+    markdown: string;
+    text: string;
+    html: string;
+    extractedMain: boolean;
+    canonicalUrl?: string;
+    headings?: string[];
+};
+export type FetchWithRedirectsResult = {
+    blockedRedirect: true;
+    redirectUrl: string;
+    statusCode: number;
+    redirectChain: RedirectStep[];
+} | {
+    response: Response;
+    finalUrl: string;
+    redirectChain: RedirectStep[];
+};
+export type LlmsProbeResult = {
+    url: string;
+    statusCode: number;
+    redirectChain: RedirectStep[];
+    text: string;
+    headers: {
+        contentType?: string;
+        charset?: string;
+        etag?: string;
+        lastModified?: string;
+        contentLength?: number;
+        filename?: string;
+    };
+    truncated: boolean;
+    decodedCharset: string;
+    decodeFallback: boolean;
+    decodeWarning?: string;
+    upgradedToHttps: boolean;
+} | {
+    error?: string;
+};

package/dist/tools/smartfetch/utils.d.ts

@@ -0,0 +1,18 @@
+import type { CachedFetch, ExtractedContent } from './types';
+export declare function wordCount(text: string): number;
+export declare function frontmatter(metadata: Record<string, unknown>): string;
+export declare function trimBlankRuns(input: string): string;
+export declare function cleanHeadingText(input: string): string;
+export declare function cleanFetchedMarkdown(input: string): string;
+export declare function cleanFetchedText(input: string): string;
+export declare function escapeHtml(input: string): string;
+export declare function withTruncationMarker(content: string, format: 'text' | 'markdown' | 'html', truncated: boolean): string;
+export declare function joinRenderedContent(metadata: string, content: string, format: 'text' | 'markdown' | 'html'): string;
+export declare function renderMessageForFormat(content: string, format: 'text' | 'markdown' | 'html'): string;
+export declare function buildRedirectResultMessage(originalUrl: string, redirectUrl: string, statusCode: number): string;
+export declare function buildLlmsRequiredMessage(originalUrl: string, reason?: string): string;
+export declare function extractFromHtml(html: string, finalUrl: string, extractMain: boolean): Promise<ExtractedContent>;
+export declare function inferCanonicalUrlFromText(content: string, finalUrl: string): string | undefined;
+export declare function extractHeadingsFromMarkdown(content: string): string[] | undefined;
+export declare function detectQualitySignals(fetchResult: Pick<CachedFetch, 'text' | 'markdown' | 'rawContent' | 'wordCount' | 'sourceKind' | 'extractedMain'>): string[];
+export declare function pickContent(fetchResult: CachedFetch, format: 'text' | 'markdown' | 'html'): string;

package/dist/tui-state.d.ts

@@ -0,0 +1,15 @@
+export interface TuiSnapshot {
+    version: 1;
+    updatedAt: number;
+    agentModels: Record<string, string>;
+}
+export declare function getTuiStatePath(): string;
+export declare function readTuiSnapshot(): TuiSnapshot;
+export declare function readTuiSnapshotAsync(): Promise<TuiSnapshot>;
+export declare function recordTuiAgentModels(input: {
+    agentModels: Record<string, string>;
+}): void;
+export declare function recordTuiAgentModel(input: {
+    agentName: string;
+    model: string;
+}): void;

package/dist/tui.d.ts

@@ -0,0 +1,8 @@
+import type { TuiPluginModule } from '@opencode-ai/plugin/tui';
+import { type TuiSnapshot } from './tui-state';
+export declare function formatSidebarModelName(model: string): string;
+export declare function getSidebarAgentNames(snapshot: TuiSnapshot): string[];
+declare const plugin: TuiPluginModule & {
+    id: string;
+};
+export default plugin;

package/dist/tui.js

@@ -0,0 +1,248 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tui.ts
+import { createElement, insert, setProp } from "@opentui/solid";
+
+// src/config/constants.ts
+var SUBAGENT_NAMES = [
+  "researcher",
+  "reviewer",
+  "implementer",
+  "council",
+  "councillor"
+];
+var ORCHESTRATOR_NAME = "orchestrator";
+var ALL_AGENT_NAMES = [ORCHESTRATOR_NAME, ...SUBAGENT_NAMES];
+var PROTECTED_AGENTS = new Set([
+  "orchestrator",
+  "researcher",
+  "reviewer",
+  "implementer",
+  "councillor"
+]);
+var DEFAULT_MODELS = {
+  orchestrator: undefined,
+  reviewer: "openai/gpt-5.5",
+  researcher: "openai/gpt-5.4-mini",
+  implementer: "openai/gpt-5.4-mini",
+  council: "openai/gpt-5.4-mini",
+  councillor: "openai/gpt-5.4-mini"
+};
+var POLL_INTERVAL_BACKGROUND_MS = 2000;
+var DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
+var MAX_POLL_TIME_MS = 5 * 60 * 1000;
+var DEFAULT_MAX_SUBAGENT_DEPTH = 3;
+var PHASE_REMINDER_TEXT = `!IMPORTANT! Recall the workflow rules:
+Understand → choose the best parallelized path based on your capabilities and agents delegation rules → recall session reuse rules → execute → verify.
+If delegating, launch the specialist in the same turn you mention it !END!`;
+var TMUX_SPAWN_DELAY_MS = 500;
+var COUNCILLOR_STAGGER_MS = 250;
+var DEFAULT_DISABLED_AGENTS = ["council"];
+
+// src/tui-state.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var STATE_DIR = "agent-forge";
+var STATE_FILE = "tui-state.json";
+function dataDir() {
+  return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
+}
+function getTuiStatePath() {
+  return path.join(dataDir(), "opencode", "storage", STATE_DIR, STATE_FILE);
+}
+function emptySnapshot() {
+  return {
+    version: 1,
+    updatedAt: Date.now(),
+    agentModels: {}
+  };
+}
+function parseSnapshot(value) {
+  const parsed = JSON.parse(value);
+  if (parsed?.version !== 1)
+    return emptySnapshot();
+  return {
+    version: 1,
+    updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : Date.now(),
+    agentModels: parsed.agentModels ?? {}
+  };
+}
+function readTuiSnapshot() {
+  try {
+    return parseSnapshot(fs.readFileSync(getTuiStatePath(), "utf8"));
+  } catch {
+    return emptySnapshot();
+  }
+}
+async function readTuiSnapshotAsync() {
+  try {
+    return parseSnapshot(await fs.promises.readFile(getTuiStatePath(), "utf8"));
+  } catch {
+    return emptySnapshot();
+  }
+}
+function writeTuiSnapshot(snapshot) {
+  try {
+    const filePath = getTuiStatePath();
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(snapshot)}
+`);
+  } catch {}
+}
+function updateSnapshot(mutator) {
+  const snapshot = readTuiSnapshot();
+  mutator(snapshot);
+  snapshot.updatedAt = Date.now();
+  writeTuiSnapshot(snapshot);
+}
+function recordTuiAgentModels(input) {
+  updateSnapshot((snapshot) => {
+    snapshot.agentModels = { ...input.agentModels };
+  });
+}
+function recordTuiAgentModel(input) {
+  updateSnapshot((snapshot) => {
+    snapshot.agentModels[input.agentName] = input.model;
+  });
+}
+
+// src/tui.ts
+var PLUGIN_NAME = "agent-forge";
+var FALLBACK_SIDEBAR_AGENTS = SUBAGENT_NAMES.filter((agent) => agent !== "councillor" && agent !== "council" && !DEFAULT_DISABLED_AGENTS.includes(agent));
+var BORDER = { type: "single" };
+async function readPackageVersion() {
+  try {
+    const packageJson = await Bun.file(new URL("../package.json", import.meta.url)).json();
+    return typeof packageJson.version === "string" ? packageJson.version : undefined;
+  } catch {
+    return;
+  }
+}
+function element(tag, props, children = []) {
+  const node = createElement(tag);
+  for (const [key, value] of Object.entries(props)) {
+    if (value !== undefined)
+      setProp(node, key, value);
+  }
+  for (const child of children) {
+    if (child === null || child === undefined || child === false)
+      continue;
+    insert(node, child);
+  }
+  return node;
+}
+function text(props, children) {
+  return element("text", props, children);
+}
+function box(props, children = []) {
+  return element("box", props, children);
+}
+function truncate(value, max = 24) {
+  return value.length > max ? `${value.slice(0, max - 1)}…` : value;
+}
+function formatSidebarModelName(model) {
+  const lastSlash = model.lastIndexOf("/");
+  return lastSlash === -1 ? model : model.slice(lastSlash + 1);
+}
+function getSidebarAgentNames(snapshot) {
+  const configuredAgents = Object.keys(snapshot.agentModels);
+  return configuredAgents.length > 0 ? configuredAgents : FALLBACK_SIDEBAR_AGENTS;
+}
+function row(label, value, theme, valueColor) {
+  return box({ width: "100%", flexDirection: "row", justifyContent: "space-between" }, [
+    text({ fg: theme.textMuted }, [label]),
+    text({ fg: valueColor ?? theme.text }, [value])
+  ]);
+}
+function renderSidebar(snapshot, version, theme) {
+  return box({
+    width: "100%",
+    flexDirection: "column",
+    border: BORDER,
+    borderColor: theme.borderActive,
+    paddingTop: 1,
+    paddingBottom: 1,
+    paddingLeft: 1,
+    paddingRight: 1
+  }, [
+    box({
+      width: "100%",
+      flexDirection: "row",
+      justifyContent: "space-between",
+      alignItems: "center"
+    }, [
+      box({ paddingLeft: 1, paddingRight: 1, backgroundColor: theme.accent }, [text({ fg: theme.background }, ["OMO-Slim"])]),
+      text({ fg: theme.textMuted }, [`v${version}`])
+    ]),
+    box({ width: "100%", marginTop: 1 }, [
+      text({ fg: theme.text }, ["Agents"])
+    ]),
+    ...getSidebarAgentNames(snapshot).map((agentName) => {
+      const model = snapshot.agentModels[agentName] ?? "pending";
+      return row(agentName, truncate(formatSidebarModelName(model), 26), theme, theme.textMuted);
+    })
+  ]);
+}
+var plugin = {
+  id: `${PLUGIN_NAME}:tui`,
+  tui: async (api, _options, meta) => {
+    const version = meta.version ?? await readPackageVersion() ?? "dev";
+    let snapshot = readTuiSnapshot();
+    const renderTimer = setInterval(async () => {
+      try {
+        snapshot = await readTuiSnapshotAsync();
+        api.renderer.requestRender();
+      } catch {}
+    }, 1000);
+    api.lifecycle.onDispose(() => {
+      clearInterval(renderTimer);
+    });
+    api.slots.register({
+      order: 900,
+      slots: {
+        sidebar_content() {
+          return renderSidebar(snapshot, version, api.theme.current);
+        }
+      }
+    });
+  }
+};
+var tui_default = plugin;
+export {
+  getSidebarAgentNames,
+  formatSidebarModelName,
+  tui_default as default
+};