thoth-agents 0.2.11 → 0.3.1

package/dist/chunk-XO74DXBZ.js

@@ -0,0 +1,1781 @@
+// 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 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 CONFIRMED_OPENAI_SUBAGENT_PRESET = {
+  explorer: { model: "gpt-5.6-luna", effort: "low" },
+  librarian: { model: "gpt-5.6-luna", effort: "xhigh" },
+  oracle: { model: "gpt-5.6-sol", effort: "xhigh" },
+  designer: { model: "gpt-5.6-sol", effort: "medium" },
+  quick: { model: "gpt-5.6-luna", effort: "xhigh" },
+  deep: { model: "gpt-5.6-sol", effort: "medium" }
+};
+var OPENCODE_OPENAI_ORCHESTRATOR_PRESET = {
+  model: "gpt-5.6-sol",
+  effort: "xhigh"
+};
+function buildDefaultModels() {
+  const defaults = {
+    orchestrator: void 0,
+    explorer: void 0,
+    librarian: void 0,
+    oracle: void 0,
+    designer: void 0,
+    quick: void 0,
+    deep: void 0
+  };
+  for (const [name, { model }] of Object.entries(
+    CONFIRMED_OPENAI_SUBAGENT_PRESET
+  )) {
+    defaults[name] = `openai/${model}`;
+  }
+  return defaults;
+}
+var DEFAULT_MODELS = buildDefaultModels();
+function getDefaultOpenCodeModel(name) {
+  const subagentModel = DEFAULT_MODELS[name];
+  if (subagentModel !== void 0) {
+    return subagentModel;
+  }
+  return `openai/${OPENCODE_OPENAI_ORCHESTRATOR_PRESET.model}`;
+}
+function getDefaultOpenCodeVariant(name) {
+  if (name === ORCHESTRATOR_NAME) {
+    return OPENCODE_OPENAI_ORCHESTRATOR_PRESET.effort;
+  }
+  return CONFIRMED_OPENAI_SUBAGENT_PRESET[name].effort;
+}
+var POLL_INTERVAL_BACKGROUND_MS = 2e3;
+var DEFAULT_TIMEOUT_MS = 2 * 60 * 1e3;
+var MAX_POLL_TIME_MS = 5 * 60 * 1e3;
+
+// 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"]);
+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(),
+  codex: CodexGenerationConfigSchema.optional(),
+  claudeCode: ClaudeCodeGenerationConfigSchema.optional()
+});
+
+// src/config/utils.ts
+function getAgentOverride(config, name) {
+  return config?.agents?.[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";
+function buildOpenAIModelMappings() {
+  const mappings = {
+    orchestrator: {
+      model: getDefaultOpenCodeModel("orchestrator"),
+      variant: getDefaultOpenCodeVariant("orchestrator")
+    }
+  };
+  for (const [name, preset] of Object.entries(
+    CONFIRMED_OPENAI_SUBAGENT_PRESET
+  )) {
+    mappings[name] = {
+      model: `openai/${preset.model}`,
+      variant: preset.effort
+    };
+  }
+  return mappings;
+}
+var MODEL_MAPPINGS = {
+  openai: buildOpenAIModelMappings()
+};
+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,
+    hasOpenAI: false,
+    hasTmux: false
+  };
+  const { config } = parseConfig(getExistingConfigPath());
+  if (!config) return result;
+  const plugins = config.plugin ?? [];
+  result.isInstalled = plugins.some((p) => p.startsWith(PACKAGE_NAME));
+  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/"));
+    }
+    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),
+      codex: deepMerge(config.codex, projectConfig.codex),
+      claudeCode: deepMerge(config.claudeCode, projectConfig.claudeCode)
+    };
+  }
+  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: "instruction-only"
+};
+function supportedCapabilityProfile(capabilities) {
+  return {
+    capabilities,
+    renderCapabilityDisclosure: () => void 0
+  };
+}
+function codexCapabilityDisclosure(capability) {
+  const status = CODEX_PROMPT_CAPABILITIES[capability];
+  if (status === "supported") {
+    return void 0;
+  }
+  if (status === "unknown") {
+    return `${capability}: unknown in Codex; treat related behavior as diagnostic-only unless the active Codex host documents support.`;
+  }
+  return `${capability}: ${status} in Codex; preserve the role responsibility as prompt guidance because equivalent runtime enforcement is not guaranteed.`;
+}
+function claudeCodeCapabilityDisclosure(capability) {
+  const status = CLAUDE_CODE_PROMPT_CAPABILITIES[capability];
+  if (status === "supported") {
+    return void 0;
+  }
+  return `${capability}: ${status} in Claude Code; installed provider guidance owns provider-dependent enforcement and mechanics.`;
+}
+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: "Agent",
+    backgroundDelegationTool: "Agent(run_in_background=true)",
+    backgroundStatusTool: "TaskOutput",
+    userQuestionTool: "AskUserQuestion",
+    progressTool: "TodoWrite",
+    hostStatusSurface: "TodoWrite",
+    lifecycle: {
+      statusAction: "wait, inspect, 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" : `Agent(subagent_type: ${claudeCodeSubagentType(role)})`
+  },
+  capabilities: {
+    capabilities: CLAUDE_CODE_PROMPT_CAPABILITIES,
+    renderCapabilityDisclosure: claudeCodeCapabilityDisclosure
+  },
+  dispatchLabel(method) {
+    switch (method) {
+      case "root-coordinator":
+        return "main-session coordinator";
+      case "task":
+        return "Agent tool";
+      case "synchronous-task-only":
+        return "synchronous Agent only";
+    }
+  },
+  renderRoleInvocation(role) {
+    return role === "orchestrator" ? "main-thread orchestrator" : claudeCodeSubagentType(role);
+  }
+};
+
+// src/harness/core/agent-pack.ts
+var AGENT_ROLES = [
+  {
+    name: "orchestrator",
+    mode: "adaptive-root",
+    dispatch: "root-coordinator",
+    canMutateWorkspace: true,
+    scope: "requirements, SDD coordination, routing, bounded direct work, decisions, and synthesis",
+    responsibility: "Keep the task coherent, own sequential specification, planning, task, convergence, and archive coordination, act directly when work is clear and bounded, and delegate only for net gain.",
+    toolGovernance: [
+      "may inspect and edit bounded direct work, but every verification is delegated to oracle",
+      "loads the matching thoth-sdd phase contract on demand instead of carrying every phase protocol in its prompt",
+      "owns governed coordination writes under openspec/ and uses append-only tasks.md updates during convergence",
+      "delegates independent or specialist work only when it produces a net gain",
+      "keeps requirements, decisions, and final synthesis in the root thread"
+    ],
+    verification: [
+      "delegates analyze and every verify phase to oracle, including Direct and Accelerated routes",
+      "consolidates summarized evidence returned by child agents"
+    ]
+  },
+  {
+    name: "explorer",
+    mode: "read-only",
+    dispatch: "task",
+    canMutateWorkspace: false,
+    scope: "local repository discovery",
+    responsibility: "Resolve broad or uncertain repository questions and return distilled evidence.",
+    toolGovernance: [
+      "uses read, search, and code-navigation tools only",
+      "does not mutate files or delegate further"
+    ],
+    verification: ["reports inspected paths, confidence, and remaining gaps"]
+  },
+  {
+    name: "librarian",
+    mode: "read-only",
+    dispatch: "task",
+    canMutateWorkspace: false,
+    scope: "authoritative external research with local confirmation when needed",
+    responsibility: "Gather current authoritative evidence and separate documented facts from inference.",
+    toolGovernance: [
+      "uses research and read-only local tools",
+      "does not mutate files or delegate further"
+    ],
+    verification: ["provides direct sources for substantive external claims"]
+  },
+  {
+    name: "oracle",
+    mode: "read-only",
+    dispatch: "synchronous-task-only",
+    canMutateWorkspace: false,
+    scope: "diagnosis, architecture, analysis, and independent verification",
+    responsibility: "Independently analyze plans and perform every implementation verification, exposing correctness risks and judging whether results satisfy their contracts.",
+    toolGovernance: [
+      "performs read-only analysis and independent review and is never the implementer of the work it judges",
+      "does not implement, persist artifacts, or delegate further"
+    ],
+    verification: ["separates observations, risks, and recommendations"]
+  },
+  {
+    name: "designer",
+    mode: "write-capable",
+    dispatch: "synchronous-task-only",
+    canMutateWorkspace: true,
+    scope: "UI/UX decisions, implementation, and visual verification",
+    responsibility: "Own user-facing implementation choices and visual quality for UI work.",
+    toolGovernance: [
+      "may edit focused UI/UX files",
+      "owns screenshots and visual QA",
+      "does not delegate further"
+    ],
+    verification: ["includes visual verification when applicable"]
+  },
+  {
+    name: "quick",
+    mode: "write-capable",
+    dispatch: "synchronous-task-only",
+    canMutateWorkspace: true,
+    scope: "fast bounded implementation",
+    responsibility: "Implement narrow, clear, low-risk changes within an explicitly bounded surface.",
+    toolGovernance: [
+      "edits only bounded targets",
+      "escalates when discovery or correctness risk exceeds the assignment",
+      "does not delegate further"
+    ],
+    verification: ["runs the smallest sufficient focused check"]
+  },
+  {
+    name: "deep",
+    mode: "write-capable",
+    dispatch: "synchronous-task-only",
+    canMutateWorkspace: true,
+    scope: "correctness-critical implementation and verification",
+    responsibility: "Handle multi-file, edge-case-heavy, or high-risk implementation with full local context.",
+    toolGovernance: [
+      "may edit implementation and tests within the assigned surface",
+      "validates shared behavior against related code and call sites",
+      "does not delegate further"
+    ],
+    verification: ["reports focused checks and relevant edge-case evidence"]
+  }
+];
+var ORCHESTRATION_POLICY = {
+  maxDelegationDepth: 1,
+  singleWriter: true,
+  rules: [
+    "The root performs bounded direct work when scope and intent are clear.",
+    "Delegate only when specialization, context isolation, or independent parallel work creates a net gain.",
+    "Prefer child agents for read-heavy exploration, research, analysis, and verification.",
+    "Use one writer for each mutable surface and never parallelize overlapping writes.",
+    "Child agents return distilled evidence instead of raw logs or file dumps."
+  ]
+};
+var AGENT_RETURN_CONTRACT = [
+  "conclusion",
+  "evidence",
+  "verification",
+  "risks",
+  "openQuestions",
+  "nextAction"
+];
+var VERIFICATION_PROTOCOL = [
+  "Completion reports identify changed files and verification evidence.",
+  "Behavior changes receive the smallest sufficient automated check or a declared manual check.",
+  "Visual changes receive designer-owned visual QA when applicable."
+];
+var AGENT_PACK_CONTRACT = {
+  roles: [...AGENT_ROLES],
+  orchestrationPolicy: {
+    ...ORCHESTRATION_POLICY,
+    rules: [...ORCHESTRATION_POLICY.rules]
+  },
+  returnContract: [...AGENT_RETURN_CONTRACT],
+  verificationProtocol: [...VERIFICATION_PROTOCOL]
+};
+function getAgentRole(name) {
+  const role = AGENT_ROLES.find((candidate) => candidate.name === name);
+  if (!role) {
+    throw new Error(`Unknown agent role: ${name}`);
+  }
+  return role;
+}
+function getAgentPackContract() {
+  return {
+    roles: AGENT_PACK_CONTRACT.roles.map((role) => ({
+      ...role,
+      writeScope: role.writeScope ? [...role.writeScope] : void 0,
+      toolGovernance: [...role.toolGovernance],
+      verification: [...role.verification]
+    })),
+    orchestrationPolicy: {
+      ...AGENT_PACK_CONTRACT.orchestrationPolicy,
+      rules: [...AGENT_PACK_CONTRACT.orchestrationPolicy.rules]
+    },
+    returnContract: [...AGENT_PACK_CONTRACT.returnContract],
+    verificationProtocol: [...AGENT_PACK_CONTRACT.verificationProtocol]
+  };
+}
+
+// src/harness/core/sdd.ts
+var SDD_PHASES = [
+  {
+    id: "explore",
+    order: 0,
+    availableFor: ["full"],
+    requiredFor: ["full"],
+    activation: "required",
+    prerequisites: [],
+    producesArtifact: false,
+    defaultAgentRole: "explorer",
+    eligibleAgentRoles: ["explorer"],
+    reason: "Resolve broad repository uncertainty before requirements are fixed."
+  },
+  {
+    id: "specify",
+    order: 1,
+    availableFor: ["accelerated", "full"],
+    requiredFor: ["accelerated", "full"],
+    activation: "required",
+    prerequisites: ["explore"],
+    producesArtifact: true,
+    defaultAgentRole: "orchestrator",
+    eligibleAgentRoles: ["orchestrator"],
+    reason: "Define the user-visible requirements and acceptance contract."
+  },
+  {
+    id: "clarify",
+    order: 2,
+    availableFor: ["accelerated", "full"],
+    requiredFor: [],
+    activation: "conditional",
+    prerequisites: ["specify"],
+    producesArtifact: false,
+    defaultAgentRole: "orchestrator",
+    eligibleAgentRoles: ["orchestrator"],
+    reason: "Resolve only material ambiguity that would change the solution.",
+    condition: "Activate when unresolved decisions cannot be handled by a safe local assumption."
+  },
+  {
+    id: "plan",
+    order: 3,
+    availableFor: ["accelerated", "full"],
+    requiredFor: ["accelerated", "full"],
+    activation: "required",
+    prerequisites: ["specify"],
+    producesArtifact: true,
+    defaultAgentRole: "orchestrator",
+    eligibleAgentRoles: ["orchestrator"],
+    reason: "Translate requirements into an executable technical approach."
+  },
+  {
+    id: "checklist",
+    order: 4,
+    availableFor: ["accelerated", "full"],
+    requiredFor: [],
+    activation: "conditional",
+    prerequisites: ["specify", "plan"],
+    producesArtifact: true,
+    defaultAgentRole: "orchestrator",
+    eligibleAgentRoles: ["orchestrator"],
+    reason: "Audit requirement quality when risk justifies an explicit checklist.",
+    condition: "Activate for high-risk, compliance-sensitive, or ambiguity-prone requirements."
+  },
+  {
+    id: "tasks",
+    order: 5,
+    availableFor: ["accelerated", "full"],
+    requiredFor: ["accelerated", "full"],
+    activation: "required",
+    prerequisites: ["specify", "plan"],
+    producesArtifact: true,
+    defaultAgentRole: "orchestrator",
+    eligibleAgentRoles: ["orchestrator"],
+    reason: "Produce dependency-ordered implementation slices with verification."
+  },
+  {
+    id: "analyze",
+    order: 6,
+    availableFor: ["full"],
+    requiredFor: ["full"],
+    activation: "required",
+    prerequisites: ["specify", "plan", "tasks"],
+    producesArtifact: false,
+    defaultAgentRole: "oracle",
+    eligibleAgentRoles: ["oracle"],
+    reason: "Independently check cross-artifact consistency before high-risk implementation."
+  },
+  {
+    id: "implement",
+    order: 7,
+    availableFor: ["direct", "accelerated", "full"],
+    requiredFor: ["direct", "accelerated", "full"],
+    activation: "required",
+    prerequisites: ["tasks", "analyze"],
+    producesArtifact: false,
+    defaultAgentRole: "orchestrator",
+    eligibleAgentRoles: ["orchestrator", "designer", "quick", "deep"],
+    reason: "Let the adaptive root act directly or route the settled work to one writer."
+  },
+  {
+    id: "verify",
+    order: 8,
+    availableFor: ["direct", "accelerated", "full"],
+    requiredFor: ["direct", "accelerated", "full"],
+    activation: "required",
+    prerequisites: ["implement"],
+    producesArtifact: true,
+    defaultAgentRole: "oracle",
+    eligibleAgentRoles: ["oracle"],
+    reason: "Independently judge the result against requirements, contracts, and focused checks."
+  },
+  {
+    id: "converge",
+    order: 9,
+    availableFor: ["accelerated", "full"],
+    requiredFor: [],
+    activation: "conditional",
+    prerequisites: ["verify"],
+    producesArtifact: true,
+    defaultAgentRole: "orchestrator",
+    eligibleAgentRoles: ["orchestrator"],
+    reason: "Append traceable remaining work to tasks.md before another implementation loop.",
+    condition: "Activate only when verification finds actionable defects."
+  },
+  {
+    id: "archive",
+    order: 10,
+    availableFor: ["accelerated", "full"],
+    requiredFor: ["accelerated", "full"],
+    activation: "required",
+    prerequisites: ["verify"],
+    producesArtifact: true,
+    defaultAgentRole: "orchestrator",
+    eligibleAgentRoles: ["orchestrator"],
+    reason: "Transactionally sync declared durable deltas and close verified work with a dated audit trail."
+  }
+];
+var SDD_ARTIFACT_GRAPH = [
+  {
+    id: "spec",
+    path: "spec.md",
+    producedBy: "specify",
+    consumes: [],
+    requiredFor: ["accelerated", "full"]
+  },
+  {
+    id: "plan",
+    path: "plan.md",
+    producedBy: "plan",
+    consumes: ["spec"],
+    requiredFor: ["accelerated", "full"]
+  },
+  {
+    id: "tasks",
+    path: "tasks.md",
+    producedBy: "tasks",
+    consumes: ["spec", "plan"],
+    requiredFor: ["accelerated", "full"]
+  },
+  {
+    id: "requirements-checklist",
+    path: "checklists/requirements.md",
+    producedBy: "checklist",
+    consumes: ["spec"],
+    requiredFor: []
+  },
+  {
+    id: "research",
+    path: "research.md",
+    producedBy: "plan",
+    consumes: ["spec"],
+    requiredFor: []
+  },
+  {
+    id: "data-model",
+    path: "data-model.md",
+    producedBy: "plan",
+    consumes: ["spec"],
+    requiredFor: []
+  },
+  {
+    id: "contracts",
+    path: "contracts/",
+    producedBy: "plan",
+    consumes: ["spec"],
+    requiredFor: []
+  },
+  {
+    id: "quickstart",
+    path: "quickstart.md",
+    producedBy: "plan",
+    consumes: ["spec", "plan"],
+    requiredFor: []
+  },
+  {
+    id: "verify-report",
+    path: "verify-report.md",
+    producedBy: "verify",
+    consumes: ["spec", "plan", "tasks"],
+    requiredFor: ["accelerated", "full"]
+  },
+  {
+    id: "archive-report",
+    path: "archive-report.md",
+    producedBy: "archive",
+    consumes: ["spec", "plan", "tasks", "verify-report"],
+    requiredFor: ["accelerated", "full"]
+  }
+];
+var SDD_ROUTE_EXECUTION_POLICIES = [
+  {
+    route: "direct",
+    planningMode: "none",
+    validationGates: [],
+    optionalArtifactsByDefault: false,
+    routineUserPauses: false,
+    artifactRevisionPolicy: "none"
+  },
+  {
+    route: "accelerated",
+    planningMode: "fast-forward",
+    validationGates: ["specify", "ready", "closeout"],
+    optionalArtifactsByDefault: false,
+    routineUserPauses: false,
+    artifactRevisionPolicy: "revalidate-affected-downstream"
+  },
+  {
+    route: "full",
+    planningMode: "gated",
+    validationGates: ["specify", "plan", "tasks", "ready", "closeout"],
+    optionalArtifactsByDefault: false,
+    routineUserPauses: false,
+    artifactRevisionPolicy: "revalidate-affected-downstream"
+  }
+];
+var SDD_WORKFLOW_CONTRACT = {
+  artifactRoot: "openspec/changes/<feature>/",
+  phases: [...SDD_PHASES],
+  routePolicies: SDD_ROUTE_EXECUTION_POLICIES.map((policy) => ({
+    ...policy,
+    validationGates: [...policy.validationGates]
+  })),
+  routingRules: [
+    "An explicitly requested direct, accelerated, or full route wins; a generic SDD request sets accelerated as the minimum route.",
+    "Direct work is the default for clear, bounded, low-risk changes; documentation and mechanical work may remain direct across multiple files.",
+    "Accelerated SDD is used for multi-surface behavior, architecture, partial clarity, moderate risk, or broad non-behavioral coordination.",
+    "Accelerated planning fast-forwards specify, plan, and tasks in one uninterrupted root pass without routine user pauses.",
+    "Full SDD is used for unresolved scope, cross-cutting behavior or architecture, high contract risk, or high failure cost.",
+    "Use architectural-grilling before specification only when the user explicitly requests it or material product or architecture decisions remain human-owned and unresolved; never require it merely because the route is Full.",
+    "User input is requested only when a material unresolved decision would change the result."
+  ],
+  artifactRules: [
+    "Spec Kit artifact semantics are preserved inside the governed openspec store.",
+    "Accelerated and full routes require spec.md, plan.md, tasks.md, verify-report.md, and archive-report.md.",
+    "Research, data model, contracts, quickstart, and requirements checklist are created only when useful.",
+    "The adaptive root writes coordination artifacts after loading the matching bundled phase contract; implementation ownership stays with the root or one writer role.",
+    "After oracle PASS, archive transactionally synchronizes only explicitly declared durable ADDED, MODIFIED, REMOVED, and RENAMED requirement deltas into openspec/specs; INTERNAL requirements and undeclared prose never update permanent specifications.",
+    "Archive stages and backs up writes so handled failures roll back within the active process; forced process or operating-system termination is not crash-atomic."
+  ],
+  verificationRules: [
+    "Every route delegates focused verification to read-only oracle; the implementation writer never verifies its own work.",
+    "Full SDD delegates independent cross-artifact analysis to oracle before implementation.",
+    "Accelerated and full verification persists verify-report.md with a pass or fail verdict and requirement compliance matrix.",
+    "An artifact-backed fail verdict routes through append-only convergence, implementation, and verification again; direct work returns straight to implementation.",
+    "A pass verdict is required before accelerated or full work can archive."
+  ]
+};
+function clonePhase(phase) {
+  return {
+    ...phase,
+    availableFor: [...phase.availableFor],
+    requiredFor: [...phase.requiredFor],
+    prerequisites: [...phase.prerequisites],
+    eligibleAgentRoles: [...phase.eligibleAgentRoles]
+  };
+}
+function getSddWorkflowContract() {
+  return {
+    artifactRoot: SDD_WORKFLOW_CONTRACT.artifactRoot,
+    phases: SDD_WORKFLOW_CONTRACT.phases.map(clonePhase),
+    routePolicies: SDD_WORKFLOW_CONTRACT.routePolicies.map((policy) => ({
+      ...policy,
+      validationGates: [...policy.validationGates]
+    })),
+    routingRules: [...SDD_WORKFLOW_CONTRACT.routingRules],
+    artifactRules: [...SDD_WORKFLOW_CONTRACT.artifactRules],
+    verificationRules: [...SDD_WORKFLOW_CONTRACT.verificationRules]
+  };
+}
+function getSddRouteExecutionPolicy(route) {
+  const policy = SDD_ROUTE_EXECUTION_POLICIES.find(
+    (candidate) => candidate.route === route
+  );
+  if (!policy) {
+    throw new Error(`Unknown SDD route policy: ${route}`);
+  }
+  return {
+    ...policy,
+    validationGates: [...policy.validationGates]
+  };
+}
+function getSddArtifactGraph() {
+  return SDD_ARTIFACT_GRAPH.map((artifact) => ({
+    ...artifact,
+    consumes: [...artifact.consumes],
+    requiredFor: [...artifact.requiredFor]
+  }));
+}
+function getSddPhase(id) {
+  const phase = SDD_PHASES.find((candidate) => candidate.id === id);
+  if (!phase) {
+    throw new Error(`Unknown SDD phase: ${id}`);
+  }
+  return clonePhase(phase);
+}
+function renderSddPhaseDispatchTemplate() {
+  return `## PHASE
+phase=<phase-id>
+
+## ROUTE / CHANGE
+<direct|accelerated|full> / <feature-or-direct-task>
+
+## OBJECTIVE
+<phase objective>
+
+## INPUT ARTIFACTS
+<required files, evidence, and prior handoff>
+
+## REQUIREMENTS
+<concrete outcomes and phase instructions>
+
+## BOUNDARIES
+<allowed writes, assigned surface, and non-goals>
+
+## VERIFICATION
+<done criteria, blockers, and checks>
+
+## EXPECTED OUTPUT
+<phase result fields>
+
+## HANDOFF
+<what the next phase must preserve>
+
+## MEMORY
+provider=thoth-mem
+project=<project-name>
+root_session_id=<stable-root-session-id|unavailable>
+authorization=<none|recall|observe>
+context:
+<bounded recalled context or - none>`;
+}
+function getSddPhaseOwner(_route, phaseId) {
+  return getSddPhase(phaseId).defaultAgentRole;
+}
+function getRequiredSddPhaseOrder(route) {
+  return SDD_PHASES.filter(
+    (phase) => phase.requiredFor.includes(route)
+  ).map((phase) => phase.id);
+}
+
+// src/agents/prompt-sections.ts
+function createQuestionProtocolSection() {
+  return { kind: "question-protocol", toolConcept: "userQuestion" };
+}
+function createSubagentRulesSection(memoryAccess = "dispatch-scoped") {
+  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 getPrimaryModelId2(model) {
+  if (Array.isArray(model)) {
+    const first = model[0];
+    return typeof first === "string" ? first : first?.id;
+  }
+  return model;
+}
+function detectModelFamilyFromModel(model) {
+  const id = getPrimaryModelId2(model)?.toLowerCase();
+  if (!id) return void 0;
+  if (id.includes("gpt") || id.startsWith("openai/")) return "openai";
+  return void 0;
+}
+function createModelFamilySection(role, model) {
+  const family = detectModelFamilyFromModel(model);
+  return family ? { kind: "model-family", role, family } : void 0;
+}
+function roleText(template) {
+  return { kind: "role-text", template };
+}
+function roleTemplate(role) {
+  return `{{role.${role}}}`;
+}
+function renderSddRoute(route) {
+  return getRequiredSddPhaseOrder(route).map(
+    (phase) => `${phase} (${roleTemplate(getSddPhaseOwner(route, phase))})`
+  ).join(" -> ");
+}
+function renderRoleDirectory() {
+  return getAgentPackContract().roles.filter((role) => role.name !== "orchestrator").map((role) => `- ${roleTemplate(role.name)}: ${role.responsibility}`).join("\n");
+}
+function renderArtifactSummary() {
+  return getSddArtifactGraph().filter((artifact) => artifact.requiredFor.length === 0).map((artifact) => artifact.path).join(", ");
+}
+function createOrchestratorPromptSections() {
+  const workflow = getSddWorkflowContract();
+  const policy = getAgentPackContract().orchestrationPolicy;
+  const accelerated = getSddRouteExecutionPolicy("accelerated");
+  const full = getSddRouteExecutionPolicy("full");
+  return [
+    roleText(`<role>
+You are the adaptive root for thoth-agents. Keep requirements, decisions, execution ownership, and final synthesis in this thread.
+</role>
+
+<operating-model>
+- Handle bounded direct work when intent and risk are clear; never verify your own implementation.
+- Delegate only for net gain from specialization, context isolation, review, or safe parallelism. The maximum delegation depth is ${policy.maxDelegationDepth}; children never delegate.
+- Maintain one writer for each mutable surface. Parallelize only independent work with no overlapping writes.
+- Keep prompts bounded; request distilled evidence, not raw logs or full files.
+- Use \`{{userQuestionTool}}\` only when a material unresolved choice changes the result. Continue all safe non-blocked work first.
+- Use \`{{progressTool}}\` only when the work genuinely has multiple dependent steps.
+</operating-model>
+
+<routing>
+${renderRoleDirectory()}
+</routing>
+
+<sdd-routing>
+- An explicitly requested route wins; a generic SDD request sets Accelerated as the minimum unless Full risk applies.
+- Direct: clear, bounded, low-risk work. ${renderSddRoute("direct")}.
+- Documentation or mechanical work may remain Direct across multiple files when it is clear and low risk.
+- Accelerated SDD: multi-surface behavior, architecture, partial clarity, or moderate risk. ${renderSddRoute("accelerated")}.
+- For Accelerated, run specify -> plan -> tasks in one uninterrupted root pass. Do not pause between those planning artifacts; ask only for a material unresolved decision.
+- Its thoth-sdd validator gates are ${accelerated.validationGates.join(" -> ")}; optional artifacts are off by default.
+- Full SDD: uncertain scope, cross-cutting behavior or architecture, high contract risk, or high failure cost. ${renderSddRoute("full")}.
+- Full gates are ${full.validationGates.join(" -> ")}; checklist remains conditional.
+- Happy path: verify -> archive. Artifact-backed failure loop: verify fail -> converge -> implement -> verify. Direct failure loop: verify fail -> implement -> verify.
+- Conditional phases: clarify only for material ambiguity; checklist only when requirement risk justifies it; converge only when verification finds actionable defects.
+- When implementation discoveries refine the same intent, update the canonical artifact and revalidate only affected downstream artifacts. Split a new change when the intent changes.
+- Load the bundled \`thoth-sdd\` skill only after selecting Accelerated or Full, then read only the reference for the current phase.
+- Root owns specify, clarify, plan, checklist, tasks, converge, and archive coordination; these phases are not delegated merely to change prompts.
+- Delegate analyze and every verify phase to ${roleTemplate("oracle")}, including Direct and Accelerated work. The implementation writer must never review itself.
+</sdd-routing>
+
+<external-skills>
+- Use bundled \`thoth-constitution\` for constitution lifecycle and \`thoth-archive\` for verified artifact-backed closeout.
+- Use the installed mandatory \`tdd\` skill for behavior changes and \`simplify\` after implementation without changing behavior.
+- During an SDD, never invoke the thoth-agents CLI, \`npx skills add\`, or a network fetch. A missing local contract means incomplete installation.
+- Use progressive-context-router only for repository instruction or context-router work.
+- Use architectural-grilling before specification only when the user explicitly asks to be grilled or material human-owned product or architecture decisions remain unresolved.
+- Do not invoke it merely because the route is Full. While grilling, ask one material question per turn and await explicit closure.
+- Feed accepted decisions forward; spec.md and plan.md remain canonical instead of creating a duplicate blueprint artifact by default.
+</external-skills>
+
+<memory>
+- Load the installed \`thoth-mem\` skill for resume or prior work and provider-backed memory; never invent its protocol.
+- Preserve a durable decision, root cause, convention, or discovery only when reusable. Root owns the stable root session ID, project, lifecycle, real-user intent, and authorization; never invent identity or confirmed effects.
+- Follow the skill at verified compaction and a meaningful semantic boundary. Children receive only bounded MEMORY dispatch and never own root lifecycle.
+- \`openspec/\` remains canonical; do not mirror SDD phase artifacts into provider memory. A memory failure degrades memory only and does not block unrelated implementation or verification.
+</memory>
+
+<artifacts>
+- Preserve Spec Kit semantics inside ${workflow.artifactRoot}.
+- Accelerated and Full require spec.md, plan.md, tasks.md, verify-report.md, and archive-report.md; optional when useful: ${renderArtifactSummary()}.
+- Root owns openspec/ coordination and thoth-sdd gates; product work has one writer, and root alone moves [~] -> [x] after evidence.
+- ${roleTemplate("oracle")} returns read-only findings. Root persists verification; after PASS, archive syncs declared durable deltas and moves the change to openspec/changes/archive/YYYY-MM-DD-<feature>/.
+</artifacts>
+
+<execution>
+- Validate contracts and tests first; use test-first work for behavior. Root or one writer implements; do not delegate merely because an agent exists.
+- ${roleTemplate("oracle")} always provides independent verification and also owns Full SDD analysis. Root and implementation writers never self-approve.
+- Preserve unrelated working-tree changes. Never instruct an agent to discard them.
+- Report changed files, evidence, risks, and capability gaps truthfully.
+</execution>
+
+<delegation>
+- Dispatch through \`{{delegationTool}}\` with this envelope; use the same boundaries for non-SDD work.
+- Parallelize only independent work and await requested results before synthesis.
+- Child return fields: conclusion, evidence, verification, risks, openQuestions, nextAction.
+
+${renderSddPhaseDispatchTemplate()}
+</delegation>`),
+    createQuestionProtocolSection()
+  ];
+}
+var ROLE_SPECIFIC_RULES = {
+  explorer: [
+    "Resolve the assigned repository question with paths, symbols, and concise anchors.",
+    "Search broadly only when the target is genuinely unknown; stop once the evidence is decision-ready."
+  ],
+  librarian: [
+    "Prefer current official documentation and primary sources.",
+    "Cite every substantive external claim and label inference explicitly."
+  ],
+  oracle: [
+    "Separate observations, risks, and recommendations.",
+    "Review against stated requirements and contracts; do not invent implementation scope.",
+    "For analyze or verify, load the matching bundled thoth-sdd reference and remain read-only.",
+    "Reject self-review: the implementing root or writer cannot substitute for independent oracle judgment."
+  ],
+  designer: [
+    "Own user-facing choices, implementation, and visual verification.",
+    "Check relevant responsive and interaction states when feasible."
+  ],
+  quick: [
+    "Make the smallest complete edit and stop after focused verification.",
+    "Escalate instead of expanding a bounded assignment into broad discovery."
+  ],
+  deep: [
+    "Build the necessary local mental model and use tests first for behavior changes.",
+    "Verify related call sites, edge cases, and shared contracts before completion."
+  ]
+};
+function childSections(roleName) {
+  const role = getAgentRole(roleName);
+  const dispatch = role.dispatch === "synchronous-task-only" ? "{{dispatch.synchronous-task-only}}" : "{{dispatch.task}}";
+  const writeScope = role.writeScope?.length ? `
+- Write scope: ${role.writeScope.join(", ")}` : "";
+  const modeRules = role.mode === "read-only" ? [
+    "Do not mutate the workspace.",
+    "Do not create coordination artifacts."
+  ] : [
+    "Edit only the assigned phase surface.",
+    "Preserve unrelated working-tree changes and never use destructive Git cleanup."
+  ];
+  const sections = [
+    roleText(`<role>
+You are ${roleName}.
+</role>
+
+<mode>
+- Mode: ${role.mode}
+- Dispatch: ${dispatch}
+- Scope: ${role.scope}${writeScope}
+</mode>
+
+<responsibility>
+${role.responsibility}
+</responsibility>`),
+    createReasoningDisciplineSection(),
+    roleText(`<rules>
+- Do not delegate further or manage root progress.
+- ${modeRules.join("\n- ")}
+- ${ROLE_SPECIFIC_RULES[roleName].join("\n- ")}
+- Ask only when a local blocking decision cannot be resolved from the assignment and evidence.
+</rules>`),
+    createSubagentRulesSection(),
+    createQuestionProtocolSection(),
+    roleText(`<return-contract>
+Return a compact result with these fields:
+- conclusion
+- evidence
+- verification
+- risks
+- openQuestions
+- nextAction
+</return-contract>`),
+    createResponseBudgetSection()
+  ];
+  return sections;
+}
+function createReadOnlySpecialistPromptSections(role) {
+  return childSections(role);
+}
+function createWriteCapableSpecialistPromptSections(role) {
+  return childSections(role);
+}
+function createRolePromptSections(role) {
+  const mode = getAgentRole(role).mode;
+  switch (mode) {
+    case "adaptive-root":
+      return createOrchestratorPromptSections();
+    case "read-only":
+      return createReadOnlySpecialistPromptSections(role);
+    case "write-capable":
+      return createWriteCapableSpecialistPromptSections(
+        role
+      );
+  }
+}
+function renderQuestionProtocol(_section, dialect) {
+  return `<questions>
+Use \`${dialect.tools.userQuestionTool}\` only for a blocking material choice, destructive or security-sensitive action, or missing secret. Do safe non-blocked work first and ask one targeted question with a recommended default.
+</questions>`;
+}
+function renderSubagentRules(section, dialect) {
+  const rules = [
+    `- Do not delegate further or call \`${dialect.tools.progressTool}\`.`,
+    `- Use \`${dialect.tools.userQuestionTool}\` only for a local blocking choice.`,
+    "- Use terminating checks; avoid watch processes and indefinite waits.",
+    "- Never discard or overwrite unrelated working-tree changes."
+  ];
+  if (section.memoryAccess === "dispatch-scoped") {
+    rules.push(
+      "- Read the dispatch MEMORY block: `none` forbids provider work, `recall` permits bounded reads, and `observe` additionally permits a bounded durable observation under the delegated scope.",
+      "- For `recall` or `observe`, load and follow the installed `thoth-mem` skill; do not invent provider mechanics or claim unconfirmed effects.",
+      "- MEMORY authorization does not authorize workspace mutation. It never transfers root lifecycle or real-user-intent ownership to a child.",
+      "- `openspec/` remains canonical; do not mirror SDD phase artifacts into provider memory.",
+      "- Report unavailable, degraded, stale, contradictory, or insufficient memory evidence and continue unrelated assigned work when safe."
+    );
+  }
+  return rules.join("\n");
+}
+function renderReasoningDiscipline() {
+  return `<reasoning-discipline>
+- Check the most likely failure mode and one meaningful alternative before acting.
+- Ground conclusions in current evidence and verify the assigned outcome before returning.
+</reasoning-discipline>`;
+}
+function renderResponseBudget() {
+  return "Be concise. Return distilled evidence and outcomes, not raw logs or full-file dumps.";
+}
+function renderStepBudget(section) {
+  return `<step-budget>
+- Execution budget: ${section.steps} steps.
+- Prioritize high-signal checks and return partial evidence with the next target instead of looping.
+</step-budget>`;
+}
+function getRoleModelProfile(role) {
+  switch (role) {
+    case "orchestrator":
+      return "Act directly on bounded work; delegate only for net gain and synthesize all results.";
+    case "explorer":
+      return "Navigate from broad uncertainty to exact repository anchors.";
+    case "librarian":
+      return "Prioritize current primary sources, versions, and explicit citations.";
+    case "oracle":
+      return "Challenge assumptions and return evidence-backed judgment.";
+    case "designer":
+      return "Make concrete UX choices and verify the visible result.";
+    case "quick":
+      return "Favor the smallest complete edit and focused verification.";
+    case "deep":
+      return "Trace shared behavior, test assumptions, and verify edge cases.";
+  }
+}
+function renderModelFamily(section) {
+  const familyGuidance = {
+    openai: "Plan briefly, then act with explicit tool targets and return shapes."
+  };
+  return `<model-profile family="${section.family}">
+- ${familyGuidance[section.family]}
+- ${getRoleModelProfile(section.role)}
+</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(),
+  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 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/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,
+  CONFIRMED_OPENAI_SUBAGENT_PRESET,
+  OPENCODE_OPENAI_ORCHESTRATOR_PRESET,
+  DEFAULT_MODELS,
+  getDefaultOpenCodeModel,
+  getDefaultOpenCodeVariant,
+  POLL_INTERVAL_BACKGROUND_MS,
+  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,
+  getAgentPackContract,
+  createStepBudgetSection,
+  createModelFamilySection,
+  createOrchestratorPromptSections,
+  createReadOnlySpecialistPromptSections,
+  createWriteCapableSpecialistPromptSections,
+  createRolePromptSections,
+  renderPromptSection,
+  renderRolePrompt,
+  appendPromptSections,
+  getStepBudgetPromptSection,
+  getModelFamilyPromptSection,
+  composeAgentPrompt,
+  CONTEXT7_MCP_URL,
+  context7,
+  exa,
+  GREP_APP_MCP_URL,
+  grep_app
+};