oh-my-opencode-slim 1.0.5 → 1.0.7

package/dist/tui.js

@@ -34,8 +34,695 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/tui.ts
 import { createElement, insert, setProp } from "@opentui/solid";
+
+// src/config/constants.ts
+var AGENT_ALIASES = {
+  explore: "explorer",
+  "frontend-ui-ux-engineer": "designer"
+};
+var SUBAGENT_NAMES = [
+  "explorer",
+  "librarian",
+  "oracle",
+  "designer",
+  "fixer",
+  "observer",
+  "council",
+  "councillor"
+];
+var ORCHESTRATOR_NAME = "orchestrator";
+var ALL_AGENT_NAMES = [ORCHESTRATOR_NAME, ...SUBAGENT_NAMES];
+var PROTECTED_AGENTS = new Set(["orchestrator", "councillor"]);
+var DEFAULT_MODELS = {
+  orchestrator: undefined,
+  oracle: "openai/gpt-5.5",
+  librarian: "openai/gpt-5.4-mini",
+  explorer: "openai/gpt-5.4-mini",
+  designer: "openai/gpt-5.4-mini",
+  fixer: "openai/gpt-5.4-mini",
+  observer: "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 = ["observer"];
+
+// src/config/loader.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// src/cli/paths.ts
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+function getDefaultOpenCodeConfigDir() {
+  const userConfigDir = process.env.XDG_CONFIG_HOME ? process.env.XDG_CONFIG_HOME : join(homedir(), ".config");
+  return join(userConfigDir, "opencode");
+}
+function getCustomOpenCodeConfigDir() {
+  const configDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  return configDir || undefined;
+}
+function getConfigSearchDirs() {
+  const dirs = [getCustomOpenCodeConfigDir(), getDefaultOpenCodeConfigDir()];
+  return dirs.filter((dir, index) => {
+    return Boolean(dir) && dirs.indexOf(dir) === index;
+  });
+}
+function getOpenCodeConfigPaths() {
+  const configDir = getDefaultOpenCodeConfigDir();
+  return [join(configDir, "opencode.json"), join(configDir, "opencode.jsonc")];
+}
+// src/config/council-schema.ts
+import { z } from "zod";
+var ModelIdSchema = z.string().regex(/^[^/\s]+\/[^\s]+$/, 'Expected provider/model format (e.g. "openai/gpt-5.4-mini")');
+var CouncillorConfigSchema = z.object({
+  model: ModelIdSchema.describe('Model ID in provider/model format (e.g. "openai/gpt-5.4-mini")'),
+  variant: z.string().optional(),
+  prompt: z.string().optional().describe("Optional role/guidance injected into the councillor user prompt")
+});
+var CouncilPresetSchema = z.record(z.string(), z.record(z.string(), z.unknown())).transform((entries, ctx) => {
+  const councillors = {};
+  for (const [key, raw] of Object.entries(entries)) {
+    if (key === "master")
+      continue;
+    if (key === "councillors" && typeof raw === "object" && raw !== null) {
+      for (const [innerKey, innerRaw] of Object.entries(raw)) {
+        const innerParsed = CouncillorConfigSchema.safeParse(innerRaw);
+        if (!innerParsed.success) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Invalid councillor "${innerKey}" (nested under legacy "councillors" key): ${innerParsed.error.issues.map((i) => i.message).join(", ")}`
+          });
+          return z.NEVER;
+        }
+        councillors[innerKey] = innerParsed.data;
+      }
+      continue;
+    }
+    const parsed = CouncillorConfigSchema.safeParse(raw);
+    if (!parsed.success) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Invalid councillor "${key}": ${parsed.error.issues.map((i) => i.message).join(", ")}`
+      });
+      return z.NEVER;
+    }
+    councillors[key] = parsed.data;
+  }
+  return councillors;
+});
+var CouncillorExecutionModeSchema = z.enum(["parallel", "serial"]).default("parallel").describe('Execution mode for councillors. Use "serial" for single-model systems to avoid conflicts. ' + 'Use "parallel" for multi-model systems for faster execution.');
+var CouncilConfigSchema = z.object({
+  presets: z.record(z.string(), CouncilPresetSchema),
+  timeout: z.number().min(0).default(180000),
+  default_preset: z.string().default("default"),
+  councillor_execution_mode: CouncillorExecutionModeSchema.describe('Execution mode for councillors. "serial" runs them one at a time (required for single-model systems). "parallel" runs them concurrently (default, faster for multi-model systems).'),
+  councillor_retries: z.number().int().min(0).max(5).default(3).describe("Number of retry attempts for councillors that return empty responses " + "(e.g. due to provider rate limiting). Default: 3 retries."),
+  master: z.unknown().optional().describe("DEPRECATED — ignored. Council agent synthesizes directly."),
+  master_timeout: z.unknown().optional().describe('DEPRECATED — ignored. Use "timeout" instead.'),
+  master_fallback: z.unknown().optional().describe("DEPRECATED — ignored. No separate master session.")
+}).transform((data) => {
+  const deprecated = [];
+  if (data.master !== undefined)
+    deprecated.push("master");
+  if (data.master_timeout !== undefined)
+    deprecated.push("master_timeout");
+  if (data.master_fallback !== undefined)
+    deprecated.push("master_fallback");
+  const legacyMasterModel = typeof data.master === "object" && data.master !== null && "model" in data.master && typeof data.master.model === "string" ? data.master.model : undefined;
+  return {
+    presets: data.presets,
+    timeout: data.timeout,
+    default_preset: data.default_preset,
+    councillor_execution_mode: data.councillor_execution_mode,
+    councillor_retries: data.councillor_retries,
+    _deprecated: deprecated.length > 0 ? deprecated : undefined,
+    _legacyMasterModel: legacyMasterModel
+  };
+});
+// src/config/schema.ts
+import { z as z2 } from "zod";
+var ProviderModelIdSchema = z2.string().regex(/^[^/\s]+\/[^\s]+$/, "Expected provider/model format (provider/.../model)");
+var ManualAgentPlanSchema = z2.object({
+  primary: ProviderModelIdSchema,
+  fallback1: ProviderModelIdSchema,
+  fallback2: ProviderModelIdSchema,
+  fallback3: ProviderModelIdSchema
+}).superRefine((value, ctx) => {
+  const unique = new Set([
+    value.primary,
+    value.fallback1,
+    value.fallback2,
+    value.fallback3
+  ]);
+  if (unique.size !== 4) {
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      message: "primary and fallbacks must be unique per agent"
+    });
+  }
+});
+var ManualPlanSchema = z2.object({
+  orchestrator: ManualAgentPlanSchema,
+  oracle: ManualAgentPlanSchema,
+  designer: ManualAgentPlanSchema,
+  explorer: ManualAgentPlanSchema,
+  librarian: ManualAgentPlanSchema,
+  fixer: ManualAgentPlanSchema
+}).strict();
+var AgentModelChainSchema = z2.array(z2.string()).min(1);
+var FallbackChainsSchema = z2.object({
+  orchestrator: AgentModelChainSchema.optional(),
+  oracle: AgentModelChainSchema.optional(),
+  designer: AgentModelChainSchema.optional(),
+  explorer: AgentModelChainSchema.optional(),
+  librarian: AgentModelChainSchema.optional(),
+  fixer: AgentModelChainSchema.optional()
+}).catchall(AgentModelChainSchema);
+var AgentOverrideConfigSchema = z2.object({
+  model: z2.union([
+    z2.string(),
+    z2.array(z2.union([
+      z2.string(),
+      z2.object({
+        id: z2.string(),
+        variant: z2.string().optional()
+      })
+    ])).min(1)
+  ]).optional(),
+  temperature: z2.number().min(0).max(2).optional(),
+  variant: z2.string().optional().catch(undefined),
+  skills: z2.array(z2.string()).optional(),
+  mcps: z2.array(z2.string()).optional(),
+  prompt: z2.string().min(1).optional(),
+  orchestratorPrompt: z2.string().min(1).optional(),
+  options: z2.record(z2.string(), z2.unknown()).optional(),
+  displayName: z2.string().min(1).optional()
+}).strict();
+var MultiplexerTypeSchema = z2.enum(["auto", "tmux", "zellij", "none"]);
+var MultiplexerLayoutSchema = z2.enum([
+  "main-horizontal",
+  "main-vertical",
+  "tiled",
+  "even-horizontal",
+  "even-vertical"
+]);
+var TmuxLayoutSchema = MultiplexerLayoutSchema;
+var MultiplexerConfigSchema = z2.object({
+  type: MultiplexerTypeSchema.default("none"),
+  layout: MultiplexerLayoutSchema.default("main-vertical"),
+  main_pane_size: z2.number().min(20).max(80).default(60)
+});
+var TmuxConfigSchema = z2.object({
+  enabled: z2.boolean().default(false),
+  layout: TmuxLayoutSchema.default("main-vertical"),
+  main_pane_size: z2.number().min(20).max(80).default(60)
+});
+var PresetSchema = z2.record(z2.string(), AgentOverrideConfigSchema);
+var WebsearchConfigSchema = z2.object({
+  provider: z2.enum(["exa", "tavily"]).default("exa")
+});
+var McpNameSchema = z2.enum(["websearch", "context7", "grep_app"]);
+var InterviewConfigSchema = z2.object({
+  maxQuestions: z2.number().int().min(1).max(10).default(2),
+  outputFolder: z2.string().min(1).default("interview"),
+  autoOpenBrowser: z2.boolean().default(true).describe("Automatically open the interview UI in your default browser during interactive runs. Disabled automatically in tests and CI."),
+  port: z2.number().int().min(0).max(65535).default(0),
+  dashboard: z2.boolean().default(false)
+});
+var SessionManagerConfigSchema = z2.object({
+  maxSessionsPerAgent: z2.number().int().min(1).max(10).default(2),
+  readContextMinLines: z2.number().int().min(0).max(1000).default(10),
+  readContextMaxFiles: z2.number().int().min(0).max(50).default(8)
+});
+var DivoomConfigSchema = z2.object({
+  enabled: z2.boolean().default(false),
+  python: z2.string().min(1).default("/Applications/Divoom MiniToo.app/Contents/Resources/.venv/bin/python"),
+  script: z2.string().min(1).default("/Applications/Divoom MiniToo.app/Contents/Resources/tools/divoom_send.py"),
+  size: z2.number().int().min(1).max(1024).default(128),
+  fps: z2.number().int().min(1).max(60).default(8),
+  speed: z2.number().int().min(1).max(1e4).default(125),
+  maxFrames: z2.number().int().min(1).max(500).default(24),
+  posterizeBits: z2.number().int().min(1).max(8).default(3),
+  gifs: z2.record(z2.string(), z2.string().min(1)).optional()
+});
+var TodoContinuationConfigSchema = z2.object({
+  maxContinuations: z2.number().int().min(1).max(50).default(5).describe("Maximum consecutive auto-continuations before stopping to ask user"),
+  cooldownMs: z2.number().int().min(0).max(30000).default(3000).describe("Delay in ms before auto-continuing (gives user time to abort)"),
+  autoEnable: z2.boolean().default(false).describe("Automatically enable auto-continue when the orchestrator session has enough todos"),
+  autoEnableThreshold: z2.number().int().min(1).max(50).default(4).describe("Number of todos that triggers auto-enable (only used when autoEnable is true)")
+});
+var FailoverConfigSchema = z2.object({
+  enabled: z2.boolean().default(true),
+  timeoutMs: z2.number().min(0).default(15000),
+  retryDelayMs: z2.number().min(0).default(500),
+  chains: FallbackChainsSchema.default({}),
+  retry_on_empty: z2.boolean().default(true).describe("When true (default), empty provider responses are treated as failures, " + "triggering fallback/retry. Set to false to treat them as successes.")
+});
+function validateCustomOnlyPromptFields(overrides, ctx, pathPrefix) {
+  for (const [name, override] of Object.entries(overrides)) {
+    const isBuiltInOrAlias = ALL_AGENT_NAMES.includes(name) || AGENT_ALIASES[name] !== undefined;
+    if (!isBuiltInOrAlias) {
+      continue;
+    }
+    if (override.prompt !== undefined) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: [...pathPrefix, name, "prompt"],
+        message: "prompt is only supported for custom agents"
+      });
+    }
+    if (override.orchestratorPrompt !== undefined) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: [...pathPrefix, name, "orchestratorPrompt"],
+        message: "orchestratorPrompt is only supported for custom agents"
+      });
+    }
+  }
+}
+var PluginConfigSchema = z2.object({
+  preset: z2.string().optional(),
+  setDefaultAgent: z2.boolean().optional(),
+  scoringEngineVersion: z2.enum(["v1", "v2-shadow", "v2"]).optional(),
+  balanceProviderUsage: z2.boolean().optional(),
+  autoUpdate: z2.boolean().optional().describe("Disable automatic installation of plugin updates when false. Defaults to true."),
+  manualPlan: ManualPlanSchema.optional(),
+  presets: z2.record(z2.string(), PresetSchema).optional(),
+  agents: z2.record(z2.string(), AgentOverrideConfigSchema).optional(),
+  disabled_agents: z2.array(z2.string()).optional().describe("Agent names to disable completely. " + "Disabled agents are not instantiated and cannot be delegated to. " + "Orchestrator and council internal agents (councillor) cannot be disabled. " + "By default, 'observer' is disabled. Remove it from this list and configure a vision-capable model to enable."),
+  disabled_mcps: z2.array(z2.string()).optional(),
+  multiplexer: MultiplexerConfigSchema.optional(),
+  tmux: TmuxConfigSchema.optional(),
+  websearch: WebsearchConfigSchema.optional(),
+  interview: InterviewConfigSchema.optional(),
+  sessionManager: SessionManagerConfigSchema.optional(),
+  divoom: DivoomConfigSchema.optional(),
+  todoContinuation: TodoContinuationConfigSchema.optional(),
+  fallback: FailoverConfigSchema.optional(),
+  council: CouncilConfigSchema.optional()
+}).superRefine((value, ctx) => {
+  if (value.agents) {
+    validateCustomOnlyPromptFields(value.agents, ctx, ["agents"]);
+  }
+  if (value.presets) {
+    for (const [presetName, preset] of Object.entries(value.presets)) {
+      validateCustomOnlyPromptFields(preset, ctx, ["presets", presetName]);
+    }
+  }
+});
+// src/config/utils.ts
+function getAgentOverride(config, name) {
+  const overrides = config?.agents ?? {};
+  return overrides[name] ?? overrides[Object.keys(AGENT_ALIASES).find((k) => AGENT_ALIASES[k] === name) ?? ""];
+}
+function getCustomAgentNames(config) {
+  const overrides = config?.agents ?? {};
+  return Object.keys(overrides).filter((name) => {
+    if (AGENT_ALIASES[name] !== undefined) {
+      return false;
+    }
+    return !ALL_AGENT_NAMES.includes(name);
+  });
+}
+// src/config/agent-mcps.ts
+var DEFAULT_AGENT_MCPS = {
+  orchestrator: ["*", "!context7"],
+  designer: [],
+  oracle: [],
+  librarian: ["websearch", "context7", "grep_app"],
+  explorer: [],
+  fixer: [],
+  observer: [],
+  council: [],
+  councillor: []
+};
+function parseList(items, allAvailable) {
+  if (!items || items.length === 0) {
+    return [];
+  }
+  const allow = items.filter((i) => !i.startsWith("!"));
+  const deny = items.filter((i) => i.startsWith("!")).map((i) => i.slice(1));
+  if (deny.includes("*")) {
+    return [];
+  }
+  if (allow.includes("*")) {
+    return allAvailable.filter((item) => !deny.includes(item));
+  }
+  return allow.filter((item) => !deny.includes(item) && allAvailable.includes(item));
+}
+function getAgentMcpList(agentName, config) {
+  const agentConfig = getAgentOverride(config, agentName);
+  if (agentConfig?.mcps !== undefined) {
+    return agentConfig.mcps;
+  }
+  const defaultMcps = DEFAULT_AGENT_MCPS[agentName];
+  return defaultMcps ?? [];
+}
+
+// src/cli/custom-skills.ts
+var CUSTOM_SKILLS = [
+  {
+    name: "simplify",
+    description: "Code simplification and readability-focused refactoring",
+    allowedAgents: ["oracle"],
+    sourcePath: "src/skills/simplify"
+  },
+  {
+    name: "codemap",
+    description: "Repository understanding and hierarchical codemap generation",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/codemap"
+  }
+];
+
+// src/cli/skills.ts
+var RECOMMENDED_SKILLS = [
+  {
+    name: "agent-browser",
+    repo: "https://github.com/vercel-labs/agent-browser",
+    skillName: "agent-browser",
+    allowedAgents: ["designer"],
+    description: "High-performance browser automation",
+    postInstallCommands: [
+      "npm install -g agent-browser",
+      "agent-browser install"
+    ]
+  }
+];
+var PERMISSION_ONLY_SKILLS = [
+  {
+    name: "requesting-code-review",
+    allowedAgents: ["oracle"],
+    description: "Code review template for reviewer subagents in multi-step workflows"
+  }
+];
+function getSkillPermissionsForAgent(agentName, skillList) {
+  const permissions = {
+    "*": agentName === "orchestrator" ? "allow" : "deny"
+  };
+  if (skillList) {
+    permissions["*"] = "deny";
+    for (const name of skillList) {
+      if (name === "*") {
+        permissions["*"] = "allow";
+      } else if (name.startsWith("!")) {
+        permissions[name.slice(1)] = "deny";
+      } else {
+        permissions[name] = "allow";
+      }
+    }
+    return permissions;
+  }
+  for (const skill of RECOMMENDED_SKILLS) {
+    const isAllowed = skill.allowedAgents.includes("*") || skill.allowedAgents.includes(agentName);
+    if (isAllowed) {
+      permissions[skill.skillName] = "allow";
+    }
+  }
+  for (const skill of CUSTOM_SKILLS) {
+    const isAllowed = skill.allowedAgents.includes("*") || skill.allowedAgents.includes(agentName);
+    if (isAllowed) {
+      permissions[skill.name] = "allow";
+    }
+  }
+  for (const skill of PERMISSION_ONLY_SKILLS) {
+    const isAllowed = skill.allowedAgents.includes("*") || skill.allowedAgents.includes(agentName);
+    if (isAllowed) {
+      permissions[skill.name] = "allow";
+    }
+  }
+  return permissions;
+}
+
+// src/cli/config-io.ts
+function stripJsonComments(json) {
+  const commentPattern = /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g;
+  const trailingCommaPattern = /\\"|"(?:\\"|[^"])*"|(,)(\s*[}\]])/g;
+  return json.replace(commentPattern, (match, commentGroup) => commentGroup ? "" : match).replace(trailingCommaPattern, (match, comma, closing) => comma ? closing : match);
+}
+
+// src/config/loader.ts
+var PROMPTS_DIR_NAME = "oh-my-opencode-slim";
+function loadConfigFromPath(configPath, options) {
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    let rawConfig;
+    try {
+      rawConfig = JSON.parse(stripJsonComments(content));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      options?.onWarning?.({
+        path: configPath,
+        kind: "invalid-json",
+        message
+      });
+      if (!options?.silent) {
+        console.warn(`[oh-my-opencode-slim] Invalid JSON in ${configPath}:`, message);
+      }
+      return null;
+    }
+    const result = PluginConfigSchema.safeParse(rawConfig);
+    if (!result.success) {
+      options?.onWarning?.({
+        path: configPath,
+        kind: "invalid-schema",
+        message: "Config does not match schema",
+        formatted: result.error.format()
+      });
+      if (!options?.silent) {
+        console.warn(`[oh-my-opencode-slim] Invalid config at ${configPath}:`);
+        console.warn(result.error.format());
+      }
+      return null;
+    }
+    return result.data;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
+      options?.onWarning?.({
+        path: configPath,
+        kind: "read-error",
+        message: error.message
+      });
+      if (!options?.silent) {
+        console.warn(`[oh-my-opencode-slim] Error reading config from ${configPath}:`, error.message);
+      }
+    }
+    return null;
+  }
+}
+function findConfigPath(basePath) {
+  const jsoncPath = `${basePath}.jsonc`;
+  const jsonPath = `${basePath}.json`;
+  if (fs.existsSync(jsoncPath)) {
+    return jsoncPath;
+  }
+  if (fs.existsSync(jsonPath)) {
+    return jsonPath;
+  }
+  return null;
+}
+function findConfigPathInDirs(configDirs, baseName) {
+  for (const configDir of configDirs) {
+    const configPath = findConfigPath(path.join(configDir, baseName));
+    if (configPath) {
+      return configPath;
+    }
+  }
+  return null;
+}
+function findPluginConfigPaths(directory) {
+  const userConfigPath = findConfigPathInDirs(getConfigSearchDirs(), "oh-my-opencode-slim");
+  const projectConfigBasePath = path.join(directory, ".opencode", "oh-my-opencode-slim");
+  const projectConfigPath = findConfigPath(projectConfigBasePath);
+  return { userConfigPath, projectConfigPath };
+}
+function mergePluginConfigs(base, override) {
+  return {
+    ...base,
+    ...override,
+    agents: deepMerge(base.agents, override.agents),
+    tmux: deepMerge(base.tmux, override.tmux),
+    multiplexer: deepMerge(base.multiplexer, override.multiplexer),
+    interview: deepMerge(base.interview, override.interview),
+    sessionManager: deepMerge(base.sessionManager, override.sessionManager),
+    divoom: deepMerge(base.divoom, override.divoom),
+    fallback: deepMerge(base.fallback, override.fallback),
+    council: deepMerge(base.council, override.council)
+  };
+}
+function deepMerge(base, override) {
+  if (!base)
+    return override;
+  if (!override)
+    return base;
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const baseVal = base[key];
+    const overrideVal = override[key];
+    if (typeof baseVal === "object" && baseVal !== null && typeof overrideVal === "object" && overrideVal !== null && !Array.isArray(baseVal) && !Array.isArray(overrideVal)) {
+      result[key] = deepMerge(baseVal, overrideVal);
+    } else {
+      result[key] = overrideVal;
+    }
+  }
+  return result;
+}
+function loadPluginConfig(directory, options) {
+  const { userConfigPath, projectConfigPath } = findPluginConfigPaths(directory);
+  let config = userConfigPath ? loadConfigFromPath(userConfigPath, options) ?? {} : {};
+  const projectConfig = projectConfigPath ? loadConfigFromPath(projectConfigPath, options) : null;
+  if (projectConfig) {
+    config = mergePluginConfigs(config, projectConfig);
+  }
+  config = migrateTmuxToMultiplexer(config);
+  const envPreset = process.env.OH_MY_OPENCODE_SLIM_PRESET;
+  if (envPreset) {
+    config.preset = envPreset;
+  }
+  if (config.preset) {
+    const preset = config.presets?.[config.preset];
+    if (preset) {
+      config.agents = deepMerge(preset, config.agents);
+    } else {
+      const presetSource = envPreset === config.preset ? "environment variable" : "config file";
+      const availablePresets = config.presets ? Object.keys(config.presets).join(", ") : "none";
+      const message = `Preset "${config.preset}" not found (from ${presetSource}). Available presets: ${availablePresets}`;
+      options?.onWarning?.({
+        path: projectConfigPath ?? userConfigPath ?? "",
+        kind: "missing-preset",
+        message
+      });
+      if (!options?.silent) {
+        console.warn(`[oh-my-opencode-slim] ${message}`);
+      }
+    }
+  }
+  return config;
+}
+function loadAgentPrompt(agentName, preset) {
+  const presetDirName = preset && /^[a-zA-Z0-9_-]+$/.test(preset) ? preset : undefined;
+  const promptSearchDirs = getConfigSearchDirs().flatMap((configDir) => {
+    const promptsDir = path.join(configDir, PROMPTS_DIR_NAME);
+    return presetDirName ? [path.join(promptsDir, presetDirName), promptsDir] : [promptsDir];
+  });
+  const result = {};
+  const readFirstPrompt = (fileName, errorPrefix) => {
+    for (const dir of promptSearchDirs) {
+      const promptPath = path.join(dir, fileName);
+      if (!fs.existsSync(promptPath)) {
+        continue;
+      }
+      try {
+        return fs.readFileSync(promptPath, "utf-8");
+      } catch (error) {
+        console.warn(`[oh-my-opencode-slim] ${errorPrefix} ${promptPath}:`, error instanceof Error ? error.message : String(error));
+      }
+    }
+    return;
+  };
+  result.prompt = readFirstPrompt(`${agentName}.md`, "Error reading prompt file");
+  result.appendPrompt = readFirstPrompt(`${agentName}_append.md`, "Error reading append prompt file");
+  return result;
+}
+function migrateTmuxToMultiplexer(config) {
+  if (config.multiplexer?.type && config.multiplexer.type !== "none") {
+    return config;
+  }
+  if (config.tmux?.enabled) {
+    return {
+      ...config,
+      multiplexer: {
+        type: "tmux",
+        layout: config.tmux.layout ?? "main-vertical",
+        main_pane_size: config.tmux.main_pane_size ?? 60
+      }
+    };
+  }
+  return config;
+}
+
+// src/tui-state.ts
+import * as fs2 from "node:fs";
+import * as os from "node:os";
+import * as path2 from "node:path";
+var STATE_DIR = "oh-my-opencode-slim";
+var STATE_FILE = "tui-state.json";
+function dataDir() {
+  return process.env.XDG_DATA_HOME ?? path2.join(os.homedir(), ".local", "share");
+}
+function getTuiStatePath() {
+  return path2.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(fs2.readFileSync(getTuiStatePath(), "utf8"));
+  } catch {
+    return emptySnapshot();
+  }
+}
+async function readTuiSnapshotAsync() {
+  try {
+    return parseSnapshot(await fs2.promises.readFile(getTuiStatePath(), "utf8"));
+  } catch {
+    return emptySnapshot();
+  }
+}
+function writeTuiSnapshot(snapshot) {
+  try {
+    const filePath = getTuiStatePath();
+    fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+    fs2.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 = "oh-my-opencode-slim";
-var PLUGIN_LABEL = "OMOS";
+var CONFIG_WARNING_COLOR = "orange";
+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();
@@ -60,21 +747,109 @@ function element(tag, props, children = []) {
 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 getTuiDirectory(api) {
+  return api.state?.path?.directory ?? process.cwd();
+}
+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, configInvalid) {
+  const configStatusRow = buildConfigStatusRow(configInvalid, 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}`])
+    ]),
+    configStatusRow,
+    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);
+    })
+  ]);
+}
+function buildConfigStatusRow(configInvalid, theme) {
+  if (!configInvalid)
+    return null;
+  return box({
+    width: "100%",
+    flexDirection: "column",
+    marginTop: 1,
+    marginBottom: 1
+  }, [
+    text({ fg: CONFIG_WARNING_COLOR }, ["Config invalid"]),
+    text({ fg: theme.textMuted }, ["Run doctor for details"])
+  ]);
+}
+function readConfigInvalid(directory) {
+  let configInvalid = false;
+  loadPluginConfig(directory, {
+    silent: true,
+    onWarning: () => {
+      configInvalid = true;
+    }
+  });
+  return configInvalid;
+}
 var plugin = {
   id: `${PLUGIN_NAME}:tui`,
   tui: async (api, _options, meta) => {
     const version = meta.version ?? await readPackageVersion() ?? "dev";
-    const versionText = `${PLUGIN_LABEL} ${version}`;
+    let configDirectory = getTuiDirectory(api);
+    let configInvalid = readConfigInvalid(configDirectory);
+    let snapshot = readTuiSnapshot();
+    const renderTimer = setInterval(async () => {
+      try {
+        snapshot = await readTuiSnapshotAsync();
+        const currentDirectory = getTuiDirectory(api);
+        if (currentDirectory !== configDirectory) {
+          configDirectory = currentDirectory;
+          configInvalid = readConfigInvalid(configDirectory);
+        }
+        api.renderer.requestRender();
+      } catch {}
+    }, 1000);
+    api.lifecycle.onDispose(() => {
+      clearInterval(renderTimer);
+    });
     api.slots.register({
       order: 900,
       slots: {
-        home_prompt_right() {
-          const theme = api.theme.current;
-          return text({ fg: theme.textMuted }, [versionText]);
-        },
-        session_prompt_right() {
-          const theme = api.theme.current;
-          return text({ fg: theme.textMuted }, [versionText]);
+        sidebar_content() {
+          return renderSidebar(snapshot, version, api.theme.current, configInvalid);
         }
       }
     });
@@ -82,5 +857,8 @@ var plugin = {
 };
 var tui_default = plugin;
 export {
+  readConfigInvalid,
+  getSidebarAgentNames,
+  formatSidebarModelName,
   tui_default as default
 };