thoth-agents 0.2.11 → 0.3.0

package/dist/chunk-OZE7JVGS.js

@@ -1,2344 +0,0 @@
-// 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 getOpenCodeManagedModelStatePath() {
-  return join(getConfigDir(), ".thoth-agents-managed-models.json");
-}
-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/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 CONFIRMED_OPENAI_SUBAGENT_PRESET = {
-  oracle: { model: "gpt-5.6-sol", effort: "high" },
-  librarian: { model: "gpt-5.6-luna", effort: "low" },
-  explorer: { model: "gpt-5.6-luna", effort: "low" },
-  designer: { model: "gpt-5.6-terra", effort: "high" },
-  quick: { model: "gpt-5.6-luna", effort: "medium" },
-  deep: { model: "gpt-5.6-terra", effort: "xhigh" }
-};
-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", "mcp"];
-
-// 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 ClaudeCodeGenerationConfigSchema = 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({
-  $schema: z.string().optional(),
-  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(),
-  claudeCode: ClaudeCodeGenerationConfigSchema.optional()
-});
-
-// 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 getPrimaryModelId(model) {
-  if (Array.isArray(model)) {
-    const first = model[0];
-    return typeof first === "string" ? first : first?.id;
-  }
-  return model;
-}
-
-// src/cli/providers.ts
-var THOTH_AGENTS_CONFIG_SCHEMA_URL = "https://unpkg.com/thoth-agents@latest/thoth-agents.schema.json";
-var MODEL_MAPPINGS = {
-  openai: {
-    orchestrator: { model: "openai/gpt-5.4" },
-    oracle: {
-      model: `openai/${CONFIRMED_OPENAI_SUBAGENT_PRESET.oracle.model}`,
-      variant: CONFIRMED_OPENAI_SUBAGENT_PRESET.oracle.effort
-    },
-    librarian: {
-      model: `openai/${CONFIRMED_OPENAI_SUBAGENT_PRESET.librarian.model}`,
-      variant: CONFIRMED_OPENAI_SUBAGENT_PRESET.librarian.effort
-    },
-    explorer: {
-      model: `openai/${CONFIRMED_OPENAI_SUBAGENT_PRESET.explorer.model}`,
-      variant: CONFIRMED_OPENAI_SUBAGENT_PRESET.explorer.effort
-    },
-    designer: {
-      model: `openai/${CONFIRMED_OPENAI_SUBAGENT_PRESET.designer.model}`,
-      variant: CONFIRMED_OPENAI_SUBAGENT_PRESET.designer.effort
-    },
-    quick: {
-      model: `openai/${CONFIRMED_OPENAI_SUBAGENT_PRESET.quick.model}`,
-      variant: CONFIRMED_OPENAI_SUBAGENT_PRESET.quick.effort
-    },
-    deep: {
-      model: `openai/${CONFIRMED_OPENAI_SUBAGENT_PRESET.deep.model}`,
-      variant: CONFIRMED_OPENAI_SUBAGENT_PRESET.deep.effort
-    }
-  },
-  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 = {
-    $schema: THOTH_AGENTS_CONFIG_SCHEMA_URL,
-    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);
-}
-function mergeOpenCodeMainConfig(config, update) {
-  if (update.ensurePlugin) {
-    const plugins = Array.isArray(config.plugin) ? config.plugin : [];
-    config.plugin = [
-      ...plugins.filter(
-        (plugin) => plugin !== PACKAGE_NAME && !plugin.startsWith(`${PACKAGE_NAME}@`)
-      ),
-      `${PACKAGE_NAME}@latest`
-    ];
-  }
-  if (update.disableDefaults) {
-    const agent = config.agent && typeof config.agent === "object" ? { ...config.agent } : {};
-    const explore = agent.explore && typeof agent.explore === "object" ? { ...agent.explore } : {};
-    const general = agent.general && typeof agent.general === "object" ? { ...agent.general } : {};
-    agent.explore = { ...explore, disable: true };
-    agent.general = { ...general, disable: true };
-    config.agent = agent;
-  }
-  return config;
-}
-function updateOpenCodeMainConfig(update) {
-  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}`
-      };
-    }
-    writeConfig(
-      configPath,
-      mergeOpenCodeMainConfig(parsedConfig ?? {}, update)
-    );
-    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 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/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/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: "supported",
-  parallelDelegation: "supported",
-  runtimeHooks: "unknown",
-  mcpConfiguration: "supported",
-  skillPackaging: "supported",
-  rolePermissions: "instruction-only",
-  parentContextInjection: "instruction-only",
-  memoryGovernanceEnforcement: "instruction-only"
-};
-var CLAUDE_CODE_PROMPT_CAPABILITIES = {
-  agentDefinitions: "supported",
-  delegatedExecution: "supported",
-  parallelDelegation: "supported",
-  runtimeHooks: "supported",
-  mcpConfiguration: "supported",
-  skillPackaging: "supported",
-  rolePermissions: "supported",
-  parentContextInjection: "supported",
-  memoryGovernanceEnforcement: "supported"
-};
-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",
-    lifecycle: {
-      statusAction: "wait, poll, and collect",
-      terminalState: "terminal task_status result",
-      nonterminalState: "nonterminal task_status result",
-      sameSessionProbe: "task_status on the same task session",
-      enforcement: "runtime-supported"
-    },
-    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: "collaboration.spawn_agent",
-    backgroundDelegationTool: "collaboration.spawn_agent",
-    backgroundStatusTool: "collaboration.wait_agent",
-    userQuestionTool: "request_user_input",
-    progressTool: "functions.update_plan",
-    hostStatusSurface: "collaboration.list_agents",
-    lifecycle: {
-      statusAction: "wait and inspect status",
-      terminalState: "terminal mailbox completion or failure update",
-      nonterminalState: "collaboration.wait_agent timeout or silence",
-      sameSessionProbe: "collaboration.list_agents on the same task path",
-      enforcement: "runtime-supported"
-    },
-    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 "collaboration.spawn_agent";
-      case "synchronous-task-only":
-        return "synchronous collaboration.spawn_agent only";
-    }
-  },
-  renderRoleInvocation(role) {
-    return role === "orchestrator" ? "orchestrator role agent" : `${role} subagent`;
-  }
-};
-var CLAUDE_CODE_SUBAGENT_NAMESPACE = "thoth-agents";
-function claudeCodeSubagentType(role) {
-  return `${CLAUDE_CODE_SUBAGENT_NAMESPACE}:${role}`;
-}
-var CLAUDE_CODE_PROMPT_DIALECT = {
-  harness: "claude",
-  tools: {
-    delegationTool: "Task",
-    backgroundDelegationTool: "Task(run_in_background=true)",
-    backgroundStatusTool: "TaskOutput",
-    userQuestionTool: "AskUserQuestion",
-    progressTool: "TodoWrite",
-    hostStatusSurface: "TodoWrite",
-    lifecycle: {
-      statusAction: "wait, poll, and collect",
-      terminalState: "terminal TaskOutput result",
-      nonterminalState: "nonterminal TaskOutput result",
-      sameSessionProbe: "TaskOutput on the same task session",
-      enforcement: "runtime-supported"
-    },
-    roleReference: (role) => role === "orchestrator" ? "the main-thread orchestrator" : `Task(subagent_type: ${claudeCodeSubagentType(role)})`
-  },
-  capabilities: supportedCapabilityProfile(CLAUDE_CODE_PROMPT_CAPABILITIES),
-  dispatchLabel(method) {
-    switch (method) {
-      case "root-coordinator":
-        return "main-session coordinator";
-      case "task":
-        return "Task tool";
-      case "synchronous-task-only":
-        return "synchronous Task only";
-    }
-  },
-  renderRoleInvocation(role) {
-    return role === "orchestrator" ? "main-thread orchestrator" : claudeCodeSubagentType(role);
-  }
-};
-
-// src/harness/core/sdd.ts
-var SDD_VERIFY_MAX_ROUNDS = 3;
-var SDD_PHASES = [
-  {
-    id: "requirements-interview",
-    order: 0,
-    requiredFor: ["direct", "accelerated", "full"],
-    prerequisites: [],
-    producesArtifact: false,
-    owner: "orchestrator",
-    delegationReason: "Root-owned requirements discovery, scope calibration, and route approval."
-  },
-  {
-    id: "init",
-    order: 1,
-    requiredFor: [],
-    prerequisites: ["requirements-interview"],
-    producesArtifact: true,
-    owner: "write-capable-agent",
-    artifactSkill: "sdd-init",
-    condition: "Only when OpenSpec persistence is selected and openspec/ is missing or stale (partial structure or missing mechanism sections).",
-    defaultAgentRole: "quick",
-    supportingAgentRoles: ["explorer"],
-    delegationReason: "Fast mechanical bootstrap, with explorer supplying repository facts when needed."
-  },
-  {
-    id: "explore",
-    order: 2,
-    requiredFor: ["accelerated", "full"],
-    prerequisites: ["requirements-interview"],
-    producesArtifact: false,
-    owner: "read-only-agent",
-    defaultAgentRole: "explorer",
-    supportingAgentRoles: ["librarian"],
-    delegationReason: "Read-only repository discovery before artifact-producing SDD phases."
-  },
-  {
-    id: "proposal",
-    order: 3,
-    requiredFor: ["accelerated", "full"],
-    prerequisites: ["requirements-interview", "explore"],
-    producesArtifact: true,
-    owner: "write-capable-agent",
-    artifactSkill: "sdd-propose",
-    defaultAgentRole: "deep",
-    supportingAgentRoles: ["oracle"],
-    delegationReason: "Structured technical reasoning and trade-off synthesis before implementation.",
-    handoffHints: [
-      "Preserve accepted scope and explicit non-goals downstream.",
-      "Carry deferred or discovery affected areas forward as follow-up."
-    ]
-  },
-  {
-    id: "spec",
-    order: 4,
-    requiredFor: ["full"],
-    prerequisites: ["proposal"],
-    producesArtifact: true,
-    owner: "write-capable-agent",
-    artifactSkill: "sdd-spec",
-    defaultAgentRole: "deep",
-    supportingAgentRoles: ["oracle"],
-    delegationReason: "High-quality requirement contract work where ambiguity propagates downstream.",
-    handoffHints: [
-      "Preserve recorded Assumptions and any [NEEDS CLARIFICATION] resolutions.",
-      "Keep the requirements-quality checklist resolved before tasks."
-    ]
-  },
-  {
-    id: "clarify",
-    order: 5,
-    requiredFor: ["full"],
-    prerequisites: ["spec"],
-    producesArtifact: false,
-    owner: "write-capable-agent",
-    artifactSkill: "sdd-clarify",
-    defaultAgentRole: "deep",
-    supportingAgentRoles: ["oracle"],
-    delegationReason: "Resolve residual spec ambiguity in place before design consumes it.",
-    handoffHints: [
-      "Preserve clarified resolutions written back into the spec.",
-      "Keep the requirements-quality checklist re-validated before design."
-    ]
-  },
-  {
-    id: "design",
-    order: 6,
-    requiredFor: ["full"],
-    prerequisites: ["proposal", "clarify"],
-    producesArtifact: true,
-    owner: "write-capable-agent",
-    artifactSkill: "sdd-design",
-    artifactMeaning: "technical-solution-design",
-    defaultAgentRole: "deep",
-    supportingAgentRoles: ["designer"],
-    delegationReason: "Technical architecture and file-change design; designer only supports UI/UX concerns.",
-    handoffHints: [
-      "Preserve coverage decisions and architecture constraints in tasks.",
-      "Honor the Constitution Check outcome recorded during design."
-    ]
-  },
-  {
-    id: "tasks",
-    order: 7,
-    requiredFor: ["accelerated", "full"],
-    prerequisites: ["proposal", "spec", "design"],
-    producesArtifact: true,
-    owner: "write-capable-agent",
-    artifactSkill: "sdd-tasks",
-    defaultAgentRole: "quick",
-    alternateAgentRoles: ["deep"],
-    alternateAgentCondition: "Only when the task plan is complex.",
-    delegationReason: "Mechanical conversion of settled design into dependency-ordered execution tasks."
-  },
-  {
-    id: "plan-review",
-    order: 8,
-    requiredFor: ["accelerated", "full"],
-    prerequisites: ["tasks"],
-    producesArtifact: true,
-    gate: "oracle-review",
-    owner: "oracle",
-    artifactSkill: "plan-reviewer",
-    artifactMeaning: "durable-plan-review-result",
-    defaultAgentRole: "oracle",
-    persistenceAgentRole: "quick",
-    delegationReason: "Independent read-only executability review of tasks before implementation; quick persists the durable review artifact when writes are required."
-  },
-  {
-    id: "implementation-confirmation",
-    order: 9,
-    requiredFor: ["accelerated", "full"],
-    prerequisites: ["plan-review"],
-    producesArtifact: false,
-    gate: "user-confirmation",
-    owner: "user",
-    delegationReason: "Human approval gate after reviewed tasks and before workspace implementation."
-  },
-  {
-    id: "apply",
-    order: 10,
-    requiredFor: ["direct", "accelerated", "full"],
-    prerequisites: ["implementation-confirmation"],
-    producesArtifact: false,
-    owner: "write-capable-agent",
-    defaultAgentRole: "deep",
-    alternateAgentRoles: ["quick", "designer"],
-    delegationReason: "Correctness-heavy implementation by default; quick handles mechanical batches and designer owns UI/visual work."
-  },
-  {
-    id: "verify",
-    order: 11,
-    requiredFor: ["accelerated", "full"],
-    prerequisites: ["apply"],
-    producesArtifact: true,
-    gate: "iterative-verify",
-    maxRounds: SDD_VERIFY_MAX_ROUNDS,
-    owner: "oracle",
-    artifactSkill: "sdd-verify",
-    defaultAgentRole: "oracle",
-    persistenceAgentRole: "quick",
-    delegationReason: "Independent verification review; quick persists the report when the selected store requires writes."
-  },
-  {
-    id: "archive",
-    order: 12,
-    requiredFor: ["accelerated", "full"],
-    prerequisites: ["verify"],
-    producesArtifact: true,
-    owner: "write-capable-agent",
-    artifactSkill: "sdd-archive",
-    defaultAgentRole: "quick",
-    delegationReason: "Mechanical closeout, summary, and archive movement after verification passes."
-  }
-];
-var SDD_WORKFLOW_CONTRACT = {
-  phases: [...SDD_PHASES],
-  routingRules: [
-    "Requirements interview is step zero for all non-trivial work.",
-    "Scope-faithful invariant: accepted user intent/scope is preserved; unresolved affected areas remain explicit as deferred/discovery follow-up.",
-    "Direct implementation is reserved for low-complexity work.",
-    "Accelerated SDD follows explore -> proposal -> tasks before execution.",
-    "Full SDD follows explore -> proposal -> spec -> clarify -> design -> tasks before execution."
-  ],
-  artifactRules: [
-    "SDD delegation defaults are phase-specific: sdd-propose, sdd-spec, and sdd-design default to deep.",
-    "sdd-tasks defaults to quick with deep as fallback when the task plan is complex.",
-    "plan-reviewer defaults to oracle for independent read-only review; quick persists the plan-review artifact when repository or memory writes are required.",
-    "sdd-verify defaults to oracle for independent review; quick persists the report when repository or memory writes are required.",
-    "sdd-archive defaults to quick for mechanical closeout.",
-    "OpenSpec design.md is technical solution design, not UI/UX design; sdd-design itself never routes to designer.",
-    "Designer participates during apply only for user-facing UI, visual work, screenshots, or visual QA.",
-    "Full-pipeline tasks require proposal, spec, and design artifacts.",
-    "Oracle is read-only and performs plan review plus independent verification review; it does not persist artifacts.",
-    "A fresh persisted plan-review approval satisfies only the plan-review gate; user implementation confirmation remains separate."
-  ],
-  verificationRules: [
-    "Plan review must complete before implementation confirmation.",
-    "User confirmation is required after plan-review approval and before apply.",
-    "Apply is followed by verify and archive for SDD pipelines.",
-    "Verify runs as a bounded iterative gate of at most SDD_VERIFY_MAX_ROUNDS rounds; on exhausted failure escalate to the user."
-  ]
-};
-function getSddWorkflowContract() {
-  return {
-    phases: SDD_WORKFLOW_CONTRACT.phases.map((phase) => ({
-      ...phase,
-      requiredFor: [...phase.requiredFor],
-      prerequisites: [...phase.prerequisites],
-      alternateAgentRoles: phase.alternateAgentRoles ? [...phase.alternateAgentRoles] : void 0,
-      supportingAgentRoles: phase.supportingAgentRoles ? [...phase.supportingAgentRoles] : void 0,
-      handoffHints: phase.handoffHints ? [...phase.handoffHints] : void 0
-    })),
-    routingRules: [...SDD_WORKFLOW_CONTRACT.routingRules],
-    artifactRules: [...SDD_WORKFLOW_CONTRACT.artifactRules],
-    verificationRules: [...SDD_WORKFLOW_CONTRACT.verificationRules]
-  };
-}
-
-// 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 createReasoningDisciplineSection() {
-  return { kind: "reasoning-discipline" };
-}
-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 = getPrimaryModelId2(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 roleTemplate(role) {
-  return `{{role.${role}}}`;
-}
-function renderRoleList(roles) {
-  return roles.map(roleTemplate).join(", ");
-}
-function getDelegatedSddPhase(id) {
-  const phase = getSddWorkflowContract().phases.find(
-    (candidate) => candidate.id === id
-  );
-  if (!phase?.defaultAgentRole) {
-    throw new Error(`Missing SDD delegation role for ${id}`);
-  }
-  return phase;
-}
-function primarySddRole(id) {
-  return roleTemplate(getDelegatedSddPhase(id).defaultAgentRole);
-}
-function alternateSddRoles(id) {
-  const phase = getDelegatedSddPhase(id);
-  return phase.alternateAgentRoles?.length ? renderRoleList(phase.alternateAgentRoles) : "";
-}
-function alternateSddCondition(id) {
-  const condition = getDelegatedSddPhase(id).alternateAgentCondition;
-  return condition ? condition.replace(/^Only/, "only").replace(/\.$/, "") : "";
-}
-function supportSddRoles(id) {
-  const phase = getDelegatedSddPhase(id);
-  return phase.supportingAgentRoles?.length ? renderRoleList(phase.supportingAgentRoles) : "";
-}
-function persistenceSddRole(id) {
-  const phase = getDelegatedSddPhase(id);
-  return phase.persistenceAgentRole ? roleTemplate(phase.persistenceAgentRole) : "";
-}
-function renderSddDelegationMatrix() {
-  return `<sdd-delegation-matrix>
-- sdd-init -> ${primarySddRole("init")} (+${supportSddRoles("init")}, if openspec/ missing); sdd-explore -> ${primarySddRole("explore")} (+${supportSddRoles("explore")})
-- sdd-propose/sdd-spec/sdd-design -> ${primarySddRole("proposal")}; sdd-clarify -> ${primarySddRole("clarify")}; sdd-tasks -> ${primarySddRole("tasks")} (fallback: ${alternateSddRoles("tasks")} ${alternateSddCondition("tasks")})
-- plan-reviewer -> ${primarySddRole("plan-review")}; sdd-apply -> ${primarySddRole("apply")} (fallback: ${alternateSddRoles("apply")}); sdd-verify -> ${primarySddRole("verify")} (persistence: ${persistenceSddRole("verify")}); sdd-archive -> ${primarySddRole("archive")}
-</sdd-delegation-matrix>`;
-}
-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>
-
-`),
-    createReasoningDisciplineSection(),
-    roleText(`
-<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>`),
-    roleText(`
-
-<core-rules>
-- Mode: primary coordinator. Mutation: coordination artifacts only.
-- Load \`thoth-mem-agents\` and \`requirements-interview\`.
-- Mutation remains limited to coordination artifacts such as \`openspec/\` during the SDD pipeline; implementation edits belong to write-capable sub-agents.
-- You may perform small bounded local inspection when cheaper, faster, or clearer than delegation: read a known file, confirm a script name, inspect a narrow artifact, or verify one concrete claim.
-- Keep any direct check narrow and evidence-led; do not become the default discovery, implementation, or verification worker.
-- 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}}.
-- Delegate broad search, multi-file edits, risky verification, UI visual QA, independent review, correctness-heavy debugging, and implementation-heavy work.
-- 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>
-
-<epistemic-rigor>
-- Verify material user/agent claims before relying on them in implementation, architecture, verification, safety, or guidance.
-- Before solving/editing, post one short commentary update naming reasoning/root-cause check.
-- Do thought experiments: test competing explanations, edge cases, failure modes, root-cause fit.
-- Do not stop at first plausible explanation/superficial answer; validate with evidence, edge cases, tests, or fitting check.
-- If evidence disproves an assumption, correct it plainly, explain tradeoffs, and offer alternatives.
-</epistemic-rigor>
-
-<session-bootstrap>
-- At the start of a new root session, when thoth-mem tools and session/project identity are available, load \`thoth-mem-agents\` and \`requirements-interview\`, then call \`mem_session(action="start")\` as step 0 before any other thoth-mem call.
-- Save only the real user request with \`mem_save(kind="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 claiming 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>
-
-<delegation-economics>
-- Choose direct action, delegation, parallelization, or review by net quality, speed, cost, and reliability.
-- Do not delegate when overhead exceeds a bounded direct check; delegate when breadth, risk, specialization, or independent review materially improves the result.
-- Parallelize only independent delegations; reconcile dependent steps after evidence returns.
-- Keep validation and final synthesis accountable to the root even when sub-agents gather evidence, implement, review, or verify.
-</delegation-economics>
-
-<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 body for root-owned session context; it is not user-facing and must not be embedded in the initial sub-agent prompt.
-
-Internal handoff fields: Goal, Decision, Evidence, Scope, Steps, Verification, Uncertainty, relevant files or symbols, suggested skills when applicable, constraints, non-goals, escalation conditions, and next focus.
-
-When thoth-mem summary persistence and parent session/project identity are available, save or refresh that handoff body with root-owned \`mem_session(action="summary")\` or \`mem_save(kind="session_summary")\` before dispatch. If tooling or identity is unavailable, disclose that root-owned compaction could not be persisted and continue with explicit task instructions and local context; do not invent a fallback session or ask a sub-agent to create one.
-
-The delegated prompt carries task instructions plus handoff recovery instructions only: parent \`session_id\`, project, persistence mode, memory permissions, the recall funnel \`mem_recall(mode="compact")\` -> \`mem_recall(mode="context")\` -> \`mem_get(...)\`, optional bounded \`mem_context(recall_query=...)\`/\`mem_project(...)\` guidance when permitted, non-goals, escalation conditions, and redaction requirements. It must not include the handoff body, raw transcripts, file dumps, secrets, credentials, irrelevant context, or generated sub-agent prompts as memory source material.
-
-Never mention internal handoff preparation to the user, ask the user to prepare it, or present handoff preparation as the recommended next step. Describe the actual work instead.
-
-For {{role.explorer}}/{{role.librarian}}, ask narrow fact-finding questions for files, symbols, constraints, examples, 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 {{lifecycleStatusAction}}: treat \`{{lifecycleNonterminalState}}\` as in progress and probe the same session via \`{{lifecycleSameSessionProbe}}\`; no retry/reroute/interruption before \`{{lifecycleTerminalState}}\`, an explicit user deadline, user cancellation, or a superseding request.
-- Terminal result-quality and required-artifact checks share one sharpened retry; nonterminal probes use none.
-- Capacity is separate: retry the named role up to 3 times; never switch to \`default\`, \`worker\`, or another role; then use a same-role model override or report a blocker.
-- Write-capable dispatches must include task instructions and handoff retrieval instructions when a root-owned handoff summary exists, so implementers can recover context without rediscovering settled scope.
-- Never tell sub-agents to discard working-tree changes.
-</dispatch>
-
-<sdd>
-All work always starts with requirements-interview skill.
-Scope-faithful invariant: accepted user intent and scope must not be silently narrowed; unresolved affected areas stay visible as deferred/discovery follow-up, not hidden as out-of-scope.
-
-Routes:
-- Direct implementation for low-complexity work.
-- Accelerated SDD: explore -> propose -> tasks.
-- Full SDD: explore -> propose -> spec -> clarify -> design -> tasks.
-
-${renderSddDelegationMatrix()}
-
-Hard gates:
-- Use the SDD delegation matrix as canonical phase routing.
-- Load the matching skill when a phase has one.
-- {{role.oracle}} is read-only for plan-reviewer and sdd-verify review; {{role.quick}} persists plan-review and verify artifacts when writes are required.
-- 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 or stale (partial structure or missing mechanism sections), 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.
-
-Artifact governance handoff:
-- After \`sdd-tasks\`, you may surface report-only artifact governance findings before execution preparation starts.
-- Delegate governance inspection; do not treat findings as an execution gate or replacement for \`plan-reviewer\`/\`executing-plans\`.
-- Root thoth-mem ownership stays with you; sub-agents 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".
-Plan review is complete only after fresh [OKAY] evidence in \`plan-review.md\` or \`sdd/{change-name}/plan-review\`; missing, stale, rejected, or unparsable evidence reruns oracle unless a user override is logged.
-Fresh [OKAY] satisfies only plan-review. If {{role.oracle}} returns [OKAY], or recovery accepts it, give an approved-plan overview, then ask with \`{{userQuestionTool}}\` whether to implement or stop. Cover scope, sequence, decisions, verification, risks, and uncertainty.
-Do not dispatch \`sdd-apply\` until user confirmation; never treat plan-review recovery as implementation confirmation.
-Post-execution verify-loop (mirrors the plan-review loop's discipline; bounded to 3 rounds = initial apply->verify plus up to 2 fix->re-verify):
-- Dispatch \`sdd-verify\` as an iterative gate, not a single shot; round 1 is the first verify after apply. Treat the \`round N\` marker in the verify report as the source of truth for the round counter and surface it in {{progressTool}}.
-- On clean \`pass\`: proceed through the existing pre-archive user gate above, then delegate \`sdd-archive\`. Do not auto-advance to archive merely because a verify report exists.
-- On \`fail\` with rounds remaining (round < 3): dispatch a TARGETED \`sdd-apply\` re-run scoped by the verify report's Critical Issue remediation anchors (file and/or scenario), then re-dispatch \`sdd-verify\` as round N+1. Do not expand a scoped fix into a full unscoped re-apply when anchors are present, and do not advance to archive while the verdict is \`fail\`.
-- On \`fail\` at the bound (round 3 still failing): escalate the unresolved failure to the user with \`{{userQuestionTool}}\`. Do not run another apply/verify round and do not silently abandon or auto-archive. If the harness lacks a blocking user-input primitive, report this as an unsupported-capability limitation instead of auto-advancing or looping.
-- On \`pass with warnings\`: escalate with \`{{userQuestionTool}}\` an advance-vs-iterate choice (advance to \`sdd-archive\` vs re-iterate to clear warnings). Never auto-advance and never auto-loop. If the user chooses re-iterate, dispatch a targeted \`sdd-apply\` scoped by the warning remediation anchors and re-verify, subject to the 3-round bound.
-</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: recall repeated work; save durable decisions, discoveries, bugs, patterns, constraints, summaries.
-- Use \`mem_save(kind="observation")\` for decisions, bugs, discoveries, conventions, preferences; stable topics; observations outside \`sdd/*\`.
-- Targeted recall funnel: \`mem_recall(mode="compact")\` -> \`mem_recall(mode="context")\` -> \`mem_get(...)\`; use \`mem_get(include_timeline=true)\` for time context.
-- Use HyDE/fused recall; set \`mem_recall\` \`limit\` from 1 to 20; narrow with \`topic_key\`, \`type\`, \`time_from\`/\`time_to\`, \`scope\`, \`project\`, \`session_id\`.
-- \`mem_get\`: \`kind="observation"|"prompt"\`, \`include_timeline=true\`, \`before\`/\`after\`, \`offset\`/\`max_length\`; supplement with bounded \`mem_context(recall_query=...)\` or \`mem_project(action="graph"|"topics"|"topic")\`.
-- Graph relations: HAS_TYPE, IN_PROJECT, HAS_TOPIC_KEY, HAS_WHAT, HAS_WHY, HAS_WHERE, HAS_LEARNED.
-- 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(action="summary")\` or root-owned \`mem_save(kind="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(action="summary")\`, then call \`mem_context(recall_query=...)\` and use the recall funnel 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 getPrimaryModelId2(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 parent session_id/project and handoff recovery instructions.",
-      "- Parent-scoped reads: `mem_recall`, `mem_context`, `mem_get`, bounded `mem_project`; do not call `mem_save` or own any `mem_session(...)` lifecycle action.",
-      "- If either parent session_id or project is missing, do NOT call thoth-mem; rely on task instructions and local evidence.",
-      '- Recover the parent-session handoff summary through the recall funnel `mem_recall(mode="compact")` -> `mem_recall(mode="context")` -> `mem_get(...)` before using memory.',
-      '- Use `mem_recall` `limit` from 1 to 20; use `mem_get` with `kind="observation"|"prompt"`, `include_timeline=true`, `before`/`after`, and `offset`/`max_length`.',
-      "- Report when recalled context is missing, stale, contradictory, or insufficient.",
-      '- Supplemental `mem_context(recall_query=...)` and bounded `mem_project(action="graph"|"topics"|"topic")` do not replace the recall funnel and require explicit delegated permission. Graph relations: `HAS_TYPE`, `IN_PROJECT`, `HAS_TOPIC_KEY`, `HAS_WHAT`, `HAS_WHY`, `HAS_WHERE`, `HAS_LEARNED`.',
-      "- Never save prompts, generated subagent prompts, session summaries, or durable memory."
-    );
-  }
-  if (section.memoryAccess === "writable") {
-    rules.push(
-      "- Use delegated thoth-mem tools only: `mem_save`, `mem_recall`, `mem_context`, `mem_get`, `mem_project`, `mem_session`.",
-      "- Always use the parent session_id/project from dispatch for every thoth-mem call.",
-      "- If either is missing, do NOT call thoth-mem.",
-      "- Follow handoff recovery instructions from the delegated task before using persisted memory.",
-      '- For reads, use the recall funnel `mem_recall(mode="compact")` -> `mem_recall(mode="context")` -> `mem_get(...)` and recover the parent-session handoff summary before treating memory as source material.',
-      '- Use `mem_recall` `limit` from 1 to 20; use `mem_get` with `kind="observation"|"prompt"`, `include_timeline=true`, `before`/`after`, and `offset`/`max_length`.',
-      '- Keep the recall funnel canonical; use `mem_context(recall_query=...)` and bounded `mem_project(action="graph"|"topics"|"topic")` only with explicit project-read permission. Graph relations: `HAS_TYPE`, `IN_PROJECT`, `HAS_TOPIC_KEY`, `HAS_WHAT`, `HAS_WHY`, `HAS_WHERE`, `HAS_LEARNED`.',
-      "- Report when recalled context is missing, stale, contradictory, or insufficient.",
-      '- `mem_save(kind="observation")` is allowed only for delegated durable implementation observations or assigned deterministic SDD artifacts/apply-progress under the parent session/project.',
-      '- Never own `mem_session(action="start"|"checkpoint"|"summary")`, save prompts, or save generated subagent prompts as user intent.',
-      "- Protect the `sdd/*` namespace: deterministic SDD artifacts use `sdd/{change}/{artifact}`; general durable observations must stay outside `sdd/*`.",
-      '- You do not own durable memory of your own; permitted `mem_save(kind="observation")` writes under the orchestrator\'s session/project only.'
-    );
-  }
-  return rules.join("\n");
-}
-function renderReasoningDiscipline() {
-  return `<reasoning-discipline>
-- Before solving/editing, post one short commentary update naming reasoning/root-cause check.
-- Do thought experiments: test competing explanations, edge cases, failure modes, root-cause fit.
-- Do not stop at first plausible explanation/superficial answer; validate with evidence, edge cases, tests, or fitting check.
-</reasoning-discipline>`;
-}
-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(
-    "{{lifecycleStatusAction}}",
-    dialect.tools.lifecycle.statusAction
-  ).replaceAll(
-    "{{lifecycleTerminalState}}",
-    dialect.tools.lifecycle.terminalState
-  ).replaceAll(
-    "{{lifecycleNonterminalState}}",
-    dialect.tools.lifecycle.nonterminalState
-  ).replaceAll(
-    "{{lifecycleSameSessionProbe}}",
-    dialect.tools.lifecycle.sameSessionProbe
-  ).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 "reasoning-discipline":
-      return renderReasoningDiscipline();
-    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-clarify",
-    description: "Resolve residual spec ambiguity in place before design, with a bounded taxonomy-driven clarification pass.",
-    allowedRoles: ORCHESTRATOR_ONLY,
-    sourcePath: "src/skills/sdd-clarify",
-    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"
-  },
-  {
-    name: "sdd-constitution",
-    description: "Guide a semver constitution amendment and Sync-Impact Report entry.",
-    allowedRoles: ORCHESTRATOR_ONLY,
-    sourcePath: "src/skills/sdd-constitution",
-    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 checkCustomSkillsNeedUpdate(packageRoot) {
-  return checkSkillsNeedUpdate(resolvePackageRoot(packageRoot));
-}
-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,
-  CONFIRMED_OPENAI_SUBAGENT_PRESET,
-  POLL_INTERVAL_BACKGROUND_MS,
-  DEFAULT_THOTH_COMMAND,
-  getOpenCodeConfigPaths,
-  getOpenCodeManagedModelStatePath,
-  getExistingLiteConfigPath,
-  getExistingConfigPath,
-  ensureConfigDir,
-  generateLiteConfig,
-  stripJsonComments,
-  parseConfig,
-  writeConfig,
-  updateOpenCodeMainConfig,
-  writeLiteConfig,
-  detectCurrentConfig,
-  loadPluginConfig,
-  loadAgentPrompt,
-  getAgentOverride,
-  getPrimaryModelId,
-  OPENCODE_PROMPT_DIALECT,
-  CODEX_PROMPT_DIALECT,
-  CLAUDE_CODE_SUBAGENT_NAMESPACE,
-  claudeCodeSubagentType,
-  CLAUDE_CODE_PROMPT_DIALECT,
-  createStepBudgetSection,
-  createModelFamilySection,
-  createOrchestratorPromptSections,
-  createReadOnlySpecialistPromptSections,
-  createWriteCapableSpecialistPromptSections,
-  renderPromptSection,
-  renderRolePrompt,
-  appendPromptSections,
-  detectModelFamily,
-  getStepBudgetPromptSection,
-  getModelFamilyPromptSection,
-  composeAgentPrompt,
-  getSkillRegistry,
-  CUSTOM_SKILLS,
-  getCustomSkillsDir,
-  findPackageRoot,
-  checkCustomSkillsNeedUpdate,
-  installCustomSkills,
-  CONTEXT7_MCP_URL,
-  context7,
-  exa,
-  GREP_APP_MCP_URL,
-  grep_app
-};