oh-my-opencode-serverlocal 0.1.0

package/dist/tui.js

@@ -0,0 +1,1112 @@
+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 __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/utils/compat.ts
+import { spawn as nodeSpawn } from "node:child_process";
+import { writeFile as fsWriteFile } from "node:fs/promises";
+function collectStream(stream) {
+  if (!stream)
+    return () => Promise.resolve("");
+  const chunks = [];
+  stream.on("data", (chunk) => chunks.push(chunk));
+  return () => new Promise((resolve, reject) => {
+    if (!stream.readable) {
+      resolve(Buffer.concat(chunks).toString("utf-8"));
+      return;
+    }
+    stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    stream.on("error", reject);
+  });
+}
+function crossSpawn(command, options) {
+  const [cmd, ...args] = command;
+  const proc = nodeSpawn(cmd, args, {
+    stdio: [
+      options?.stdin ?? "ignore",
+      options?.stdout ?? "pipe",
+      options?.stderr ?? "pipe"
+    ],
+    cwd: options?.cwd,
+    env: options?.env
+  });
+  const stdoutCollector = collectStream(proc.stdout);
+  const stderrCollector = collectStream(proc.stderr);
+  const exited = new Promise((resolve, reject) => {
+    proc.on("error", reject);
+    proc.on("close", (code) => resolve(code ?? 1));
+  });
+  return {
+    proc,
+    stdout: stdoutCollector,
+    stderr: stderrCollector,
+    exited,
+    kill: (signal) => proc.kill(signal),
+    get exitCode() {
+      return proc.exitCode;
+    }
+  };
+}
+async function crossWrite(path, data) {
+  await fsWriteFile(path, Buffer.from(data));
+}
+var init_compat = () => {};
+
+// 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 ALL_AGENT_NAMES = ["orchestrator", ...SUBAGENT_NAMES];
+var PROTECTED_AGENTS = new Set(["orchestrator", "councillor"]);
+var DEFAULT_MODELS = {
+  orchestrator: undefined,
+  oracle: undefined,
+  librarian: undefined,
+  explorer: undefined,
+  designer: undefined,
+  fixer: undefined,
+  observer: undefined,
+  council: undefined,
+  councillor: undefined
+};
+var POLL_INTERVAL_BACKGROUND_MS = 2000;
+var MAX_POLL_TIME_MS = 5 * 60 * 1000;
+var DEFAULT_MAX_SUBAGENT_DEPTH = 3;
+var PHASE_REMINDER_TEXT = `!IMPORTANT! Scheduler workflow: First choose the lightest workflow that fits the work. If direct execution is justified, complete it and verify proportionately. Otherwise: plan lanes/dependencies → dispatch background specialists → track task IDs → wait for hook-driven completion → reconcile terminal results → verify. Do not poll running jobs, consume running-job output, or advance dependent work. !END!`;
+function formatSystemReminder(text) {
+  return `<system-reminder>
+${text}
+</system-reminder>`;
+}
+var PHASE_REMINDER = formatSystemReminder(PHASE_REMINDER_TEXT);
+var WRITABLE_FILE_OPERATIONS_RULES = `**File Operations Rules**:
+- Prefer dedicated file tools for normal code work: glob/grep/ast_grep_search for discovery, read for file contents, and edit/write/apply_patch for targeted source changes.
+- Use bash for execution and automation: git, package managers, tests, builds, scripts, diagnostics, and shell-native filesystem operations.
+- Shell is acceptable for bulk or mechanical filesystem changes when it is clearer or safer than many individual edits (for example: truncate generated logs, remove build artifacts, batch rename/move files), especially when the user explicitly asks for that shell operation.
+- Before destructive or broad shell operations, verify the target set and quote paths. Prefer a dry-run/listing first when practical.
+- Do not use cat/head/tail/sed/awk only to read code into context; use read/grep unless a shell pipeline is genuinely the better diagnostic.`;
+var READONLY_FILE_OPERATIONS_RULES = `**File Operations Rules**:
+- READ-ONLY: inspect and report; do not modify files.
+- Prefer dedicated file tools for codebase inspection: glob/grep/ast_grep_search for discovery and read for file contents.
+- Bash is allowed for non-mutating diagnostics and shell-native inspection when it is the clearest tool, but not for modifying files.
+- Do not use cat/head/tail/sed/awk only to read code into context; use read/grep unless a shell pipeline is genuinely the better diagnostic.`;
+var NO_SHELL_READONLY_FILE_OPERATIONS_RULES = `**File Operations Rules**:
+- READ-ONLY: inspect and report; do not modify files.
+- Use glob/grep/ast_grep_search for discovery and read for file contents.
+- Do not use bash or shell commands.`;
+var TMUX_SPAWN_DELAY_MS = 500;
+var COUNCILLOR_STAGGER_MS = 250;
+var DEFAULT_DISABLED_AGENTS = ["observer"];
+var DEFAULT_MAX_SESSIONS_PER_AGENT = 2;
+var DEFAULT_READ_CONTEXT_MIN_LINES = 10;
+var DEFAULT_READ_CONTEXT_MAX_FILES = 8;
+var DEFAULT_IMAGE_ROUTING = "auto";
+function resolveImageRouting(imageRouting) {
+  return imageRouting ?? DEFAULT_IMAGE_ROUTING;
+}
+
+// src/config/loader.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// src/cli/config-io.ts
+init_compat();
+
+// 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 getConfigDir() {
+  const customConfigDir = getCustomOpenCodeConfigDir();
+  if (customConfigDir) {
+    return customConfigDir;
+  }
+  return getDefaultOpenCodeConfigDir();
+}
+function getConfigSearchDirs() {
+  const dirs = [getCustomOpenCodeConfigDir(), getDefaultOpenCodeConfigDir()];
+  return dirs.filter((dir, index) => {
+    return Boolean(dir) && dirs.indexOf(dir) === index;
+  });
+}
+function getOpenCodeConfigPaths() {
+  const configDir = getConfigDir();
+  return [join(configDir, "opencode.json"), join(configDir, "opencode.jsonc")];
+}
+// src/config/council-schema.ts
+import { z } from "zod";
+
+// src/utils/councillor-models.ts
+function normalizeCouncillorModels(model, fallbackVariant) {
+  const raw = Array.isArray(model) ? model : [model];
+  return raw.map((entry) => typeof entry === "string" ? { id: entry, variant: fallbackVariant } : { id: entry.id, variant: entry.variant ?? fallbackVariant });
+}
+
+// src/config/council-schema.ts
+var ModelIdSchema = z.string().regex(/^[^/\s]+\/[^\s]+$/, 'Expected provider/model format (e.g. "openai/gpt-5.6-luna")');
+var CouncillorModelEntrySchema = z.object({
+  id: ModelIdSchema,
+  variant: z.string().optional()
+});
+var CouncillorModelSchema = z.union([
+  ModelIdSchema,
+  z.array(z.union([ModelIdSchema, CouncillorModelEntrySchema])).min(1)
+]).describe('Model ID in provider/model format (e.g. "openai/gpt-5.6-luna"), or an ' + "ordered fallback chain (array of model IDs or { id, variant } entries) " + "tried in order until one responds.");
+var CouncillorConfigSchema = z.object({
+  model: CouncillorModelSchema,
+  variant: z.string().optional(),
+  prompt: z.string().optional().describe("Optional role/guidance injected into the councillor user prompt")
+}).transform((c) => {
+  const models = normalizeCouncillorModels(c.model, c.variant);
+  return {
+    model: models[0].id,
+    variant: c.variant,
+    prompt: c.prompt,
+    models
+  };
+});
+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.")
+}).transform((data) => {
+  const deprecated = [];
+  if (data.master !== undefined)
+    deprecated.push("master");
+  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 PermissionActionSchema = z2.enum(["ask", "allow", "deny"]);
+var PermissionRuleSchema = z2.union([
+  PermissionActionSchema,
+  z2.record(z2.string(), PermissionActionSchema)
+]);
+var PermissionObjectSchema = z2.object({
+  read: PermissionRuleSchema.optional(),
+  edit: PermissionRuleSchema.optional(),
+  glob: PermissionRuleSchema.optional(),
+  grep: PermissionRuleSchema.optional(),
+  list: PermissionRuleSchema.optional(),
+  bash: PermissionRuleSchema.optional(),
+  task: PermissionRuleSchema.optional(),
+  external_directory: PermissionRuleSchema.optional(),
+  lsp: PermissionRuleSchema.optional(),
+  skill: PermissionRuleSchema.optional(),
+  todowrite: PermissionActionSchema.optional(),
+  question: PermissionActionSchema.optional(),
+  webfetch: PermissionActionSchema.optional(),
+  websearch: PermissionActionSchema.optional(),
+  codesearch: PermissionActionSchema.optional(),
+  doom_loop: PermissionActionSchema.optional()
+}).catchall(PermissionRuleSchema);
+var PermissionConfigSchema = z2.union([
+  PermissionActionSchema,
+  PermissionObjectSchema
+]);
+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(),
+  permission: PermissionConfigSchema.optional()
+}).strict();
+var MultiplexerTypeSchema = z2.enum([
+  "auto",
+  "tmux",
+  "zellij",
+  "herdr",
+  "cmux",
+  "none"
+]);
+var MultiplexerLayoutSchema = z2.enum([
+  "main-horizontal",
+  "main-vertical",
+  "tiled",
+  "even-horizontal",
+  "even-vertical"
+]);
+var ZellijPaneModeSchema = z2.enum(["agent-tab", "current-tab"]);
+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),
+  zellij_pane_mode: ZellijPaneModeSchema.default("agent-tab")
+});
+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", "gh_grep"]);
+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 BackgroundJobsConfigSchema = 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 FailoverConfigSchema = z2.object({
+  enabled: z2.boolean().default(true),
+  timeoutMs: z2.number().min(0).default(15000),
+  retryDelayMs: z2.number().min(0).default(500),
+  maxRetries: z2.number().int().min(0).default(3).describe("Number of consecutive 429/rate-limit responses tolerated on the " + "same model before aborting (or swapping to the next fallback " + "model when a chain is configured)."),
+  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."),
+  runtimeOverride: z2.boolean().optional().describe("DEPRECATED: no longer used. Previously controlled whether out-of-chain " + "runtime model picks triggered fallback. Fallback is now always " + "disabled when a user explicitly selects a model via /model.")
+}).strict();
+var CompanionConfigSchema = z2.object({
+  enabled: z2.boolean().optional(),
+  binaryPath: z2.string().min(1).optional().describe("Path to a custom companion binary to launch."),
+  position: z2.enum(["bottom-right", "bottom-left", "top-right", "top-left"]).optional(),
+  size: z2.enum(["small", "medium", "large"]).optional(),
+  gifPack: z2.enum(["default"]).optional().describe("Bundled companion animation pack to use."),
+  loopStyle: z2.enum(["classic", "smooth"]).optional().describe("Companion animation playback style: classic loops or smooth ping-pong playback."),
+  speed: z2.number().min(0.25).max(4).optional().describe("Companion animation playback speed multiplier. Defaults to 1."),
+  debug: z2.boolean().optional().describe("Enable verbose native companion debug logs.")
+});
+var AcpAgentPermissionModeSchema = z2.enum(["ask", "allow", "reject"]);
+var MAX_ACP_TIMEOUT_MS = 2147483647;
+var AcpAgentConfigSchema = z2.object({
+  command: z2.string().min(1),
+  args: z2.array(z2.string()).default([]),
+  env: z2.record(z2.string(), z2.string()).default({}),
+  cwd: z2.string().min(1).optional(),
+  description: z2.string().min(1).optional(),
+  prompt: z2.string().min(1).optional(),
+  orchestratorPrompt: z2.string().min(1).optional(),
+  wrapperModel: ProviderModelIdSchema.optional(),
+  timeoutMs: z2.number().int().min(0).max(MAX_ACP_TIMEOUT_MS).default(0).describe("Timeout for a single ACP run in milliseconds. Set to 0 to disable the timeout."),
+  permissionMode: AcpAgentPermissionModeSchema.default("ask")
+}).strict();
+var AcpAgentsConfigSchema = z2.record(z2.string(), AcpAgentConfigSchema);
+function rejectOrchestratorPromptOnOrchestrator(overrides, ctx, pathPrefix) {
+  for (const [name, override] of Object.entries(overrides)) {
+    if (name === "orchestrator" && override.orchestratorPrompt !== undefined) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        path: [...pathPrefix, name, "orchestratorPrompt"],
+        message: "orchestratorPrompt is not supported for the orchestrator agent"
+      });
+    }
+  }
+}
+var PluginConfigSchema = z2.object({
+  preset: z2.string().optional(),
+  setDefaultAgent: z2.boolean().optional(),
+  compactSidebar: z2.boolean().optional().describe("Use the compact TUI sidebar layout. Defaults to true; set false to use the expanded layout."),
+  stripOrchestratorModel: z2.boolean().optional().describe("When true, omit orchestrator.model and orchestrator.variant from the SDK config so OpenCode uses the session model selected with /model after subagent dispatch. An explicitly selected preset that sets orchestrator.model is preserved. Defaults to false."),
+  autoUpdate: z2.boolean().optional().describe("Disable automatic installation of plugin updates when false. Defaults to true."),
+  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."),
+  image_routing: z2.enum(["auto", "direct"]).optional().describe("How image attachments are handled. " + "When omitted, preserves legacy conditional behavior: intercept " + 'attachments only when observer is enabled. "auto": requires ' + "observer to be enabled and saves attachments to disk before " + 'nudging delegation to @observer. "direct": always passes ' + "attachments to the orchestrator untouched."),
+  disabled_mcps: z2.array(z2.string()).optional().describe("MCP server names to disable completely. Disabled servers are not " + "started and cannot be used by agents."),
+  disabled_tools: z2.array(z2.string()).optional().describe("Tool names to disable completely. Disabled tools are not registered with OpenCode and cannot be used by agents."),
+  disabled_skills: z2.array(z2.string()).optional().describe("Skill names to disable completely. Disabled skills are not granted to agents, even when referenced by presets or agent overrides."),
+  multiplexer: MultiplexerConfigSchema.optional(),
+  tmux: TmuxConfigSchema.optional(),
+  websearch: WebsearchConfigSchema.optional(),
+  interview: InterviewConfigSchema.optional(),
+  backgroundJobs: BackgroundJobsConfigSchema.optional(),
+  fallback: FailoverConfigSchema.optional(),
+  council: CouncilConfigSchema.optional(),
+  companion: CompanionConfigSchema.optional(),
+  acpAgents: AcpAgentsConfigSchema.optional()
+}).superRefine((value, ctx) => {
+  if (value.agents) {
+    rejectOrchestratorPromptOnOrchestrator(value.agents, ctx, ["agents"]);
+  }
+  if (value.presets) {
+    for (const [presetName, preset] of Object.entries(value.presets)) {
+      rejectOrchestratorPromptOnOrchestrator(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);
+  });
+}
+function getAcpAgentNames(config) {
+  return Object.keys(config?.acpAgents ?? {});
+}
+// src/config/agent-mcps.ts
+var DEFAULT_AGENT_MCPS = {
+  orchestrator: ["*", "!context7"],
+  designer: [],
+  oracle: [],
+  librarian: ["websearch", "context7", "gh_grep"],
+  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-registry.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"
+  },
+  {
+    name: "clonedeps",
+    description: "Clone important dependency source for local inspection",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/clonedeps"
+  },
+  {
+    name: "deepwork",
+    description: "Heavy/complex coding sessions and large modifications workflow",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/deepwork"
+  },
+  {
+    name: "verification-planning",
+    description: "Plan credible, proportionate evidence before non-trivial implementation",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/verification-planning"
+  },
+  {
+    name: "reflect",
+    description: "Review repeated work and suggest reusable workflow improvements",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/reflect"
+  },
+  {
+    name: "oh-my-opencode-slim",
+    description: "Configure, customize, and safely improve oh-my-opencode-slim setups",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/oh-my-opencode-slim"
+  },
+  {
+    name: "worktrees",
+    description: "Manage Git worktrees as OMO safe isolated coding lanes for complex/risky/parallel work",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/worktrees"
+  }
+];
+
+// 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 {
+      const stripped = stripJsonComments(content);
+      const interpolated = stripped.replace(/\{env:([^}]+)\}/g, (_, varName) => process.env[varName] ?? "");
+      rawConfig = JSON.parse(interpolated);
+    } 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 validateFinalImageRouting(config, configPath, options) {
+  if (config.image_routing !== "auto")
+    return true;
+  const disabledAgents = config.disabled_agents ?? DEFAULT_DISABLED_AGENTS;
+  if (!disabledAgents.includes("observer"))
+    return true;
+  const message = 'image_routing "auto" requires observer to be enabled. ' + 'Remove "observer" from disabled_agents.';
+  options?.onWarning?.({
+    path: configPath,
+    kind: "invalid-schema",
+    message
+  });
+  if (!options?.silent) {
+    console.warn(`[oh-my-opencode-slim] Invalid config: ${message}`);
+  }
+  return false;
+}
+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),
+    presets: deepMerge(base.presets, override.presets),
+    tmux: deepMerge(base.tmux, override.tmux),
+    multiplexer: deepMerge(base.multiplexer, override.multiplexer),
+    interview: deepMerge(base.interview, override.interview),
+    backgroundJobs: deepMerge(base.backgroundJobs, override.backgroundJobs),
+    fallback: deepMerge(base.fallback, override.fallback),
+    council: deepMerge(base.council, override.council),
+    acpAgents: deepMerge(base.acpAgents, override.acpAgents),
+    companion: deepMerge(base.companion, override.companion)
+  };
+}
+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}`);
+      }
+    }
+  }
+  if (config.companion) {
+    config.companion = {
+      enabled: config.companion.enabled ?? false,
+      binaryPath: config.companion.binaryPath,
+      position: config.companion.position ?? "bottom-right",
+      size: config.companion.size ?? "medium",
+      gifPack: config.companion.gifPack ?? "default",
+      loopStyle: config.companion.loopStyle ?? "classic",
+      speed: config.companion.speed ?? 1,
+      debug: config.companion.debug ?? false
+    };
+  }
+  validateFinalImageRouting(config, projectConfigPath ?? userConfigPath ?? "", options);
+  return config;
+}
+function loadAgentPrompt(agentName, optionsOrPreset) {
+  let preset;
+  let projectDirectory;
+  if (typeof optionsOrPreset === "string") {
+    preset = optionsOrPreset;
+  } else if (optionsOrPreset && typeof optionsOrPreset === "object") {
+    preset = optionsOrPreset.preset;
+    projectDirectory = optionsOrPreset.projectDirectory;
+  }
+  const presetDirName = preset && /^[a-zA-Z0-9_-]+$/.test(preset) ? preset : undefined;
+  const searchDirs = [];
+  if (projectDirectory && presetDirName) {
+    searchDirs.push(path.join(projectDirectory, ".opencode", PROMPTS_DIR_NAME, presetDirName));
+  }
+  if (projectDirectory) {
+    searchDirs.push(path.join(projectDirectory, ".opencode", PROMPTS_DIR_NAME));
+  }
+  if (presetDirName) {
+    for (const userDir of getConfigSearchDirs()) {
+      searchDirs.push(path.join(userDir, PROMPTS_DIR_NAME, presetDirName));
+    }
+  }
+  for (const userDir of getConfigSearchDirs()) {
+    searchDirs.push(path.join(userDir, PROMPTS_DIR_NAME));
+  }
+  const readFirstPrompt = (fileName, errorPrefix) => {
+    for (const dir of searchDirs) {
+      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;
+  };
+  const result = {};
+  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,
+        zellij_pane_mode: "agent-tab"
+      }
+    };
+  }
+  return config;
+}
+
+// src/tui-state.ts
+import { createHash } from "node:crypto";
+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 projectScope(projectDir) {
+  return createHash("sha256").update(path2.resolve(projectDir)).digest("hex").slice(0, 12);
+}
+function getTuiStatePath(projectDir) {
+  return path2.join(dataDir(), "opencode", "storage", STATE_DIR, projectScope(projectDir), STATE_FILE);
+}
+function emptySnapshot() {
+  return {
+    version: 1,
+    updatedAt: Date.now(),
+    agentModels: {},
+    agentVariants: {}
+  };
+}
+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 ?? {},
+    agentVariants: parsed.agentVariants ?? {}
+  };
+}
+function readTuiSnapshot(projectDir) {
+  try {
+    return parseSnapshot(fs2.readFileSync(getTuiStatePath(projectDir), "utf8"));
+  } catch {
+    return emptySnapshot();
+  }
+}
+async function readTuiSnapshotAsync(projectDir) {
+  try {
+    return parseSnapshot(await fs2.promises.readFile(getTuiStatePath(projectDir), "utf8"));
+  } catch {
+    return emptySnapshot();
+  }
+}
+function writeTuiSnapshot(snapshot, projectDir) {
+  try {
+    const filePath = getTuiStatePath(projectDir);
+    fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+    fs2.writeFileSync(filePath, `${JSON.stringify(snapshot)}
+`);
+  } catch {}
+}
+function updateSnapshot(projectDir, mutator) {
+  const snapshot = readTuiSnapshot(projectDir);
+  mutator(snapshot);
+  snapshot.updatedAt = Date.now();
+  writeTuiSnapshot(snapshot, projectDir);
+}
+function recordTuiAgentModels(input, projectDir) {
+  updateSnapshot(projectDir, (snapshot) => {
+    snapshot.agentModels = { ...input.agentModels };
+    snapshot.agentVariants = { ...input.agentVariants ?? {} };
+  });
+}
+function recordTuiAgentModel(input, projectDir) {
+  updateSnapshot(projectDir, (snapshot) => {
+    snapshot.agentModels[input.agentName] = input.model;
+    if (input.variant !== undefined) {
+      if (input.variant === null) {
+        delete snapshot.agentVariants[input.agentName];
+      } else {
+        snapshot.agentVariants[input.agentName] = input.variant;
+      }
+    }
+  });
+}
+
+// src/utils/env.ts
+var TRUTHY_ENV_VALUES = new Set(["1", "true", "yes", "on"]);
+var PLUGIN_DISABLE_ENV = "OH_MY_OPENCODE_SLIM_DISABLE";
+function isTruthyEnvValue(value) {
+  return TRUTHY_ENV_VALUES.has(value?.trim().toLowerCase() ?? "");
+}
+function isPluginDisabledByEnv(env = process.env) {
+  return isTruthyEnvValue(env[PLUGIN_DISABLE_ENV]);
+}
+
+// src/tui.ts
+var PLUGIN_NAME = "oh-my-opencode-slim";
+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();
+    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 getTuiDirectory(api) {
+  return api.state?.path?.directory ?? process.cwd();
+}
+function splitSidebarModelId(model) {
+  const slashIndex = model.indexOf("/");
+  if (slashIndex === -1) {
+    return { model };
+  }
+  return {
+    provider: model.slice(0, slashIndex),
+    model: model.slice(slashIndex + 1)
+  };
+}
+function getSidebarAgentNames(snapshot) {
+  const configuredAgents = Object.keys(snapshot.agentModels);
+  return configuredAgents.length > 0 ? configuredAgents : FALLBACK_SIDEBAR_AGENTS;
+}
+function agentRow(label, model, variant, theme) {
+  const modelParts = splitSidebarModelId(model);
+  const detailRows = [];
+  function detailRow(fieldLabel, value) {
+    return box({ width: "100%", flexDirection: "row", paddingLeft: 2 }, [
+      text({ fg: theme.textMuted, width: 9 }, [fieldLabel]),
+      text({ fg: theme.textMuted }, [value])
+    ]);
+  }
+  if (modelParts.provider) {
+    detailRows.push(detailRow("provider", modelParts.provider));
+  }
+  detailRows.push(detailRow("model", modelParts.model));
+  if (variant) {
+    detailRows.push(detailRow("variant", variant));
+  }
+  return box({ width: "100%", flexDirection: "column", marginBottom: 1 }, [
+    text({ fg: theme.textMuted }, [label]),
+    ...detailRows
+  ]);
+}
+function compactAgentRow(label, model, _variant, theme) {
+  const modelName = splitSidebarModelId(model).model;
+  return box({
+    width: "100%",
+    flexDirection: "row",
+    justifyContent: "space-between"
+  }, [
+    text({ fg: theme.textMuted, width: 14 }, [label]),
+    text({ fg: theme.textMuted }, [modelName])
+  ]);
+}
+function renderSidebar(snapshot, version, theme, configInvalid, compactSidebar) {
+  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.text }, ["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";
+      const variant = snapshot.agentVariants[agentName];
+      if (compactSidebar) {
+        return compactAgentRow(agentName, model, variant, theme);
+      }
+      return agentRow(agentName, model, variant, theme);
+    })
+  ]);
+}
+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 readConfigState(directory) {
+  let configInvalid = false;
+  const config = loadPluginConfig(directory, {
+    silent: true,
+    onWarning: () => {
+      configInvalid = true;
+    }
+  });
+  const compactSidebar = config.compactSidebar ?? true;
+  return { configInvalid, compactSidebar };
+}
+function readConfigInvalid(directory) {
+  return readConfigState(directory).configInvalid;
+}
+function readCompactSidebar(directory) {
+  return readConfigState(directory).compactSidebar;
+}
+var plugin = {
+  id: `${PLUGIN_NAME}:tui`,
+  tui: async (api, _options, meta) => {
+    if (isPluginDisabledByEnv())
+      return;
+    const version = meta.version ?? await readPackageVersion() ?? "dev";
+    let configDirectory = getTuiDirectory(api);
+    let { configInvalid, compactSidebar } = readConfigState(configDirectory);
+    let snapshot = readTuiSnapshot(configDirectory);
+    const renderTimer = setInterval(async () => {
+      try {
+        const currentDirectory = getTuiDirectory(api);
+        snapshot = await readTuiSnapshotAsync(currentDirectory);
+        if (currentDirectory !== configDirectory) {
+          configDirectory = currentDirectory;
+          ({ configInvalid, compactSidebar } = readConfigState(configDirectory));
+        }
+        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, configInvalid, compactSidebar);
+        }
+      }
+    });
+  }
+};
+var tui_default = plugin;
+export {
+  splitSidebarModelId,
+  readConfigInvalid,
+  readCompactSidebar,
+  getSidebarAgentNames,
+  tui_default as default
+};