thoth-agents 0.1.6 → 0.1.7

package/dist/chunk-OES76C67.js

@@ -0,0 +1,1898 @@
+// src/config/loader.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/cli/config-io.ts
+import {
+  copyFileSync,
+  existsSync as existsSync2,
+  readFileSync,
+  renameSync,
+  statSync,
+  writeFileSync
+} from "fs";
+
+// src/cli/paths.ts
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "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 || void 0;
+}
+function getConfigDir() {
+  const customConfigDir = getCustomOpenCodeConfigDir();
+  if (customConfigDir) {
+    return customConfigDir;
+  }
+  return getDefaultOpenCodeConfigDir();
+}
+function getOpenCodeConfigPaths() {
+  const configDir = getDefaultOpenCodeConfigDir();
+  return [join(configDir, "opencode.json"), join(configDir, "opencode.jsonc")];
+}
+function getConfigJson() {
+  return getOpenCodeConfigPaths()[0];
+}
+function getConfigJsonc() {
+  return getOpenCodeConfigPaths()[1];
+}
+function getLiteConfig() {
+  return join(getConfigDir(), "thoth-agents.json");
+}
+function getLiteConfigJsonc() {
+  return join(getConfigDir(), "thoth-agents.jsonc");
+}
+function getExistingLiteConfigPath() {
+  const jsonPath = getLiteConfig();
+  if (existsSync(jsonPath)) return jsonPath;
+  const jsoncPath = getLiteConfigJsonc();
+  if (existsSync(jsoncPath)) return jsoncPath;
+  return jsonPath;
+}
+function getExistingConfigPath() {
+  const jsonPath = getConfigJson();
+  if (existsSync(jsonPath)) return jsonPath;
+  const jsoncPath = getConfigJsonc();
+  if (existsSync(jsoncPath)) return jsoncPath;
+  return jsonPath;
+}
+function ensureConfigDir() {
+  const configDir = getConfigDir();
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+}
+function ensureOpenCodeConfigDir() {
+  const configDir = dirname(getConfigJson());
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+}
+
+// src/cli/providers.ts
+var MODEL_MAPPINGS = {
+  openai: {
+    orchestrator: { model: "openai/gpt-5.4" },
+    oracle: { model: "openai/gpt-5.4", variant: "high" },
+    librarian: { model: "openai/gpt-5.4-mini", variant: "low" },
+    explorer: { model: "openai/gpt-5.4-mini", variant: "low" },
+    designer: { model: "openai/gpt-5.4-mini", variant: "medium" },
+    quick: { model: "openai/gpt-5.4-mini", variant: "low" },
+    deep: { model: "openai/gpt-5.4", variant: "high" }
+  },
+  kimi: {
+    orchestrator: { model: "kimi-for-coding/k2p5" },
+    oracle: { model: "kimi-for-coding/k2p5", variant: "high" },
+    librarian: { model: "kimi-for-coding/k2p5", variant: "low" },
+    explorer: { model: "kimi-for-coding/k2p5", variant: "low" },
+    designer: { model: "kimi-for-coding/k2p5", variant: "medium" },
+    quick: { model: "kimi-for-coding/k2p5", variant: "low" },
+    deep: { model: "kimi-for-coding/k2p5", variant: "high" }
+  },
+  copilot: {
+    orchestrator: { model: "github-copilot/claude-opus-4.6" },
+    oracle: { model: "github-copilot/claude-opus-4.6", variant: "high" },
+    librarian: { model: "github-copilot/grok-code-fast-1", variant: "low" },
+    explorer: { model: "github-copilot/grok-code-fast-1", variant: "low" },
+    designer: {
+      model: "github-copilot/gemini-3.1-pro-preview",
+      variant: "medium"
+    },
+    quick: { model: "github-copilot/claude-sonnet-4.6", variant: "low" },
+    deep: { model: "github-copilot/claude-opus-4.6", variant: "high" }
+  },
+  "zai-plan": {
+    orchestrator: { model: "zai-coding-plan/glm-5" },
+    oracle: { model: "zai-coding-plan/glm-5", variant: "high" },
+    librarian: { model: "zai-coding-plan/glm-5", variant: "low" },
+    explorer: { model: "zai-coding-plan/glm-5", variant: "low" },
+    designer: { model: "zai-coding-plan/glm-5", variant: "medium" },
+    quick: { model: "zai-coding-plan/glm-5", variant: "low" },
+    deep: { model: "zai-coding-plan/glm-5", variant: "high" }
+  }
+};
+function generateLiteConfig(installConfig) {
+  const config = {
+    preset: "openai",
+    presets: {}
+  };
+  const createAgentConfig = (modelInfo) => {
+    return {
+      model: modelInfo.model,
+      variant: modelInfo.variant
+    };
+  };
+  const buildPreset = (mappingName) => {
+    const mapping = MODEL_MAPPINGS[mappingName];
+    return Object.fromEntries(
+      Object.entries(mapping).map(([agentName, modelInfo]) => [
+        agentName,
+        createAgentConfig(modelInfo)
+      ])
+    );
+  };
+  config.presets.openai = buildPreset("openai");
+  if (installConfig.hasTmux) {
+    config.tmux = {
+      enabled: true,
+      layout: "main-vertical",
+      main_pane_size: 60
+    };
+  }
+  return config;
+}
+
+// src/cli/config-io.ts
+var PACKAGE_NAME = "thoth-agents";
+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
+  );
+}
+function parseConfigFile(path2) {
+  try {
+    if (!existsSync2(path2)) return { config: null };
+    const stat = statSync(path2);
+    if (stat.size === 0) return { config: null };
+    const content = readFileSync(path2, "utf-8");
+    if (content.trim().length === 0) return { config: null };
+    return { config: JSON.parse(stripJsonComments(content)) };
+  } catch (err) {
+    return { config: null, error: String(err) };
+  }
+}
+function parseConfig(path2) {
+  const result = parseConfigFile(path2);
+  if (result.config || result.error) return result;
+  if (path2.endsWith(".json")) {
+    const jsoncPath = path2.replace(/\.json$/, ".jsonc");
+    return parseConfigFile(jsoncPath);
+  }
+  return { config: null };
+}
+function writeConfig(configPath, config) {
+  if (configPath.endsWith(".jsonc")) {
+    console.warn(
+      "[config-manager] Writing to .jsonc file - comments will not be preserved"
+    );
+  }
+  const tmpPath = `${configPath}.tmp`;
+  const bakPath = `${configPath}.bak`;
+  const content = `${JSON.stringify(config, null, 2)}
+`;
+  if (existsSync2(configPath)) {
+    copyFileSync(configPath, bakPath);
+  }
+  writeFileSync(tmpPath, content);
+  renameSync(tmpPath, configPath);
+}
+async function addPluginToOpenCodeConfig() {
+  const configPath = getExistingConfigPath();
+  try {
+    ensureOpenCodeConfigDir();
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to create config directory: ${err}`
+    };
+  }
+  try {
+    const { config: parsedConfig, error } = parseConfig(configPath);
+    if (error) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to parse config: ${error}`
+      };
+    }
+    const config = parsedConfig ?? {};
+    const plugins = config.plugin ?? [];
+    const filteredPlugins = plugins.filter(
+      (p) => p !== PACKAGE_NAME && !p.startsWith(`${PACKAGE_NAME}@`)
+    );
+    filteredPlugins.push(`${PACKAGE_NAME}@latest`);
+    config.plugin = filteredPlugins;
+    writeConfig(configPath, config);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to update opencode config: ${err}`
+    };
+  }
+}
+function writeLiteConfig(installConfig, targetPath) {
+  const configPath = targetPath ?? getLiteConfig();
+  try {
+    ensureConfigDir();
+    const config = generateLiteConfig(installConfig);
+    const tmpPath = `${configPath}.tmp`;
+    const bakPath = `${configPath}.bak`;
+    const content = `${JSON.stringify(config, null, 2)}
+`;
+    if (existsSync2(configPath)) {
+      copyFileSync(configPath, bakPath);
+    }
+    writeFileSync(tmpPath, content);
+    renameSync(tmpPath, configPath);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to write lite config: ${err}`
+    };
+  }
+}
+function disableDefaultAgents() {
+  const configPath = getExistingConfigPath();
+  try {
+    ensureOpenCodeConfigDir();
+    const { config: parsedConfig, error } = parseConfig(configPath);
+    if (error) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to parse config: ${error}`
+      };
+    }
+    const config = parsedConfig ?? {};
+    const agent = config.agent ?? {};
+    agent.explore = { disable: true };
+    agent.general = { disable: true };
+    config.agent = agent;
+    writeConfig(configPath, config);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to disable default agents: ${err}`
+    };
+  }
+}
+function detectCurrentConfig() {
+  const result = {
+    isInstalled: false,
+    hasKimi: false,
+    hasOpenAI: false,
+    hasAnthropic: false,
+    hasCopilot: false,
+    hasZaiPlan: false,
+    hasAntigravity: false,
+    hasChutes: false,
+    hasOpencodeZen: false,
+    hasTmux: false
+  };
+  const { config } = parseConfig(getExistingConfigPath());
+  if (!config) return result;
+  const plugins = config.plugin ?? [];
+  result.isInstalled = plugins.some((p) => p.startsWith(PACKAGE_NAME));
+  result.hasAntigravity = plugins.some(
+    (p) => p.startsWith("opencode-antigravity-auth")
+  );
+  const providers = config.provider;
+  result.hasKimi = !!providers?.kimi;
+  result.hasAnthropic = !!providers?.anthropic;
+  result.hasCopilot = !!providers?.["github-copilot"];
+  result.hasZaiPlan = !!providers?.["zai-coding-plan"];
+  result.hasChutes = !!providers?.chutes;
+  if (providers?.google) result.hasAntigravity = true;
+  const { config: liteConfig } = parseConfig(getLiteConfig());
+  if (liteConfig && typeof liteConfig === "object") {
+    const configObj = liteConfig;
+    const presetName = configObj.preset;
+    const presets = configObj.presets;
+    const agents = presets?.[presetName];
+    if (agents) {
+      const models = Object.values(agents).map((a) => a?.model).filter(Boolean);
+      result.hasOpenAI = models.some((m) => m?.startsWith("openai/"));
+      result.hasAnthropic = models.some((m) => m?.startsWith("anthropic/"));
+      result.hasCopilot = models.some((m) => m?.startsWith("github-copilot/"));
+      result.hasZaiPlan = models.some((m) => m?.startsWith("zai-coding-plan/"));
+      result.hasOpencodeZen = models.some((m) => m?.startsWith("opencode/"));
+      if (models.some((m) => m?.startsWith("google/"))) {
+        result.hasAntigravity = true;
+      }
+      if (models.some((m) => m?.startsWith("chutes/"))) {
+        result.hasChutes = true;
+      }
+    }
+    if (configObj.tmux && typeof configObj.tmux === "object") {
+      const tmuxConfig = configObj.tmux;
+      result.hasTmux = tmuxConfig.enabled === true;
+    }
+  }
+  return result;
+}
+
+// src/config/schema.ts
+import { z } from "zod";
+var AGENT_NAMES = [
+  "orchestrator",
+  "oracle",
+  "designer",
+  "explorer",
+  "librarian",
+  "quick",
+  "deep"
+];
+var FALLBACK_AGENT_NAMES = [...AGENT_NAMES];
+var MANUAL_AGENT_NAMES = [...AGENT_NAMES];
+var ProviderModelIdSchema = z.string().regex(
+  /^[^/\s]+\/[^\s]+$/,
+  "Expected provider/model format (provider/.../model)"
+);
+var ManualAgentPlanSchema = z.object({
+  primary: ProviderModelIdSchema,
+  fallback1: ProviderModelIdSchema,
+  fallback2: ProviderModelIdSchema,
+  fallback3: ProviderModelIdSchema
+}).superRefine((value, ctx) => {
+  const unique = /* @__PURE__ */ new Set([
+    value.primary,
+    value.fallback1,
+    value.fallback2,
+    value.fallback3
+  ]);
+  if (unique.size !== 4) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "primary and fallbacks must be unique per agent"
+    });
+  }
+});
+var ManualPlanSchema = z.object({
+  orchestrator: ManualAgentPlanSchema,
+  oracle: ManualAgentPlanSchema,
+  designer: ManualAgentPlanSchema,
+  explorer: ManualAgentPlanSchema,
+  librarian: ManualAgentPlanSchema,
+  quick: ManualAgentPlanSchema,
+  deep: ManualAgentPlanSchema
+}).strict();
+var AgentModelChainSchema = z.array(z.string()).min(1);
+var FallbackChainsSchema = z.object({
+  orchestrator: AgentModelChainSchema.optional(),
+  oracle: AgentModelChainSchema.optional(),
+  designer: AgentModelChainSchema.optional(),
+  explorer: AgentModelChainSchema.optional(),
+  librarian: AgentModelChainSchema.optional(),
+  quick: AgentModelChainSchema.optional(),
+  deep: AgentModelChainSchema.optional()
+}).catchall(AgentModelChainSchema);
+var AgentOverrideConfigSchema = z.object({
+  model: z.union([
+    z.string(),
+    z.array(
+      z.union([
+        z.string(),
+        z.object({
+          id: z.string(),
+          variant: z.string().optional()
+        })
+      ])
+    )
+  ]).optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  steps: z.number().int().min(1).optional(),
+  variant: z.string().optional().catch(void 0)
+});
+var TmuxLayoutSchema = z.enum([
+  "main-horizontal",
+  // Main pane on top, agents stacked below
+  "main-vertical",
+  // Main pane on left, agents stacked on right
+  "tiled",
+  // All panes equal size grid
+  "even-horizontal",
+  // All panes side by side
+  "even-vertical"
+  // All panes stacked vertically
+]);
+var TmuxConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  layout: TmuxLayoutSchema.default("main-vertical"),
+  main_pane_size: z.number().min(20).max(80).default(60)
+  // percentage for main pane
+});
+var PresetSchema = z.record(z.string(), AgentOverrideConfigSchema);
+var AgentNameSchema = z.enum(AGENT_NAMES);
+var McpNameSchema = z.enum([
+  "exa",
+  "context7",
+  "grep_app",
+  "thoth_mem"
+]);
+var ThothConfigSchema = z.object({
+  command: z.array(z.string()).optional(),
+  data_dir: z.string().optional(),
+  environment: z.record(z.string(), z.string()).optional(),
+  timeout: z.number().optional(),
+  http_port: z.number().optional()
+});
+var ArtifactStoreModeSchema = z.enum([
+  "thoth-mem",
+  "openspec",
+  "hybrid"
+]);
+var ArtifactStoreConfigSchema = z.object({
+  mode: ArtifactStoreModeSchema.default("hybrid")
+});
+var CodexGenerationConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  outputRoot: z.string().optional(),
+  dryRun: z.boolean().default(true)
+});
+var FailoverConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  timeoutMs: z.number().min(0).default(15e3),
+  retryDelayMs: z.number().min(0).default(500),
+  chains: FallbackChainsSchema.default({})
+});
+var PluginConfigSchema = z.object({
+  preset: z.string().optional(),
+  setDefaultAgent: z.boolean().optional(),
+  scoringEngineVersion: z.enum(["v1", "v2-shadow", "v2"]).optional(),
+  balanceProviderUsage: z.boolean().optional(),
+  manualPlan: ManualPlanSchema.optional(),
+  presets: z.record(z.string(), PresetSchema).optional(),
+  agents: z.record(z.string(), AgentOverrideConfigSchema).optional(),
+  disabled_mcps: z.array(z.string()).optional(),
+  tmux: TmuxConfigSchema.optional(),
+  fallback: FailoverConfigSchema.optional(),
+  thoth: ThothConfigSchema.optional(),
+  artifactStore: ArtifactStoreConfigSchema.optional(),
+  codex: CodexGenerationConfigSchema.optional()
+});
+
+// src/config/loader.ts
+var PROMPTS_DIR_NAME = "thoth-agents";
+function loadConfigFromPath(configPath) {
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    const rawConfig = JSON.parse(stripJsonComments(content));
+    const result = PluginConfigSchema.safeParse(rawConfig);
+    if (!result.success) {
+      console.warn(`[thoth-agents] 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") {
+      console.warn(
+        `[thoth-agents] 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 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) {
+  const userConfigBasePath = path.join(getConfigDir(), "thoth-agents");
+  const projectConfigBasePath = path.join(
+    directory,
+    ".opencode",
+    "thoth-agents"
+  );
+  const userConfigPath = findConfigPath(userConfigBasePath);
+  const projectConfigPath = findConfigPath(projectConfigBasePath);
+  let config = userConfigPath ? loadConfigFromPath(userConfigPath) ?? {} : {};
+  const projectConfig = projectConfigPath ? loadConfigFromPath(projectConfigPath) : null;
+  if (projectConfig) {
+    config = {
+      ...config,
+      ...projectConfig,
+      agents: deepMerge(config.agents, projectConfig.agents),
+      tmux: deepMerge(config.tmux, projectConfig.tmux),
+      fallback: deepMerge(config.fallback, projectConfig.fallback),
+      thoth: deepMerge(config.thoth, projectConfig.thoth),
+      artifactStore: deepMerge(
+        config.artifactStore,
+        projectConfig.artifactStore
+      ),
+      codex: deepMerge(config.codex, projectConfig.codex)
+    };
+  }
+  const envPreset = process.env.THOTH_AGENTS_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";
+      console.warn(
+        `[thoth-agents] Preset "${config.preset}" not found (from ${presetSource}). Available presets: ${availablePresets}`
+      );
+    }
+  }
+  return config;
+}
+function loadAgentPrompt(agentName, preset) {
+  const presetDirName = preset && /^[a-zA-Z0-9_-]+$/.test(preset) ? preset : void 0;
+  const promptsDir = path.join(getConfigDir(), PROMPTS_DIR_NAME);
+  const promptSearchDirs = 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(
+          `[thoth-agents] ${errorPrefix} ${promptPath}:`,
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    }
+    return void 0;
+  };
+  result.prompt = readFirstPrompt(
+    `${agentName}.md`,
+    "Error reading prompt file"
+  );
+  result.appendPrompt = readFirstPrompt(
+    `${agentName}_append.md`,
+    "Error reading append prompt file"
+  );
+  return result;
+}
+
+// src/config/constants.ts
+var AGENT_ALIASES = {
+  explore: "explorer",
+  "frontend-ui-ux-engineer": "designer"
+};
+var SUBAGENT_NAMES = [
+  "explorer",
+  "librarian",
+  "oracle",
+  "designer",
+  "quick",
+  "deep"
+];
+var ORCHESTRATOR_NAME = "orchestrator";
+var ALL_AGENT_NAMES = [
+  ORCHESTRATOR_NAME,
+  "explorer",
+  "librarian",
+  "oracle",
+  "designer",
+  "quick",
+  "deep"
+];
+var DEFAULT_MODELS = {
+  orchestrator: void 0,
+  oracle: "openai/gpt-5.4",
+  librarian: "openai/gpt-5.4-mini",
+  explorer: "openai/gpt-5.4-mini",
+  designer: "openai/gpt-5.4-mini",
+  quick: "openai/gpt-5.4-mini",
+  deep: "openai/gpt-5.4"
+};
+var POLL_INTERVAL_BACKGROUND_MS = 2e3;
+var DEFAULT_TIMEOUT_MS = 2 * 60 * 1e3;
+var MAX_POLL_TIME_MS = 5 * 60 * 1e3;
+var DEFAULT_THOTH_COMMAND = ["npx", "-y", "thoth-mem"];
+
+// 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) ?? ""];
+}
+
+// src/agents/prompt-dialects.ts
+var OPENCODE_CAPABILITIES = {
+  agentDefinitions: "supported",
+  delegatedExecution: "supported",
+  parallelDelegation: "supported",
+  runtimeHooks: "supported",
+  mcpConfiguration: "supported",
+  skillPackaging: "supported",
+  rolePermissions: "supported",
+  parentContextInjection: "supported",
+  memoryGovernanceEnforcement: "supported"
+};
+var CODEX_PROMPT_CAPABILITIES = {
+  agentDefinitions: "supported",
+  delegatedExecution: "instruction-only",
+  parallelDelegation: "instruction-only",
+  runtimeHooks: "unknown",
+  mcpConfiguration: "supported",
+  skillPackaging: "supported",
+  rolePermissions: "instruction-only",
+  parentContextInjection: "instruction-only",
+  memoryGovernanceEnforcement: "instruction-only"
+};
+function supportedCapabilityProfile(capabilities) {
+  return {
+    capabilities,
+    renderCapabilityDisclosure: () => void 0
+  };
+}
+function codexCapabilityDisclosure(capability) {
+  const status = CODEX_PROMPT_CAPABILITIES[capability];
+  if (status === "supported") {
+    return void 0;
+  }
+  if (status === "unknown") {
+    return `${capability}: unknown in Codex; treat related behavior as diagnostic-only unless the active Codex host documents support.`;
+  }
+  return `${capability}: ${status} in Codex; preserve the role responsibility as prompt guidance because equivalent runtime enforcement is not guaranteed.`;
+}
+var OPENCODE_PROMPT_DIALECT = {
+  harness: "opencode",
+  tools: {
+    delegationTool: "task",
+    backgroundDelegationTool: "task(background=true)",
+    backgroundStatusTool: "task_status",
+    userQuestionTool: "question",
+    progressTool: "todowrite",
+    hostStatusSurface: "task_status",
+    roleReference: (role) => `@${role}`
+  },
+  capabilities: supportedCapabilityProfile(OPENCODE_CAPABILITIES),
+  dispatchLabel(method) {
+    switch (method) {
+      case "root-coordinator":
+        return "root coordinator";
+      case "task":
+        return "task";
+      case "synchronous-task-only":
+        return "synchronous task only";
+    }
+  },
+  renderRoleInvocation(role) {
+    return `@${role}`;
+  }
+};
+var CODEX_PROMPT_DIALECT = {
+  harness: "codex",
+  tools: {
+    delegationTool: "Codex custom-agent task",
+    backgroundDelegationTool: "Codex background role-agent run",
+    backgroundStatusTool: "Codex host status surface",
+    userQuestionTool: "request_user_input",
+    progressTool: "Codex progress tracking surface",
+    hostStatusSurface: "Codex host status surface",
+    roleReference: (role) => `${role} role agent`
+  },
+  capabilities: {
+    capabilities: CODEX_PROMPT_CAPABILITIES,
+    renderCapabilityDisclosure: codexCapabilityDisclosure
+  },
+  dispatchLabel(method) {
+    switch (method) {
+      case "root-coordinator":
+        return "ambient Codex root session coordinator";
+      case "task":
+        return "Codex custom-agent task";
+      case "synchronous-task-only":
+        return "synchronous Codex custom-agent task only";
+    }
+  },
+  renderRoleInvocation(role) {
+    return role === "orchestrator" ? "orchestrator role agent" : `${role} subagent`;
+  }
+};
+
+// src/agents/prompt-sections.ts
+function createQuestionProtocolSection() {
+  return {
+    kind: "question-protocol",
+    toolConcept: "userQuestion"
+  };
+}
+function createSubagentRulesSection(memoryAccess = "base") {
+  return {
+    kind: "subagent-rules",
+    memoryAccess,
+    progressConcept: "progress",
+    userQuestionConcept: "userQuestion"
+  };
+}
+function createResponseBudgetSection() {
+  return { kind: "response-budget" };
+}
+function createStepBudgetSection(steps) {
+  if (steps === void 0 || !Number.isInteger(steps) || steps <= 0) {
+    return void 0;
+  }
+  return { kind: "step-budget", steps };
+}
+function detectModelFamilyFromModel(model) {
+  const id = getPrimaryModelId(model)?.toLowerCase();
+  if (!id) {
+    return void 0;
+  }
+  if (id.includes("claude") || id.startsWith("anthropic/")) {
+    return "claude";
+  }
+  if (id.includes("gpt") || id.startsWith("openai/")) {
+    return "openai";
+  }
+  if (id.includes("gemini") || id.startsWith("google/")) {
+    return "gemini";
+  }
+  if (id.includes("kimi") || id.includes("k2")) {
+    return "kimi";
+  }
+  if (id.includes("glm") || id.startsWith("zai-")) {
+    return "glm";
+  }
+  return void 0;
+}
+function createModelFamilySection(role, model) {
+  const family = detectModelFamilyFromModel(model);
+  if (!family) {
+    return void 0;
+  }
+  return { kind: "model-family", role, family };
+}
+function roleText(template) {
+  return { kind: "role-text", template };
+}
+function specialistSections({
+  role,
+  mode,
+  dispatch,
+  scope,
+  responsibility,
+  rules,
+  memoryAccess,
+  output
+}) {
+  const dispatchLabel = dispatch === "task" ? "{{dispatch.task}}" : "{{dispatch.synchronous-task-only}}";
+  return [
+    roleText(`<role>
+You are ${role}.
+</role>
+
+<mode>
+- Mode: ${mode}
+- Dispatch method: ${dispatchLabel}
+- Scope: ${scope}
+</mode>
+
+<responsibility>
+${responsibility}
+</responsibility>
+
+<rules>`),
+    createSubagentRulesSection(memoryAccess),
+    roleText(`${rules.join("\n")}
+</rules>`),
+    createQuestionProtocolSection(),
+    roleText(`<output>`),
+    createResponseBudgetSection(),
+    roleText(`${output}
+</output>`)
+  ];
+}
+function createOrchestratorPromptSections() {
+  return [
+    roleText(`<role>
+You are the delegate-first root coordinator and decision engine for thoth-agents.
+The root agent is the orchestrator/root coordinator for the session.
+Orchestrator-only, root-only, or orchestrator-owned rules still apply even if
+the harness does not name this agent "orchestrator".
+</role>
+
+<style>
+Respond in the user's language. Be warm, direct, evidence-led, and concise.
+Push back when context, risk, or assumptions are weak. Avoid verbosity.
+</style>
+
+<core-rules>
+- Mode: primary coordinator. Mutation: none.
+- Load \`thoth-mem-agents\` and \`requirements-interview\`.
+- You MUST NOT read or write any file in the workspace except \`openspec/\` coordination artifacts for the SDD pipeline.
+- Delegate all inspection, writing, searching, debugging, and verification.
+- Own the thinking: analyze, choose approach, handle task sequencing, synthesize facts, decide, ask \`{{userQuestionTool}}\` for blocking user input, manage progress, own root-session memory, and write the final report.
+- Use sub-agents for evidence and action, not to outsource architecture or planning.
+- Never request raw file dumps from sub-agents; ask for findings, paths, line anchors, diffs, verification, and blockers.
+- Use openspec/ for coordination artifacts, especially
+  openspec/changes/{change-name}/tasks.md.
+- Visual or UX work and screenshots always go to {{role.designer}}.
+- Verify through delegation, not inline.
+- Verification should follow the user's project instructions and use the smallest sufficient delegated checks: typecheck, lint, focused tests, or build when appropriate.
+- When a harness cannot enforce a rule directly, preserve the rule as instruction-only guidance and disclose the enforcement gap instead of weakening the contract.
+</core-rules>
+
+<session-bootstrap>
+- At the start of a new root session, when thoth-mem tools are available, load \`thoth-mem-agents\` and \`requirements-interview\`, call \`mem_session_start\` with the current project and session identity, then save the real user prompt with \`mem_save_prompt\`.
+- Save only the real user request with \`mem_save_prompt\`; never save generated sub-agent prompts, handoffs, summaries, or tool scaffolding as user intent.
+- If thoth-mem tools or required session/project identity are unavailable, disclose that memory bootstrap could not run and continue without pretending memory was saved.
+</session-bootstrap>
+
+<routing>
+{{role.explorer}}: read-only codebase discovery. Use for broad search, symbols, references, unknown paths, or multiple candidates.
+{{role.librarian}}: read-only external docs/public examples. Use for version-sensitive APIs, official docs, or unfamiliar libraries.
+{{role.oracle}}: read-only review/diagnosis. Use for architecture, security/correctness risk, plan review, persistent bugs, or high-stakes ambiguity.
+{{role.designer}}: write-capable UI/UX owner. Use for user-facing UI, styles, layout, interactions, and all visual QA.
+{{role.quick}}: write-capable narrow implementer. Use for clear, mechanical, low-risk, uniform edits.
+{{role.deep}}: write-capable thorough implementer. Use for backend logic, data flow, APIs, state, refactors, edge cases, or correctness-critical work.
+
+Tiebreakers:
+- User-facing UI -> {{role.designer}}. Backend/system logic -> {{role.deep}}. Mechanical pattern -> {{role.quick}}.
+- Discovery first when paths or facts are unknown; implementation agent may read known local context for its own task, but should not redo broad discovery already assigned to {{role.explorer}}/{{role.librarian}}.
+- Do not use {{role.oracle}} for routine synthesis. After {{role.explorer}}/{{role.librarian}} results, you combine facts, inferences, unknowns, confidence, and next step.
+</routing>
+
+<subagent-prompts>
+- Every sub-agent prompt you write must be in English, regardless of the user's language.
+- Keep user-facing replies in the user's language, but translate delegated task prompts, internal handoffs, SDD envelopes, and verification requests into English.
+- Prefer 2-3 surgical discovery probes over one broad exploration when independent facts can be gathered in parallel.
+- A surgical probe asks one narrow question and returns only the anchors needed for your decision.
+</subagent-prompts>
+
+<internal-handoff>
+Before dispatching {{role.designer}}, {{role.quick}}, or {{role.deep}} after discovery, synthesize a compact internal handoff. This is an implementation detail between you and sub-agents, not a user-facing step or artifact.
+
+Internal handoff fields: Goal, Decision, Evidence, Scope, Steps, Verification, and Uncertainty. Include relevant files, symbols, anchors, constraints, non-goals, and what to escalate instead of guessing.
+
+Never mention the internal handoff to the user, ask the user to prepare it, or present handoff preparation as the recommended next step. To the user, describe the actual work: discovery, design, implementation, verification, or the concrete decision needed.
+
+For {{role.explorer}}/{{role.librarian}}, ask narrow fact-finding questions for likely files, symbols, call sites, constraints, examples, versioned API facts, and verification targets. Require decision-ready findings, not raw context.
+</internal-handoff>
+
+<dispatch>
+- If independent delegations are ready, launch them in the same response.
+- Default to normal synchronous \`{{delegationTool}}\` execution.
+- Experimental background \`{{backgroundDelegationTool}}\` is allowed only for {{role.explorer}} and {{role.librarian}} for asynchronous delegation.
+- {{role.oracle}}, {{role.designer}}, {{role.quick}}, and {{role.deep}} always use normal synchronous \`{{delegationTool}}\` execution.
+- When using background \`{{delegationTool}}\`, treat it as conditional and non-portable: if the host does not expose the experimental path, fall back to normal synchronous \`{{delegationTool}}\`.
+- Use \`{{backgroundStatusTool}}\` to wait, poll, and collect background task results before synthesizing or reporting completion.
+- If a result is empty, contradictory, or low-confidence, retry once with a materially sharper prompt; then escalate with evidence via \`{{userQuestionTool}}\`.
+- If a named subagent hits capacity, retry that same role up to 3 attempts.
+- Never switch to \`default\`, \`worker\`, or any other role.
+- After 3 failures, stay on the same role; if a same-role model override exists, use it. Otherwise report a capacity blocker.
+- Write-capable dispatches must include the internal handoff when one exists, so implementers can edit instead of rediscovering the plan.
+- Never tell sub-agents to discard working-tree changes.
+</dispatch>
+
+<sdd>
+All work always starts with requirements-interview skill.
+
+Routes:
+- Direct implementation for low-complexity work.
+- Accelerated SDD: propose -> tasks.
+- Full SDD: propose -> spec -> design -> tasks.
+
+Hard gates:
+- Artifact-producing SDD phases are dispatched to {{role.deep}} or {{role.quick}} with the matching skill loaded.
+- {{role.oracle}} is read-only and only handles plan-reviewer.
+- Never skip artifacts or jump from requirements-interview to implementation when SDD is selected.
+- Before SDD execution, load \`executing-plans\`; then track progress in {{progressTool}} plus the persistent artifact.
+- If openspec persistence is selected and openspec/ is missing, dispatch sdd-init first.
+- During SDD execution, batch compatible implementation work.
+- Group consecutive ready SDD tasks for the same execution agent into one dispatch when dependencies, scope, and verification can be handled together. Keep per-task tracking and evidence; do not split a compatible {{role.designer}}/{{role.quick}}/{{role.deep}} run into one delegation per checkbox.
+
+SDD dispatch envelope must include: skill name, persistence mode, pipeline type, change name, project name, needed prior artifact context, verification expectation, and return envelope.
+After each phase, verify the sub-agent reported the openspec path and/or thoth-mem topic_key. Retry once if missing.
+
+Artifact governance handoff:
+- After \`sdd-tasks\`, you may surface report-only artifact governance findings before execution preparation starts.
+- Delegate governance inspection; do not inspect repository artifacts inline.
+- Do not treat governance findings as an execution gate.
+- Do not let governance validation replace \`plan-reviewer\` or \`executing-plans\`.
+- Root thoth-mem ownership stays with you; sub-agents may surface findings but must not own session memory, prompts, or progress checkpoints.
+
+Plan gate: after tasks, ask with \`{{userQuestionTool}}\`: "Review plan with {{role.oracle}} before executing (Recommended)" or "Proceed to execution".
+If reviewed, the review loop is complete only after [OKAY].
+If {{role.oracle}} returns [OKAY], ask the user with \`{{userQuestionTool}}\` whether to proceed to implementation or stop with the approved plan.
+Do not dispatch \`sdd-apply\` after oracle approval until the user confirms implementation.
+Post-execution: delegate sdd-verify, then sdd-archive when verification passes.
+</sdd>
+
+<progress-memory>
+- Keep {{progressTool}} top-level and lean for multi-step work.
+- When SDD is active, update both {{progressTool}} and openspec/changes/{change-name}/tasks.md before dispatch and after results.
+- Root-session memory is yours: search before repeated work; save durable decisions, discoveries, bugs, patterns, constraints, and session summaries.
+- Durable \`mem_save\` guidance: save architecture decisions, accepted or rejected recommendations, bug fixes with root cause, non-obvious discoveries, conventions, configuration changes, and durable user preferences. Use stable topic keys for evolving topics, and keep general observations outside the protected \`sdd/*\` namespace.
+- Targeted 3-layer recall protocol: \`mem_search\` with compact results -> \`mem_timeline\` around promising observations -> \`mem_get_observation\` only for records needed in full. Use preview search only when compact results do not disambiguate.
+- SDD memory artifacts use deterministic topic keys only in thoth-mem or hybrid persistence modes: \`sdd/{change}/{artifact}\`.
+- Before ending the root session, call \`mem_session_summary\` with a concise Goal, Instructions, Discoveries, Accomplished, Next Steps, and Relevant Files summary. Do not claim memory was saved unless the tool call succeeded.
+- After compaction, first preserve the compacted summary with \`mem_session_summary\`, then recover recent context and use the 3-layer recall protocol before continuing work.
+</progress-memory>
+
+<communication>
+State the plan briefly, delegate, then summarize outcomes without replaying raw work. Before any tool call or delegation, emit a short user-visible status/preamble that names the next action and target; for parallel dispatches, one compact sentence covering the batch is enough. Keep preambles about next action, evidence, and verification, not private reasoning. Separate evidence, inference, and uncertainty when it matters. Never ask blocking questions in prose.
+</communication>`),
+    createQuestionProtocolSection()
+  ];
+}
+function createReadOnlySpecialistPromptSections(role) {
+  if (role === "explorer") {
+    return specialistSections({
+      role,
+      mode: "read-only",
+      dispatch: "task",
+      scope: "local repository discovery",
+      responsibility: "Find workspace facts fast. Return decision-ready evidence for internal handoffs: paths, lines, symbols, candidate files, constraints, edit targets, verification targets, and conclusions.",
+      rules: [
+        "- Questions should be rare; exhaust local evidence first.",
+        "- Prefer paths, lines, symbols, and concise summaries over dumps.",
+        "- Do not implement, edit files, mutate the repository, or own durable session memory.",
+        "- When full content is explicitly requested, reproduce it faithfully."
+      ],
+      memoryAccess: "readonly",
+      output: `
+Return exactly these sections, in this order:
+
+STATUS: one of CONFIRMED | PARTIAL | INCONCLUSIVE
+- CONFIRMED = direct evidence answers the question with high confidence.
+- PARTIAL = some direct evidence, but gaps remain or multiple candidates exist.
+- INCONCLUSIVE = no sufficient evidence found. Never fabricate a confident answer from naming similarity alone.
+
+FINDINGS: bullets with claim, evidence type [direct|inferred|assumed], confidence [high|medium|low], and file:line anchors for concrete claims.
+
+ALTERNATIVES CONSIDERED: ranked candidates when more than one plausible match exists. Omit if only one candidate.
+
+UNRESOLVED QUESTIONS: ambiguity and what context would unblock it.
+
+UNCHECKED AREAS: what you did not inspect that could change the answer. Omit if nothing notable.
+
+SHORT EVIDENCE: at most one 2-line excerpt per key finding.
+
+Lead with STATUS. Stay under 40 lines total when possible. If the schema forces more lines, exceed the budget rather than drop required fields.`
+    });
+  }
+  if (role === "librarian") {
+    return specialistSections({
+      role,
+      mode: "read-only",
+      dispatch: "task",
+      scope: "external docs and research plus local confirmation when needed",
+      responsibility: "Gather authoritative external evidence that helps the orchestrator make implementation decisions. Prefer official docs first, include version sensitivity, then high-signal public examples. Every substantive claim must carry a source URL.",
+      rules: [
+        "- Questions should be rare; exhaust available sources first.",
+        "- Prefer official documentation over commentary when both answer the same point.",
+        "- Distinguish clearly between official guidance and community examples.",
+        "- Do not mutate the repository, invent undocumented APIs, or perform broad implementation work."
+      ],
+      memoryAccess: "readonly",
+      output: `- Organize by finding. Include a source URL for every claim.
+- Distinguish official docs from community examples.
+- Return synthesized findings, not full documentation excerpts.
+- Target: under 40 lines total.`
+    });
+  }
+  return specialistSections({
+    role,
+    mode: "read-only",
+    dispatch: "synchronous task only",
+    scope: "advice, diagnosis, architecture, code review, and plan review",
+    responsibility: "Provide read-only review and strategic technical guidance anchored to evidence, including findings, risks, assumptions, and decision-ready conclusions. Use systematic-debugging for bugs, plan-reviewer for SDD plans, and web-assisted research when deeper diagnosis needs it.",
+    rules: [
+      "- Cite exact files and lines for local claims.",
+      "- Separate observations, risks, and recommendations.",
+      "- Ask only when tradeoffs, risk tolerance, or approval materially change the recommendation.",
+      "- Do not produce SDD artifacts, implement edits, or mutate the workspace."
+    ],
+    memoryAccess: "readonly",
+    output: `- Cite exact files and lines \u2014 do not quote large code blocks.
+- Separate observations, risks, and recommendations.
+- For diagnosis: root cause + fix recommendation, not step-by-step trace.
+- Target: under 50 lines total.`
+  });
+}
+function createWriteCapableSpecialistPromptSections(role) {
+  if (role === "designer") {
+    return specialistSections({
+      role,
+      mode: "write-capable",
+      dispatch: "synchronous task only",
+      scope: "UI/UX decisions, implementation, and visual verification",
+      responsibility: "Own the user-facing solution: choose the UX approach, implement it, and verify it visually through the visual verification surface across responsive states. Capture evidence once in non-blocking single-run mode.\nFor visual QA-only tasks, inspect the UI, summarize what is correct, note issues, recommend fixes.",
+      rules: [
+        "- Treat the orchestrator's internal handoff as the handoff; do not rediscover settled scope or constraints.",
+        "- Own UX decisions unless a real user preference is required.",
+        "- Verify visually and check responsive behavior when feasible; do not stop at code that merely compiles.",
+        "- Delete temporary evidence you generated, such as screenshots, once it is no longer needed; if it is for root/orchestrator review, list it in your final output as garbage to delete after review.",
+        "- Keep changes focused on the user-facing outcome.",
+        "- Preserve unrelated working-tree changes.",
+        "- Avoid interactive or persistent visual verification unless explicitly requested; keep it single-run, evidence-driven."
+      ],
+      memoryAccess: "writable",
+      output: `For SDD tasks: use the Task Result envelope (Status, Task, What was done, Files changed, Verification, Issues).
+For non-SDD work: state what was implemented, verification status, and remaining caveats.
+- Include visual verification status when applicable.
+- Target: under 30 lines total.`
+    });
+  }
+  if (role === "quick") {
+    return specialistSections({
+      role,
+      mode: "write-capable",
+      dispatch: "synchronous task only",
+      scope: "fast bounded implementation",
+      responsibility: "Implement well-defined changes quickly. Favor speed over exhaustive analysis when the task is narrow, low-risk, mechanical, and the path is clear.",
+      rules: [
+        "- Optimize for fast execution on narrow, clear tasks.",
+        "- Treat the orchestrator's internal handoff as the starting point; follow its file anchors, scope, non-goals, and verification target.",
+        "- Preserve unrelated working-tree changes.",
+        "- Read only the context you need.",
+        "- Do not redo broad discovery. If the handoff lacks essential anchors, surface the missing context instead of turning the task into open-ended exploration.",
+        "- Avoid multi-step planning; if the task stops being bounded, surface it.",
+        "- Ask only for implementation-local ambiguity, not orchestrator-level routing.",
+        "- NEVER run git commands that discard changes (`git restore`, `git checkout --`, `git reset`, `git clean`). Files modified by prior tasks are intentional SDD progress, not unintended changes."
+      ],
+      memoryAccess: "writable",
+      output: `For SDD tasks: use the Task Result envelope (Status, Task, What was done, Files changed, Verification, Issues).
+For non-SDD work: status + summary + files changed + issues. Nothing more.
+- Target: under 20 lines total.`
+    });
+  }
+  return specialistSections({
+    role,
+    mode: "write-capable",
+    dispatch: "synchronous task only",
+    scope: "thorough implementation and verification",
+    responsibility: "Handle correctness-critical, multi-file, or edge-case-heavy changes with full local context analysis. Use test-driven-development and systematic-debugging when relevant before implementing fixes.",
+    rules: [
+      "- Treat the orchestrator's internal handoff as the architecture handoff; validate it against nearby code, but do not restart upstream discovery unless evidence contradicts it.",
+      "- Do not skip verification \u2014 thoroughness is your value proposition.",
+      "- Investigate related files, types, and call sites before changing shared behavior, prioritizing the anchors and constraints in the handoff.",
+      "- Preserve unrelated working-tree changes.",
+      "- Ask when a real architecture or implementation tradeoff blocks correct execution."
+    ],
+    memoryAccess: "writable",
+    output: `For SDD tasks: use the Task Result envelope (Status, Task, What was done, Files changed, Verification, Issues).
+For non-SDD work: summary + files changed + verification results + edge cases considered.
+- Save detailed analysis for follow-up requests; return only actionable conclusions.
+- Target: under 40 lines total.`
+  });
+}
+function getPrimaryModelId(model) {
+  if (Array.isArray(model)) {
+    const first = model[0];
+    return typeof first === "string" ? first : first?.id;
+  }
+  return model;
+}
+function renderQuestionProtocol(_section, dialect) {
+  return `<questions>
+Use \`${dialect.tools.userQuestionTool}\` only for blocking choices: unresolved ambiguity that changes the result, destructive/security-sensitive actions, or missing secrets. Do all non-blocked work first, ask one targeted question with a recommended default first, then stop.
+</questions>`;
+}
+function renderSubagentRules(section, dialect) {
+  const rules = [
+    `- Single-task leaf agent: do not delegate, manage SDD phases, act as orchestrator, or call \`${dialect.tools.progressTool}\`.`,
+    `- Use \`${dialect.tools.userQuestionTool}\` only for local blocking decisions.`,
+    "- Never discard working-tree changes: no `git restore`, `git checkout -- <path>`, `git reset --hard`, `git clean`, or `git stash`.",
+    "- Avoid blocking/watch commands; use terminating checks only."
+  ];
+  if (section.memoryAccess === "readonly") {
+    rules.push(
+      "- Use read-only thoth-mem only when dispatch gives session_id/project: `mem_search` -> `mem_timeline` -> `mem_get_observation`.",
+      "- Never call `mem_session_start`, `mem_session_summary`, or `mem_save_prompt`; those tools are orchestrator-owned.",
+      "- Never write memory; memory writes are orchestrator-owned."
+    );
+  }
+  if (section.memoryAccess === "writable") {
+    rules.push(
+      "- Use delegated thoth-mem tools only (mem_save, mem_search, mem_get_observation, mem_timeline, mem_suggest_topic_key).",
+      "- Never call `mem_session_start`, `mem_session_summary`, or `mem_save_prompt`; those tools are orchestrator-owned.",
+      "- Always use the parent session_id/project from dispatch for every thoth-mem call.",
+      "- If either is missing, do NOT call thoth-mem.",
+      "- For reads, use only `mem_search` -> `mem_timeline` -> `mem_get_observation`.",
+      "- You do not own durable memory of your own; `mem_save` writes under the orchestrator's session/project only."
+    );
+  }
+  return rules.join("\n");
+}
+function renderResponseBudget() {
+  return "Return concise structured results: status, summary, files, verification/issues. Never return raw file dumps.";
+}
+function renderStepBudget(section) {
+  return `<step-budget>
+- You have a hard execution budget of ${section.steps} steps.
+- Plan your tool use before acting, prioritize the highest-signal checks first, and stop once you have enough evidence to answer.
+- Avoid repeated searches or reads. If the remaining work will exceed the budget, return partial findings with the next best target instead of looping.
+</step-budget>`;
+}
+function getRoleModelProfile(role) {
+  switch (role) {
+    case "orchestrator":
+      return "- Exploit your role by selecting the right specialist category, launching independent tasks together, and synthesizing facts/inferences/unknowns before the next dispatch.";
+    case "explorer":
+      return "- Exploit your role by scanning broadly first, then narrowing to symbol/path evidence with ranked candidates and confidence.";
+    case "librarian":
+      return "- Exploit your role by prioritizing official docs, dates, versions, and source quality before summarizing public examples.";
+    case "oracle":
+      return "- Exploit your role by challenging assumptions, identifying risk, and giving a decision-ready recommendation backed by evidence.";
+    case "designer":
+      return "- Exploit your role by making concrete UX choices, implementing them, and verifying the visible result instead of stopping at code review.";
+    case "quick":
+      return "- Exploit your role by applying the smallest clear edit, avoiding broad exploration, and returning immediately after focused verification.";
+    case "deep":
+      return "- Exploit your role by building a complete mental model of shared behavior, writing tests first when behavior changes, and verifying edge cases.";
+  }
+}
+function renderModelFamily(section) {
+  const roleGuidance = getRoleModelProfile(section.role);
+  if (section.family === "claude") {
+    return `<model-profile family="claude">
+- Use XML-like sections, label uncertainty, and delegate aggressively when agentic.
+${roleGuidance}
+</model-profile>`;
+  }
+  if (section.family === "openai") {
+    return `<model-profile family="openai">
+- Plan briefly, then act. Keep tool dispatch explicit: action, target, return shape.
+${roleGuidance}
+</model-profile>`;
+  }
+  if (section.family === "gemini") {
+    return `<model-profile family="gemini">
+- Use long-context breadth deliberately, then ground conclusions in exact anchors.
+${roleGuidance}
+</model-profile>`;
+  }
+  if (section.family === "kimi") {
+    return `<model-profile family="kimi">
+- Favor repository-scale navigation before edits; keep patches grounded in current file state.
+${roleGuidance}
+</model-profile>`;
+  }
+  return `<model-profile family="glm">
+- Use compact checklists, conservative steps, clear verification, and concrete blockers.
+${roleGuidance}
+</model-profile>`;
+}
+function renderRoleText(section, dialect) {
+  return section.template.replaceAll("{{delegationTool}}", dialect.tools.delegationTool).replaceAll(
+    "{{backgroundDelegationTool}}",
+    dialect.tools.backgroundDelegationTool ?? dialect.tools.delegationTool
+  ).replaceAll(
+    "{{backgroundStatusTool}}",
+    dialect.tools.backgroundStatusTool ?? dialect.tools.hostStatusSurface ?? ""
+  ).replaceAll("{{userQuestionTool}}", dialect.tools.userQuestionTool).replaceAll("{{progressTool}}", dialect.tools.progressTool).replaceAll("{{dispatch.task}}", dialect.dispatchLabel("task")).replaceAll(
+    "{{dispatch.synchronous-task-only}}",
+    dialect.dispatchLabel("synchronous-task-only")
+  ).replace(
+    /\{\{role\.(\w+)\}\}/g,
+    (_match, role) => dialect.renderRoleInvocation(role)
+  );
+}
+function renderPromptSection(section, dialect) {
+  switch (section.kind) {
+    case "question-protocol":
+      return renderQuestionProtocol(section, dialect);
+    case "subagent-rules":
+      return renderSubagentRules(section, dialect);
+    case "response-budget":
+      return renderResponseBudget();
+    case "step-budget":
+      return renderStepBudget(section);
+    case "model-family":
+      return renderModelFamily(section);
+    case "role-text":
+      return renderRoleText(section, dialect);
+  }
+}
+function renderRolePrompt(sections, dialect) {
+  return sections.map((section) => renderPromptSection(section, dialect).trim()).filter(Boolean).join("\n\n");
+}
+
+// src/agents/prompt-utils.ts
+var QUESTION_PROTOCOL = renderPromptSection(
+  createQuestionProtocolSection(),
+  OPENCODE_PROMPT_DIALECT
+);
+var SUBAGENT_RULES = renderPromptSection(
+  createSubagentRulesSection("base"),
+  OPENCODE_PROMPT_DIALECT
+);
+var SUBAGENT_RULES_READONLY = renderPromptSection(
+  createSubagentRulesSection("readonly"),
+  OPENCODE_PROMPT_DIALECT
+);
+var SUBAGENT_RULES_WRITABLE = renderPromptSection(
+  createSubagentRulesSection("writable"),
+  OPENCODE_PROMPT_DIALECT
+);
+var RESPONSE_BUDGET = renderPromptSection(
+  createResponseBudgetSection(),
+  OPENCODE_PROMPT_DIALECT
+);
+function trimPromptSection(section) {
+  const trimmed = section?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function appendPromptSections(...sections) {
+  return sections.map(trimPromptSection).filter(Boolean).join("\n\n");
+}
+function detectModelFamily(model) {
+  return detectModelFamilyFromModel(model);
+}
+function getStepBudgetPromptSection(steps) {
+  const section = createStepBudgetSection(steps);
+  if (!section) {
+    return void 0;
+  }
+  return renderPromptSection(section, OPENCODE_PROMPT_DIALECT);
+}
+function getModelFamilyPromptSection(role, model) {
+  const section = createModelFamilySection(role, model);
+  if (!section) {
+    return void 0;
+  }
+  return renderPromptSection(section, OPENCODE_PROMPT_DIALECT);
+}
+function replacePromptPlaceholders(template, placeholders = {}) {
+  return Object.entries(placeholders).reduce((prompt, [key, value]) => {
+    if (value === void 0) {
+      return prompt;
+    }
+    return prompt.replaceAll(`{{${key}}}`, String(value));
+  }, template);
+}
+function composeAgentPrompt({
+  basePrompt,
+  customPrompt,
+  customAppendPrompt,
+  placeholders
+}) {
+  const resolvedBase = replacePromptPlaceholders(basePrompt, placeholders);
+  if (customPrompt) {
+    return replacePromptPlaceholders(customPrompt, placeholders);
+  }
+  return appendPromptSections(
+    resolvedBase,
+    replacePromptPlaceholders(customAppendPrompt ?? "", placeholders)
+  );
+}
+
+// src/cli/custom-skills.ts
+import {
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync2,
+  rmSync,
+  statSync as statSync3
+} from "fs";
+import { dirname as dirname2, join as join4, parse } from "path";
+import { fileURLToPath } from "url";
+
+// src/harness/core/skills.ts
+var ORCHESTRATOR_ONLY = ["orchestrator"];
+var SHARED_SKILL_SUPPORT = {
+  name: "_shared",
+  description: "Shared OpenSpec, persistence, and thoth-mem SDD conventions",
+  allowedRoles: [
+    "orchestrator",
+    "explorer",
+    "librarian",
+    "oracle",
+    "designer",
+    "quick",
+    "deep"
+  ],
+  sourcePath: "src/skills/_shared",
+  kind: "shared-support",
+  purpose: "support"
+};
+var BUNDLED_SKILL_REGISTRY = [
+  {
+    name: "requirements-interview",
+    description: "Mandatory step-0 discovery interview to understand user intent, clarify scope, and choose the right path before implementation",
+    allowedRoles: ORCHESTRATOR_ONLY,
+    sourcePath: "src/skills/requirements-interview",
+    kind: "skill",
+    purpose: "requirements"
+  },
+  {
+    name: "thoth-mem-agents",
+    description: "Orchestrator/subagent thoth-mem workflow contract for parent session_id/project ownership, prompt-save prohibitions, and safe durable memory usage",
+    allowedRoles: [
+      "orchestrator",
+      "explorer",
+      "librarian",
+      "oracle",
+      "designer",
+      "quick",
+      "deep"
+    ],
+    sourcePath: "src/skills/thoth-mem-agents",
+    kind: "skill",
+    purpose: "memory"
+  },
+  {
+    name: "plan-reviewer",
+    description: "Review SDD task plans for execution blockers and valid references",
+    allowedRoles: ["orchestrator", "oracle"],
+    sourcePath: "src/skills/plan-reviewer",
+    kind: "skill",
+    purpose: "review"
+  },
+  {
+    name: "sdd-init",
+    description: "Initialize OpenSpec structure and SDD project context",
+    allowedRoles: ORCHESTRATOR_ONLY,
+    sourcePath: "src/skills/sdd-init",
+    kind: "skill",
+    purpose: "sdd"
+  },
+  {
+    name: "sdd-propose",
+    description: "Create change proposals for OpenSpec workflows",
+    allowedRoles: ORCHESTRATOR_ONLY,
+    sourcePath: "src/skills/sdd-propose",
+    kind: "skill",
+    purpose: "sdd"
+  },
+  {
+    name: "sdd-spec",
+    description: "Write OpenSpec delta specifications",
+    allowedRoles: ORCHESTRATOR_ONLY,
+    sourcePath: "src/skills/sdd-spec",
+    kind: "skill",
+    purpose: "sdd"
+  },
+  {
+    name: "sdd-design",
+    description: "Create technical solution design artifacts for changes",
+    allowedRoles: ORCHESTRATOR_ONLY,
+    sourcePath: "src/skills/sdd-design",
+    kind: "skill",
+    purpose: "sdd"
+  },
+  {
+    name: "sdd-tasks",
+    description: "Generate phased implementation task checklists",
+    allowedRoles: ORCHESTRATOR_ONLY,
+    sourcePath: "src/skills/sdd-tasks",
+    kind: "skill",
+    purpose: "sdd"
+  },
+  {
+    name: "sdd-apply",
+    description: "Execute tasks and persist implementation progress",
+    allowedRoles: ORCHESTRATOR_ONLY,
+    sourcePath: "src/skills/sdd-apply",
+    kind: "skill",
+    purpose: "sdd"
+  },
+  {
+    name: "executing-plans",
+    description: "Execute SDD task lists with real-time progress tracking, sub-agent dispatch, and verification checkpoints",
+    allowedRoles: ORCHESTRATOR_ONLY,
+    sourcePath: "src/skills/executing-plans",
+    kind: "skill",
+    purpose: "sdd"
+  },
+  {
+    name: "sdd-verify",
+    description: "Build verification reports and compliance matrices",
+    allowedRoles: ORCHESTRATOR_ONLY,
+    sourcePath: "src/skills/sdd-verify",
+    kind: "skill",
+    purpose: "sdd"
+  },
+  {
+    name: "sdd-archive",
+    description: "Archive completed OpenSpec changes with audit trails",
+    allowedRoles: ORCHESTRATOR_ONLY,
+    sourcePath: "src/skills/sdd-archive",
+    kind: "skill",
+    purpose: "sdd"
+  }
+];
+var SKILL_REGISTRY = [
+  ...BUNDLED_SKILL_REGISTRY,
+  SHARED_SKILL_SUPPORT
+];
+function getSkillRegistry() {
+  return SKILL_REGISTRY.map((entry) => ({
+    ...entry,
+    allowedRoles: [...entry.allowedRoles]
+  }));
+}
+
+// src/cli/skill-manifest.ts
+import { createHash } from "crypto";
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  readFileSync as readFileSync3,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { join as join3, relative } from "path";
+var SHARED_SKILL_DIRECTORY = "_shared";
+var SKILLS_SOURCE_ROOT = join3("src", "skills");
+var MANIFEST_FILE_NAME = ".skill-manifest.json";
+function getManifestPath() {
+  return join3(getCustomSkillsDir(), MANIFEST_FILE_NAME);
+}
+function listFilesRecursive(dirPath) {
+  if (!existsSync4(dirPath)) {
+    return [];
+  }
+  const files = [];
+  const entries = readdirSync(dirPath).sort(
+    (left, right) => left.localeCompare(right)
+  );
+  for (const entry of entries) {
+    const entryPath = join3(dirPath, entry);
+    const stat = statSync2(entryPath);
+    if (stat.isDirectory()) {
+      files.push(...listFilesRecursive(entryPath));
+      continue;
+    }
+    files.push(entryPath);
+  }
+  return files;
+}
+function readPackageVersion(packageRoot) {
+  const packageJsonPath = join3(packageRoot, "package.json");
+  const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+  if (typeof packageJson.version !== "string" || packageJson.version.length === 0) {
+    throw new Error(`Invalid package version in ${packageJsonPath}`);
+  }
+  return packageJson.version;
+}
+function readManifest() {
+  const manifestPath = getManifestPath();
+  if (!existsSync4(manifestPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync3(manifestPath, "utf-8"));
+  } catch (error) {
+    console.warn(`Failed to read skill manifest: ${manifestPath}`, error);
+    return null;
+  }
+}
+function writeManifest(manifest) {
+  const manifestPath = getManifestPath();
+  mkdirSync2(getCustomSkillsDir(), { recursive: true });
+  writeFileSync2(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+}
+function computeSkillHash(skillDirPath) {
+  const hash = createHash("sha256");
+  for (const filePath of listFilesRecursive(skillDirPath)) {
+    hash.update(`${relative(skillDirPath, filePath)}
+`);
+    hash.update(readFileSync3(filePath));
+    hash.update("\n");
+  }
+  return hash.digest("hex");
+}
+function findRemovedSkills(manifest) {
+  const currentSkillNames = new Set(CUSTOM_SKILLS.map((skill) => skill.name));
+  return Object.keys(manifest.skills).filter(
+    (skillName) => !currentSkillNames.has(skillName)
+  );
+}
+function checkSkillsNeedUpdate(packageRoot) {
+  const manifest = readManifest();
+  const pluginVersion = readPackageVersion(packageRoot);
+  const sharedHash = computeSkillHash(
+    join3(packageRoot, SKILLS_SOURCE_ROOT, SHARED_SKILL_DIRECTORY)
+  );
+  const versionChanged = manifest !== null && manifest.pluginVersion !== pluginVersion;
+  const sharedChanged = manifest !== null && manifest.sharedHash !== sharedHash;
+  const removedSkills = manifest ? findRemovedSkills(manifest) : [];
+  const skillsNeedingUpdate = CUSTOM_SKILLS.flatMap((skill) => {
+    const sourcePath = join3(packageRoot, skill.sourcePath);
+    const targetPath = join3(getCustomSkillsDir(), skill.name);
+    const sourceHash = computeSkillHash(sourcePath);
+    const manifestEntry = manifest?.skills[skill.name];
+    const reasons = [];
+    if (!manifest) {
+      reasons.push("manifest-missing");
+    }
+    if (versionChanged) {
+      reasons.push("version-change");
+    }
+    if (sharedChanged) {
+      reasons.push("shared-hash-mismatch");
+    }
+    if (!manifestEntry) {
+      reasons.push("new-skill");
+    } else if (manifestEntry.hash !== sourceHash) {
+      reasons.push("hash-mismatch");
+    }
+    if (!existsSync4(targetPath)) {
+      reasons.push("missing-install");
+    }
+    if (reasons.length === 0) {
+      return [];
+    }
+    return [
+      {
+        skill,
+        sourceHash,
+        targetPath,
+        reasons
+      }
+    ];
+  });
+  return {
+    pluginVersion,
+    sharedHash,
+    manifest,
+    versionChanged,
+    sharedChanged,
+    needsUpdate: skillsNeedingUpdate.length > 0 || removedSkills.length > 0,
+    skillsNeedingUpdate,
+    removedSkills
+  };
+}
+
+// src/cli/custom-skills.ts
+var SHARED_SKILL_DIRECTORY2 = "_shared";
+var SHARED_SKILL_SOURCE_PATH = `src/skills/${SHARED_SKILL_DIRECTORY2}`;
+var CUSTOM_SKILLS = BUNDLED_SKILL_REGISTRY.map(
+  (skill) => ({
+    name: skill.name,
+    description: skill.description,
+    allowedAgents: [...skill.allowedRoles],
+    sourcePath: skill.sourcePath
+  })
+);
+function getCustomSkillsDir() {
+  return join4(getConfigDir(), "skills");
+}
+function copyDirRecursive(src, dest) {
+  if (!existsSync5(dest)) {
+    mkdirSync3(dest, { recursive: true });
+  }
+  const entries = readdirSync2(src);
+  for (const entry of entries) {
+    const srcPath = join4(src, entry);
+    const destPath = join4(dest, entry);
+    const stat = statSync3(srcPath);
+    if (stat.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      const destDir = dirname2(destPath);
+      if (!existsSync5(destDir)) {
+        mkdirSync3(destDir, { recursive: true });
+      }
+      copyFileSync2(srcPath, destPath);
+    }
+  }
+}
+function installSharedSkillAssets(packageRoot) {
+  const sharedSourcePath = join4(packageRoot, SHARED_SKILL_SOURCE_PATH);
+  const sharedTargetPath = join4(getCustomSkillsDir(), SHARED_SKILL_DIRECTORY2);
+  if (!existsSync5(sharedSourcePath)) {
+    console.error(`Custom skill shared assets not found: ${sharedSourcePath}`);
+    return false;
+  }
+  rmSync(sharedTargetPath, { recursive: true, force: true });
+  copyDirRecursive(sharedSourcePath, sharedTargetPath);
+  return true;
+}
+function findPackageRoot(startDir) {
+  let currentDir = startDir;
+  const filesystemRoot = parse(startDir).root;
+  while (true) {
+    if (existsSync5(join4(currentDir, "package.json")) && existsSync5(join4(currentDir, "src", "skills"))) {
+      return currentDir;
+    }
+    if (currentDir === filesystemRoot) {
+      return null;
+    }
+    const parentDir = dirname2(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+function resolvePackageRoot(packageRoot) {
+  if (packageRoot) {
+    return packageRoot;
+  }
+  const moduleDir = fileURLToPath(new URL(".", import.meta.url));
+  return findPackageRoot(moduleDir) ?? fileURLToPath(new URL("../..", import.meta.url));
+}
+function installCustomSkillFiles(skill, packageRoot) {
+  const sourcePath = join4(packageRoot, skill.sourcePath);
+  const targetPath = join4(getCustomSkillsDir(), skill.name);
+  if (!existsSync5(sourcePath)) {
+    console.error(`Custom skill source not found: ${sourcePath}`);
+    return false;
+  }
+  rmSync(targetPath, { recursive: true, force: true });
+  copyDirRecursive(sourcePath, targetPath);
+  return true;
+}
+function removeObsoleteSkills(removedSkillNames) {
+  const removedSkills = [];
+  for (const skillName of removedSkillNames) {
+    const targetPath = join4(getCustomSkillsDir(), skillName);
+    try {
+      console.log(`Removing obsolete bundled skill: ${skillName}`);
+      rmSync(targetPath, { recursive: true, force: true });
+      removedSkills.push(skillName);
+    } catch (error) {
+      console.warn(`Failed to remove obsolete bundled skill: ${skillName}`);
+      console.warn(error);
+    }
+  }
+  return removedSkills;
+}
+function buildManifest(packageRoot, updatedSkills, previousManifest, pluginVersion, sharedHash) {
+  const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedSkillNames = new Set(
+    updatedSkills.map(({ skill }) => skill.name)
+  );
+  const skills = Object.fromEntries(
+    CUSTOM_SKILLS.map((skill) => {
+      const previousEntry = previousManifest?.skills[skill.name];
+      const nextInstalledAt = updatedSkillNames.has(skill.name) ? installedAt : previousEntry?.installedAt ?? installedAt;
+      return [
+        skill.name,
+        {
+          hash: computeSkillHash(join4(packageRoot, skill.sourcePath)),
+          installedAt: nextInstalledAt
+        }
+      ];
+    })
+  );
+  return {
+    pluginVersion,
+    sharedHash,
+    skills
+  };
+}
+function pruneRemovedSkillsFromManifest(manifest, removedSkills) {
+  const removedSkillNames = new Set(removedSkills);
+  return {
+    ...manifest,
+    skills: Object.fromEntries(
+      Object.entries(manifest.skills).filter(
+        ([skillName]) => !removedSkillNames.has(skillName)
+      )
+    )
+  };
+}
+function installCustomSkills(packageRoot = resolvePackageRoot()) {
+  const updateCheck = checkSkillsNeedUpdate(packageRoot);
+  if (!updateCheck.needsUpdate) {
+    return {
+      success: true,
+      updatedSkills: [],
+      skippedSkills: [...CUSTOM_SKILLS],
+      failedSkills: [],
+      removedSkills: []
+    };
+  }
+  const removedSkills = removeObsoleteSkills(updateCheck.removedSkills);
+  if (removedSkills.length > 0 && updateCheck.manifest) {
+    writeManifest(
+      pruneRemovedSkillsFromManifest(updateCheck.manifest, removedSkills)
+    );
+  }
+  if (updateCheck.skillsNeedingUpdate.length === 0) {
+    writeManifest(
+      buildManifest(
+        packageRoot,
+        [],
+        updateCheck.manifest,
+        updateCheck.pluginVersion,
+        updateCheck.sharedHash
+      )
+    );
+    return {
+      success: true,
+      updatedSkills: [],
+      skippedSkills: [...CUSTOM_SKILLS],
+      failedSkills: [],
+      removedSkills
+    };
+  }
+  if (!installSharedSkillAssets(packageRoot)) {
+    return {
+      success: false,
+      updatedSkills: [],
+      skippedSkills: [],
+      failedSkills: updateCheck.skillsNeedingUpdate.map(
+        ({ skill, reasons }) => ({
+          skill,
+          reasons
+        })
+      ),
+      removedSkills
+    };
+  }
+  const updatesBySkillName = new Map(
+    updateCheck.skillsNeedingUpdate.map((entry) => [entry.skill.name, entry])
+  );
+  const updatedSkills = [];
+  const skippedSkills = [];
+  const failedSkills = [];
+  for (const skill of CUSTOM_SKILLS) {
+    const pendingUpdate = updatesBySkillName.get(skill.name);
+    if (!pendingUpdate) {
+      skippedSkills.push(skill);
+      continue;
+    }
+    if (installCustomSkillFiles(skill, packageRoot)) {
+      updatedSkills.push({
+        skill,
+        reasons: pendingUpdate.reasons
+      });
+      continue;
+    }
+    failedSkills.push({
+      skill,
+      reasons: pendingUpdate.reasons
+    });
+  }
+  if (failedSkills.length > 0) {
+    return {
+      success: false,
+      updatedSkills,
+      skippedSkills,
+      failedSkills,
+      removedSkills
+    };
+  }
+  writeManifest(
+    buildManifest(
+      packageRoot,
+      updatedSkills,
+      updateCheck.manifest,
+      updateCheck.pluginVersion,
+      updateCheck.sharedHash
+    )
+  );
+  return {
+    success: true,
+    updatedSkills,
+    skippedSkills,
+    failedSkills,
+    removedSkills
+  };
+}
+
+// src/mcp/context7.ts
+var CONTEXT7_MCP_URL = "https://mcp.context7.com/mcp";
+var context7 = {
+  type: "remote",
+  url: CONTEXT7_MCP_URL,
+  headers: process.env.CONTEXT7_API_KEY ? { CONTEXT7_API_KEY: process.env.CONTEXT7_API_KEY } : void 0,
+  oauth: false
+};
+
+// src/mcp/exa.ts
+var exa = {
+  type: "local",
+  command: ["npx", "-y", "exa-mcp-server"]
+};
+
+// src/mcp/grep-app.ts
+var GREP_APP_MCP_URL = "https://mcp.grep.app";
+var grep_app = {
+  type: "remote",
+  url: GREP_APP_MCP_URL,
+  oauth: false
+};
+
+export {
+  SUBAGENT_NAMES,
+  ALL_AGENT_NAMES,
+  DEFAULT_MODELS,
+  POLL_INTERVAL_BACKGROUND_MS,
+  DEFAULT_THOTH_COMMAND,
+  getOpenCodeConfigPaths,
+  getExistingLiteConfigPath,
+  getExistingConfigPath,
+  ensureConfigDir,
+  ensureOpenCodeConfigDir,
+  generateLiteConfig,
+  stripJsonComments,
+  parseConfig,
+  writeConfig,
+  addPluginToOpenCodeConfig,
+  writeLiteConfig,
+  disableDefaultAgents,
+  detectCurrentConfig,
+  loadPluginConfig,
+  loadAgentPrompt,
+  getAgentOverride,
+  OPENCODE_PROMPT_DIALECT,
+  CODEX_PROMPT_DIALECT,
+  createStepBudgetSection,
+  createModelFamilySection,
+  createOrchestratorPromptSections,
+  createReadOnlySpecialistPromptSections,
+  createWriteCapableSpecialistPromptSections,
+  renderPromptSection,
+  renderRolePrompt,
+  appendPromptSections,
+  detectModelFamily,
+  getStepBudgetPromptSection,
+  getModelFamilyPromptSection,
+  composeAgentPrompt,
+  getSkillRegistry,
+  CUSTOM_SKILLS,
+  getCustomSkillsDir,
+  findPackageRoot,
+  installCustomSkills,
+  CONTEXT7_MCP_URL,
+  context7,
+  exa,
+  GREP_APP_MCP_URL,
+  grep_app
+};