thoth-agents 0.1.5 → 0.1.7

package/dist/index.js

@@ -1,971 +1,35 @@
-// src/index.ts
-import path5 from "path";
-
-// src/config/constants.ts
-var AGENT_ALIASES = {
-  explore: "explorer",
-  "frontend-ui-ux-engineer": "designer"
-};
-var SUBAGENT_NAMES = [
-  "explorer",
-  "librarian",
-  "oracle",
-  "designer",
-  "quick",
-  "deep"
-];
-var DEFAULT_MODELS = {
-  orchestrator: void 0,
-  oracle: "openai/gpt-5.4",
-  librarian: "openai/gpt-5.4-mini",
-  explorer: "openai/gpt-5.4-mini",
-  designer: "openai/gpt-5.4-mini",
-  quick: "openai/gpt-5.4-mini",
-  deep: "openai/gpt-5.4"
-};
-var POLL_INTERVAL_BACKGROUND_MS = 2e3;
-var DEFAULT_TIMEOUT_MS = 2 * 60 * 1e3;
-var MAX_POLL_TIME_MS = 5 * 60 * 1e3;
-var DEFAULT_THOTH_COMMAND = ["npx", "-y", "thoth-mem"];
-
-// src/config/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")];
-}
-
-// src/cli/config-io.ts
-function stripJsonComments(json) {
-  const commentPattern = /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g;
-  const trailingCommaPattern = /\\"|"(?:\\"|[^"])*"|(,)(\s*[}\]])/g;
-  return json.replace(
-    commentPattern,
-    (match, commentGroup) => commentGroup ? "" : match
-  ).replace(
-    trailingCommaPattern,
-    (match, comma, closing) => comma ? closing : match
-  );
-}
-
-// src/config/schema.ts
-import { z } from "zod";
-var AGENT_NAMES = [
-  "orchestrator",
-  "oracle",
-  "designer",
-  "explorer",
-  "librarian",
-  "quick",
-  "deep"
-];
-var FALLBACK_AGENT_NAMES = [...AGENT_NAMES];
-var MANUAL_AGENT_NAMES = [...AGENT_NAMES];
-var ProviderModelIdSchema = z.string().regex(
-  /^[^/\s]+\/[^\s]+$/,
-  "Expected provider/model format (provider/.../model)"
-);
-var ManualAgentPlanSchema = z.object({
-  primary: ProviderModelIdSchema,
-  fallback1: ProviderModelIdSchema,
-  fallback2: ProviderModelIdSchema,
-  fallback3: ProviderModelIdSchema
-}).superRefine((value, ctx) => {
-  const unique = /* @__PURE__ */ new Set([
-    value.primary,
-    value.fallback1,
-    value.fallback2,
-    value.fallback3
-  ]);
-  if (unique.size !== 4) {
-    ctx.addIssue({
-      code: z.ZodIssueCode.custom,
-      message: "primary and fallbacks must be unique per agent"
-    });
-  }
-});
-var ManualPlanSchema = z.object({
-  orchestrator: ManualAgentPlanSchema,
-  oracle: ManualAgentPlanSchema,
-  designer: ManualAgentPlanSchema,
-  explorer: ManualAgentPlanSchema,
-  librarian: ManualAgentPlanSchema,
-  quick: ManualAgentPlanSchema,
-  deep: ManualAgentPlanSchema
-}).strict();
-var AgentModelChainSchema = z.array(z.string()).min(1);
-var FallbackChainsSchema = z.object({
-  orchestrator: AgentModelChainSchema.optional(),
-  oracle: AgentModelChainSchema.optional(),
-  designer: AgentModelChainSchema.optional(),
-  explorer: AgentModelChainSchema.optional(),
-  librarian: AgentModelChainSchema.optional(),
-  quick: AgentModelChainSchema.optional(),
-  deep: AgentModelChainSchema.optional()
-}).catchall(AgentModelChainSchema);
-var AgentOverrideConfigSchema = z.object({
-  model: z.union([
-    z.string(),
-    z.array(
-      z.union([
-        z.string(),
-        z.object({
-          id: z.string(),
-          variant: z.string().optional()
-        })
-      ])
-    )
-  ]).optional(),
-  temperature: z.number().min(0).max(2).optional(),
-  steps: z.number().int().min(1).optional(),
-  variant: z.string().optional().catch(void 0)
-});
-var TmuxLayoutSchema = z.enum([
-  "main-horizontal",
-  // Main pane on top, agents stacked below
-  "main-vertical",
-  // Main pane on left, agents stacked on right
-  "tiled",
-  // All panes equal size grid
-  "even-horizontal",
-  // All panes side by side
-  "even-vertical"
-  // All panes stacked vertically
-]);
-var TmuxConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  layout: TmuxLayoutSchema.default("main-vertical"),
-  main_pane_size: z.number().min(20).max(80).default(60)
-  // percentage for main pane
-});
-var PresetSchema = z.record(z.string(), AgentOverrideConfigSchema);
-var AgentNameSchema = z.enum(AGENT_NAMES);
-var McpNameSchema = z.enum([
-  "exa",
-  "context7",
-  "grep_app",
-  "thoth_mem"
-]);
-var ThothConfigSchema = z.object({
-  command: z.array(z.string()).optional(),
-  data_dir: z.string().optional(),
-  environment: z.record(z.string(), z.string()).optional(),
-  timeout: z.number().optional(),
-  http_port: z.number().optional()
-});
-var ArtifactStoreModeSchema = z.enum([
-  "thoth-mem",
-  "openspec",
-  "hybrid"
-]);
-var ArtifactStoreConfigSchema = z.object({
-  mode: ArtifactStoreModeSchema.default("hybrid")
-});
-var CodexGenerationConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  outputRoot: z.string().optional(),
-  dryRun: z.boolean().default(true)
-});
-var FailoverConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  timeoutMs: z.number().min(0).default(15e3),
-  retryDelayMs: z.number().min(0).default(500),
-  chains: FallbackChainsSchema.default({})
-});
-var PluginConfigSchema = z.object({
-  preset: z.string().optional(),
-  setDefaultAgent: z.boolean().optional(),
-  scoringEngineVersion: z.enum(["v1", "v2-shadow", "v2"]).optional(),
-  balanceProviderUsage: z.boolean().optional(),
-  manualPlan: ManualPlanSchema.optional(),
-  presets: z.record(z.string(), PresetSchema).optional(),
-  agents: z.record(z.string(), AgentOverrideConfigSchema).optional(),
-  disabled_mcps: z.array(z.string()).optional(),
-  tmux: TmuxConfigSchema.optional(),
-  fallback: FailoverConfigSchema.optional(),
-  thoth: ThothConfigSchema.optional(),
-  artifactStore: ArtifactStoreConfigSchema.optional(),
-  codex: CodexGenerationConfigSchema.optional()
-});
-
-// src/config/loader.ts
-var PROMPTS_DIR_NAME = "thoth-agents";
-function loadConfigFromPath(configPath) {
-  try {
-    const content = fs.readFileSync(configPath, "utf-8");
-    const rawConfig = JSON.parse(stripJsonComments(content));
-    const result = PluginConfigSchema.safeParse(rawConfig);
-    if (!result.success) {
-      console.warn(`[thoth-agents] Invalid config at ${configPath}:`);
-      console.warn(result.error.format());
-      return null;
-    }
-    return result.data;
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
-      console.warn(
-        `[thoth-agents] Error reading config from ${configPath}:`,
-        error.message
-      );
-    }
-    return null;
-  }
-}
-function findConfigPath(basePath) {
-  const jsoncPath = `${basePath}.jsonc`;
-  const jsonPath = `${basePath}.json`;
-  if (fs.existsSync(jsoncPath)) {
-    return jsoncPath;
-  }
-  if (fs.existsSync(jsonPath)) {
-    return jsonPath;
-  }
-  return null;
-}
-function deepMerge(base, override) {
-  if (!base) return override;
-  if (!override) return base;
-  const result = { ...base };
-  for (const key of Object.keys(override)) {
-    const baseVal = base[key];
-    const overrideVal = override[key];
-    if (typeof baseVal === "object" && baseVal !== null && typeof overrideVal === "object" && overrideVal !== null && !Array.isArray(baseVal) && !Array.isArray(overrideVal)) {
-      result[key] = deepMerge(
-        baseVal,
-        overrideVal
-      );
-    } else {
-      result[key] = overrideVal;
-    }
-  }
-  return result;
-}
-function loadPluginConfig(directory) {
-  const userConfigBasePath = path.join(getConfigDir(), "thoth-agents");
-  const projectConfigBasePath = path.join(
-    directory,
-    ".opencode",
-    "thoth-agents"
-  );
-  const userConfigPath = findConfigPath(userConfigBasePath);
-  const projectConfigPath = findConfigPath(projectConfigBasePath);
-  let config = userConfigPath ? loadConfigFromPath(userConfigPath) ?? {} : {};
-  const projectConfig = projectConfigPath ? loadConfigFromPath(projectConfigPath) : null;
-  if (projectConfig) {
-    config = {
-      ...config,
-      ...projectConfig,
-      agents: deepMerge(config.agents, projectConfig.agents),
-      tmux: deepMerge(config.tmux, projectConfig.tmux),
-      fallback: deepMerge(config.fallback, projectConfig.fallback),
-      thoth: deepMerge(config.thoth, projectConfig.thoth),
-      artifactStore: deepMerge(
-        config.artifactStore,
-        projectConfig.artifactStore
-      ),
-      codex: deepMerge(config.codex, projectConfig.codex)
-    };
-  }
-  const envPreset = process.env.THOTH_AGENTS_PRESET;
-  if (envPreset) {
-    config.preset = envPreset;
-  }
-  if (config.preset) {
-    const preset = config.presets?.[config.preset];
-    if (preset) {
-      config.agents = deepMerge(preset, config.agents);
-    } else {
-      const presetSource = envPreset === config.preset ? "environment variable" : "config file";
-      const availablePresets = config.presets ? Object.keys(config.presets).join(", ") : "none";
-      console.warn(
-        `[thoth-agents] Preset "${config.preset}" not found (from ${presetSource}). Available presets: ${availablePresets}`
-      );
-    }
-  }
-  return config;
-}
-function loadAgentPrompt(agentName, preset) {
-  const presetDirName = preset && /^[a-zA-Z0-9_-]+$/.test(preset) ? preset : void 0;
-  const promptsDir = path.join(getConfigDir(), PROMPTS_DIR_NAME);
-  const promptSearchDirs = presetDirName ? [path.join(promptsDir, presetDirName), promptsDir] : [promptsDir];
-  const result = {};
-  const readFirstPrompt = (fileName, errorPrefix) => {
-    for (const dir of promptSearchDirs) {
-      const promptPath = path.join(dir, fileName);
-      if (!fs.existsSync(promptPath)) {
-        continue;
-      }
-      try {
-        return fs.readFileSync(promptPath, "utf-8");
-      } catch (error) {
-        console.warn(
-          `[thoth-agents] ${errorPrefix} ${promptPath}:`,
-          error instanceof Error ? error.message : String(error)
-        );
-      }
-    }
-    return void 0;
-  };
-  result.prompt = readFirstPrompt(
-    `${agentName}.md`,
-    "Error reading prompt file"
-  );
-  result.appendPrompt = readFirstPrompt(
-    `${agentName}_append.md`,
-    "Error reading append prompt file"
-  );
-  return result;
-}
-
-// src/config/utils.ts
-function getAgentOverride(config, name) {
-  const overrides = config?.agents ?? {};
-  return overrides[name] ?? overrides[Object.keys(AGENT_ALIASES).find((k) => AGENT_ALIASES[k] === name) ?? ""];
-}
-
-// src/agents/prompt-dialects.ts
-var OPENCODE_CAPABILITIES = {
-  agentDefinitions: "supported",
-  delegatedExecution: "supported",
-  parallelDelegation: "supported",
-  runtimeHooks: "supported",
-  mcpConfiguration: "supported",
-  skillPackaging: "supported",
-  rolePermissions: "supported",
-  parentContextInjection: "supported",
-  memoryGovernanceEnforcement: "supported"
-};
-function supportedCapabilityProfile(capabilities) {
-  return {
-    capabilities,
-    renderCapabilityDisclosure: () => void 0
-  };
-}
-var OPENCODE_PROMPT_DIALECT = {
-  harness: "opencode",
-  tools: {
-    delegationTool: "task",
-    backgroundDelegationTool: "task(background=true)",
-    backgroundStatusTool: "task_status",
-    userQuestionTool: "question",
-    progressTool: "todowrite",
-    hostStatusSurface: "task_status",
-    roleReference: (role) => `@${role}`
-  },
-  capabilities: supportedCapabilityProfile(OPENCODE_CAPABILITIES),
-  dispatchLabel(method) {
-    switch (method) {
-      case "root-coordinator":
-        return "root coordinator";
-      case "task":
-        return "task";
-      case "synchronous-task-only":
-        return "synchronous task only";
-    }
-  },
-  renderRoleInvocation(role) {
-    return `@${role}`;
-  }
-};
-
-// src/agents/prompt-sections.ts
-function createQuestionProtocolSection() {
-  return {
-    kind: "question-protocol",
-    toolConcept: "userQuestion"
-  };
-}
-function createSubagentRulesSection(memoryAccess = "base") {
-  return {
-    kind: "subagent-rules",
-    memoryAccess,
-    progressConcept: "progress",
-    userQuestionConcept: "userQuestion"
-  };
-}
-function createResponseBudgetSection() {
-  return { kind: "response-budget" };
-}
-function createStepBudgetSection(steps) {
-  if (steps === void 0 || !Number.isInteger(steps) || steps <= 0) {
-    return void 0;
-  }
-  return { kind: "step-budget", steps };
-}
-function detectModelFamilyFromModel(model) {
-  const id = getPrimaryModelId(model)?.toLowerCase();
-  if (!id) {
-    return void 0;
-  }
-  if (id.includes("claude") || id.startsWith("anthropic/")) {
-    return "claude";
-  }
-  if (id.includes("gpt") || id.startsWith("openai/")) {
-    return "openai";
-  }
-  if (id.includes("gemini") || id.startsWith("google/")) {
-    return "gemini";
-  }
-  if (id.includes("kimi") || id.includes("k2")) {
-    return "kimi";
-  }
-  if (id.includes("glm") || id.startsWith("zai-")) {
-    return "glm";
-  }
-  return void 0;
-}
-function createModelFamilySection(role, model) {
-  const family = detectModelFamilyFromModel(model);
-  if (!family) {
-    return void 0;
-  }
-  return { kind: "model-family", role, family };
-}
-function roleText(template) {
-  return { kind: "role-text", template };
-}
-function specialistSections({
-  role,
-  mode,
-  dispatch,
-  scope,
-  responsibility,
-  rules,
-  memoryAccess,
-  output
-}) {
-  const dispatchLabel = dispatch === "task" ? "{{dispatch.task}}" : "{{dispatch.synchronous-task-only}}";
-  return [
-    roleText(`<role>
-You are ${role}.
-</role>
-
-<mode>
-- Mode: ${mode}
-- Dispatch method: ${dispatchLabel}
-- Scope: ${scope}
-</mode>
-
-<responsibility>
-${responsibility}
-</responsibility>
-
-<rules>`),
-    createSubagentRulesSection(memoryAccess),
-    roleText(`${rules.join("\n")}
-</rules>`),
-    createQuestionProtocolSection(),
-    roleText(`<output>`),
-    createResponseBudgetSection(),
-    roleText(`${output}
-</output>`)
-  ];
-}
-function createOrchestratorPromptSections() {
-  return [
-    roleText(`<role>
-You are the delegate-first root coordinator and decision engine for thoth-agents.
-The root agent is the orchestrator/root coordinator for the session.
-Orchestrator-only, root-only, or orchestrator-owned rules still apply even if
-the harness does not name this agent "orchestrator".
-</role>
-
-<style>
-Respond in the user's language. Be warm, direct, evidence-led, and concise.
-Push back when context, risk, or assumptions are weak. Avoid verbosity.
-</style>
-
-<core-rules>
-- Mode: primary coordinator. Mutation: none.
-- Load \`thoth-mem-agents\` and \`requirements-interview\`.
-- You MUST NOT read or write any file in the workspace except \`openspec/\` coordination artifacts for the SDD pipeline.
-- Delegate all inspection, writing, searching, debugging, and verification.
-- Own the thinking: analyze the request, choose the approach, synthesize facts, make decisions, ask \`{{userQuestionTool}}\`, manage progress, and own root-session memory.
-- Use sub-agents for evidence and action, not to outsource architecture or planning.
-- Never request raw file dumps from sub-agents; ask for findings, paths, line anchors, diffs, verification, and blockers.
-- Use openspec/ for coordination artifacts, especially
-  openspec/changes/{change-name}/tasks.md.
-- Visual or UX work and screenshots always go to {{role.designer}}.
-- Verify through delegation, not inline.
-- Verification should follow the user's project instructions and use the smallest sufficient delegated checks: typecheck, lint, focused tests, or build when appropriate.
-</core-rules>
-
-<session-bootstrap>
-- At the start of a new root session, when thoth-mem tools are available, load \`thoth-mem-agents\` and \`requirements-interview\`, call \`mem_session_start\` with the current project and session identity, then save the real user prompt with \`mem_save_prompt\`.
-- Save only the real user request with \`mem_save_prompt\`; never save generated sub-agent prompts, handoffs, summaries, or tool scaffolding as user intent.
-- If thoth-mem tools or required session/project identity are unavailable, disclose that memory bootstrap could not run and continue without pretending memory was saved.
-</session-bootstrap>
-
-<routing>
-{{role.explorer}}: read-only codebase discovery. Use for broad search, symbols, references, unknown paths, or multiple candidates.
-{{role.librarian}}: read-only external docs/public examples. Use for version-sensitive APIs, official docs, or unfamiliar libraries.
-{{role.oracle}}: read-only review/diagnosis. Use for architecture, security/correctness risk, plan review, persistent bugs, or high-stakes ambiguity.
-{{role.designer}}: write-capable UI/UX owner. Use for user-facing UI, styles, layout, interactions, and all visual QA.
-{{role.quick}}: write-capable narrow implementer. Use for clear, mechanical, low-risk, uniform edits.
-{{role.deep}}: write-capable thorough implementer. Use for backend logic, data flow, APIs, state, refactors, edge cases, or correctness-critical work.
-
-Tiebreakers:
-- User-facing UI -> {{role.designer}}. Backend/system logic -> {{role.deep}}. Mechanical pattern -> {{role.quick}}.
-- Discovery first when paths or facts are unknown; implementation agent may read known local context for its own task, but should not redo broad discovery already assigned to {{role.explorer}}/{{role.librarian}}.
-- Do not use {{role.oracle}} for routine synthesis. After {{role.explorer}}/{{role.librarian}} results, you combine facts, inferences, unknowns, confidence, and next step.
-</routing>
-
-<subagent-prompts>
-- Every sub-agent prompt you write must be in English, regardless of the user's language.
-- Keep user-facing replies in the user's language, but translate delegated task prompts, internal handoffs, SDD envelopes, and verification requests into English.
-- Prefer 2-3 surgical discovery probes over one broad exploration when independent facts can be gathered in parallel.
-- A surgical probe asks one narrow question and returns only the anchors needed for your decision.
-</subagent-prompts>
-
-<internal-handoff>
-Before dispatching {{role.designer}}, {{role.quick}}, or {{role.deep}} after discovery, synthesize a compact internal handoff. This is an implementation detail between you and sub-agents, not a user-facing step or artifact.
-
-Internal handoff fields:
-- Goal: the specific outcome for this task.
-- Decision: the chosen approach and why it is the right next move.
-- Evidence: relevant files, symbols, line anchors, docs, constraints, and known invariants from {{role.explorer}}/{{role.librarian}}.
-- Scope: exact files/areas to change and non-goals to avoid.
-- Steps: ordered implementation instructions, including what to preserve.
-- Verification: smallest sufficient checks or visual QA required.
-- Uncertainty: remaining unknowns the implementer may resolve locally, plus what should be escalated instead of guessed.
-
-Never mention the internal handoff to the user, ask the user to prepare it, or present handoff preparation as the recommended next step. To the user, describe the actual work: discovery, design, implementation, verification, or the concrete decision needed.
-
-For {{role.explorer}}/{{role.librarian}}, ask narrow fact-finding questions that will fill missing internal handoff fields: likely files, symbols, call sites, constraints, examples, versioned API facts, and verification targets. Require decision-ready findings, not raw context.
-</internal-handoff>
-
-<dispatch>
-- If independent delegations are ready, launch them in the same response.
-- Default to normal synchronous \`{{delegationTool}}\` execution.
-- Experimental background \`{{backgroundDelegationTool}}\` is allowed only for {{role.explorer}} and {{role.librarian}} for asynchronous delegation.
-- {{role.oracle}}, {{role.designer}}, {{role.quick}}, and {{role.deep}} always use normal synchronous \`{{delegationTool}}\` execution.
-- When using background \`{{delegationTool}}\`, treat it as conditional and non-portable: if the host does not expose the experimental path, fall back to normal synchronous \`{{delegationTool}}\`.
-- Use \`{{backgroundStatusTool}}\` to wait, poll, and collect background task results before synthesizing or reporting completion.
-- If a result is empty, contradictory, or low-confidence, retry once with a materially sharper prompt; then escalate with evidence via \`{{userQuestionTool}}\`.
-- If a named subagent hits capacity, retry that same role up to 3 attempts.
-- Never switch to \`default\`, \`worker\`, or any other role.
-- After 3 failures, stay on the same role; if a same-role model override exists, use it. Otherwise report a capacity blocker.
-- Write-capable dispatches must include the internal handoff when one exists, so implementers can edit instead of rediscovering the plan.
-- Never tell sub-agents to discard working-tree changes.
-</dispatch>
-
-<sdd>
-All work always starts with requirements-interview skill.
-
-Routes:
-- Direct implementation for low-complexity work.
-- Accelerated SDD: propose -> tasks.
-- Full SDD: propose -> spec -> design -> tasks.
-
-Hard gates:
-- Artifact-producing SDD phases are dispatched to {{role.deep}} or {{role.quick}} with the matching skill loaded.
-- {{role.oracle}} is read-only and only handles plan-reviewer.
-- Never skip artifacts or jump from requirements-interview to implementation when SDD is selected.
-- Before SDD execution, load \`executing-plans\`; then track progress in {{progressTool}} plus the persistent artifact.
-- If openspec persistence is selected and openspec/ is missing, dispatch sdd-init first.
-- During SDD execution, batch compatible implementation work.
-- Group consecutive ready SDD tasks for the same execution agent into one dispatch when dependencies, scope, and verification can be handled together. Keep per-task tracking and evidence; do not split a compatible {{role.designer}}/{{role.quick}}/{{role.deep}} run into one delegation per checkbox.
-
-SDD dispatch envelope must include: skill name, persistence mode, pipeline type, change name, project name, needed prior artifact context, verification expectation, and return envelope.
-After each phase, verify the sub-agent reported the openspec path and/or thoth-mem topic_key. Retry once if missing.
-
-Artifact governance handoff:
-- After \`sdd-tasks\`, you may surface report-only artifact governance findings before execution preparation starts.
-- Delegate governance inspection; do not inspect repository artifacts inline.
-- Do not treat governance findings as an execution gate.
-- Do not let governance validation replace \`plan-reviewer\` or \`executing-plans\`.
-- Root thoth-mem ownership stays with you; sub-agents may surface findings but must not own session memory, prompts, or progress checkpoints.
-
-Plan gate: after tasks, ask with \`{{userQuestionTool}}\`: "Review plan with {{role.oracle}} before executing (Recommended)" or "Proceed to execution".
-If reviewed, the review loop is complete only after [OKAY].
-If {{role.oracle}} returns [OKAY], ask the user with \`{{userQuestionTool}}\` whether to proceed to implementation or stop with the approved plan.
-Do not dispatch \`sdd-apply\` after oracle approval until the user confirms implementation.
-Post-execution: delegate sdd-verify, then sdd-archive when verification passes.
-</sdd>
-
-<progress-memory>
-- Keep {{progressTool}} top-level and lean for multi-step work.
-- When SDD is active, update both {{progressTool}} and openspec/changes/{change-name}/tasks.md before dispatch and after results.
-- Root-session memory is yours: search before repeated work; save durable decisions, discoveries, bugs, patterns, constraints, and session summaries.
-- Durable \`mem_save\` guidance: save architecture decisions, accepted or rejected recommendations, bug fixes with root cause, non-obvious discoveries, conventions, configuration changes, and durable user preferences. Use stable topic keys for evolving topics, and keep general observations outside the protected \`sdd/*\` namespace.
-- Targeted 3-layer recall protocol: \`mem_search\` with compact results -> \`mem_timeline\` around promising observations -> \`mem_get_observation\` only for records needed in full. Use preview search only when compact results do not disambiguate.
-- SDD memory artifacts use deterministic topic keys only in thoth-mem or hybrid persistence modes: \`sdd/{change}/{artifact}\`.
-- Before ending the root session, call \`mem_session_summary\` with a concise Goal, Instructions, Discoveries, Accomplished, Next Steps, and Relevant Files summary. Do not claim memory was saved unless the tool call succeeded.
-- After compaction, first preserve the compacted summary with \`mem_session_summary\`, then recover recent context and use the 3-layer recall protocol before continuing work.
-</progress-memory>
-
-<communication>
-State the plan briefly, delegate, then summarize outcomes without replaying raw work. Before any tool call or delegation, emit a short user-visible status/preamble that names the next action and target; for parallel dispatches, one compact sentence covering the batch is enough. Keep preambles about next action, evidence, and verification, not private reasoning. Separate evidence, inference, and uncertainty when it matters. Never ask blocking questions in prose.
-</communication>`),
-    createQuestionProtocolSection()
-  ];
-}
-function createReadOnlySpecialistPromptSections(role) {
-  if (role === "explorer") {
-    return specialistSections({
-      role,
-      mode: "read-only",
-      dispatch: "task",
-      scope: "local repository discovery",
-      responsibility: "Find workspace facts fast. Return decision-ready evidence for internal handoffs: paths, lines, symbols, constraints, edit targets, and conclusions.",
-      rules: [
-        "- Questions should be rare; exhaust local evidence first.",
-        "- Prefer paths, lines, symbols, and concise summaries over dumps.",
-        "- 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: what remains ambiguous. State what additional context would unblock the search.
-
-UNCHECKED AREAS: what you did not inspect that could change the answer. Omit if nothing notable.
-
-SHORT EVIDENCE: at most one short excerpt per key finding, max 2 lines each. Skip if citations are self-explanatory.
-
-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 research plus local confirmation when needed",
-      responsibility: "Gather authoritative external evidence that helps the orchestrator make implementation decisions. Prefer official docs first, 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."
-      ],
-      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 strategic technical guidance anchored to evidence. 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."
-    ],
-    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 end to end: choose the UX approach, implement it, and verify it visually. Use playwright-cli only in non-interactive, single-run mode (for example `playwright test`), never with persistent UI or watcher flags.\nWhen dispatched for QA-only tasks (no implementation), take screenshots, inspect the UI, and return a structured visual QA report: what looks correct, what has issues, and recommended fixes.",
-      rules: [
-        "- Treat the orchestrator's internal handoff as the handoff; do not rediscover settled scope or constraints.",
-        "- Own UX decisions instead of bouncing them back unless a real user preference is required.",
-        "- Verify visually when feasible; do not stop at code that merely compiles.",
-        "- Keep changes focused on the user-facing outcome.",
-        "- NEVER run blocking or long-running commands: no `playwright test --ui`, `playwright show-report`, `--headed --debug`, dev servers, or watchers. Use single-run variants and capture screenshots/traces as artifacts."
-      ],
-      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 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.",
-        "- 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.",
-      "- Ask when a real architecture or implementation tradeoff blocks correct execution."
-    ],
-    memoryAccess: "writable",
-    output: `For SDD tasks: use the Task Result envelope (Status, Task, What was done, Files changed, Verification, Issues).
-For non-SDD work: summary + files changed + verification results + edge cases considered.
-- Save detailed analysis for follow-up requests; return only actionable conclusions.
-- Target: under 40 lines total.`
-  });
-}
-function getPrimaryModelId(model) {
-  if (Array.isArray(model)) {
-    const first = model[0];
-    return typeof first === "string" ? first : first?.id;
-  }
-  return model;
-}
-function renderQuestionProtocol(_section, dialect) {
-  return `<questions>
-Use \`${dialect.tools.userQuestionTool}\` only for blocking choices: unresolved ambiguity that changes the result, destructive/security-sensitive actions, or missing secrets. Do all non-blocked work first, ask one targeted question with a recommended default first, then stop.
-</questions>`;
-}
-function renderSubagentRules(section, dialect) {
-  const rules = [
-    `- Single-task leaf agent: do not delegate, manage SDD phases, act as orchestrator, or call \`${dialect.tools.progressTool}\`.`,
-    `- Use \`${dialect.tools.userQuestionTool}\` only for local blocking decisions.`,
-    "- Never discard working-tree changes: no `git restore`, `git checkout -- <path>`, `git reset --hard`, `git clean`, or `git stash`.",
-    "- Avoid blocking/watch commands; use terminating checks only."
-  ];
-  if (section.memoryAccess === "readonly") {
-    rules.push(
-      "- Use read-only thoth-mem only when dispatch gives session_id/project: `mem_search` -> `mem_timeline` -> `mem_get_observation`.",
-      "- Never call `mem_session_start`, `mem_session_summary`, or `mem_save_prompt`; those tools are orchestrator-owned.",
-      "- Never write memory; memory writes are orchestrator-owned."
-    );
-  }
-  if (section.memoryAccess === "writable") {
-    rules.push(
-      "- Use delegated thoth-mem tools only (mem_save, mem_search, mem_get_observation, mem_timeline, mem_suggest_topic_key).",
-      "- Never call `mem_session_start`, `mem_session_summary`, or `mem_save_prompt`; those tools are orchestrator-owned.",
-      "- Always use the parent session_id/project from dispatch for every thoth-mem call.",
-      "- If either is missing, do NOT call thoth-mem.",
-      "- For reads, use only `mem_search` -> `mem_timeline` -> `mem_get_observation`.",
-      "- You do not own durable memory of your own; `mem_save` writes under the orchestrator's session/project only."
-    );
-  }
-  return rules.join("\n");
-}
-function renderResponseBudget() {
-  return "Return concise structured results: status, summary, files, verification/issues. Never return raw file dumps.";
-}
-function renderStepBudget(section) {
-  return `<step-budget>
-- You have a hard execution budget of ${section.steps} steps.
-- Plan your tool use before acting, prioritize the highest-signal checks first, and stop once you have enough evidence to answer.
-- Avoid repeated searches or reads. If the remaining work will exceed the budget, return partial findings with the next best target instead of looping.
-</step-budget>`;
-}
-function getRoleModelProfile(role) {
-  switch (role) {
-    case "orchestrator":
-      return "- Exploit your role by selecting the right specialist category, launching independent tasks together, and synthesizing facts/inferences/unknowns before the next dispatch.";
-    case "explorer":
-      return "- Exploit your role by scanning broadly first, then narrowing to symbol/path evidence with ranked candidates and confidence.";
-    case "librarian":
-      return "- Exploit your role by prioritizing official docs, dates, versions, and source quality before summarizing public examples.";
-    case "oracle":
-      return "- Exploit your role by challenging assumptions, identifying risk, and giving a decision-ready recommendation backed by evidence.";
-    case "designer":
-      return "- Exploit your role by making concrete UX choices, implementing them, and verifying the visible result instead of stopping at code review.";
-    case "quick":
-      return "- Exploit your role by applying the smallest clear edit, avoiding broad exploration, and returning immediately after focused verification.";
-    case "deep":
-      return "- Exploit your role by building a complete mental model of shared behavior, writing tests first when behavior changes, and verifying edge cases.";
-  }
-}
-function renderModelFamily(section) {
-  const roleGuidance = getRoleModelProfile(section.role);
-  if (section.family === "claude") {
-    return `<model-profile family="claude">
-- Use XML-like sections, label uncertainty, and delegate aggressively when agentic.
-${roleGuidance}
-</model-profile>`;
-  }
-  if (section.family === "openai") {
-    return `<model-profile family="openai">
-- Plan briefly, then act. Keep tool dispatch explicit: action, target, return shape.
-${roleGuidance}
-</model-profile>`;
-  }
-  if (section.family === "gemini") {
-    return `<model-profile family="gemini">
-- Use long-context breadth deliberately, then ground conclusions in exact anchors.
-${roleGuidance}
-</model-profile>`;
-  }
-  if (section.family === "kimi") {
-    return `<model-profile family="kimi">
-- Favor repository-scale navigation before edits; keep patches grounded in current file state.
-${roleGuidance}
-</model-profile>`;
-  }
-  return `<model-profile family="glm">
-- Use compact checklists, conservative steps, clear verification, and concrete blockers.
-${roleGuidance}
-</model-profile>`;
-}
-function renderRoleText(section, dialect) {
-  return section.template.replaceAll("{{delegationTool}}", dialect.tools.delegationTool).replaceAll(
-    "{{backgroundDelegationTool}}",
-    dialect.tools.backgroundDelegationTool ?? dialect.tools.delegationTool
-  ).replaceAll(
-    "{{backgroundStatusTool}}",
-    dialect.tools.backgroundStatusTool ?? dialect.tools.hostStatusSurface ?? ""
-  ).replaceAll("{{userQuestionTool}}", dialect.tools.userQuestionTool).replaceAll("{{progressTool}}", dialect.tools.progressTool).replaceAll("{{dispatch.task}}", dialect.dispatchLabel("task")).replaceAll(
-    "{{dispatch.synchronous-task-only}}",
-    dialect.dispatchLabel("synchronous-task-only")
-  ).replace(
-    /\{\{role\.(\w+)\}\}/g,
-    (_match, role) => dialect.renderRoleInvocation(role)
-  );
-}
-function renderPromptSection(section, dialect) {
-  switch (section.kind) {
-    case "question-protocol":
-      return renderQuestionProtocol(section, dialect);
-    case "subagent-rules":
-      return renderSubagentRules(section, dialect);
-    case "response-budget":
-      return renderResponseBudget();
-    case "step-budget":
-      return renderStepBudget(section);
-    case "model-family":
-      return renderModelFamily(section);
-    case "role-text":
-      return renderRoleText(section, dialect);
-  }
-}
-function renderRolePrompt(sections, dialect) {
-  return sections.map((section) => renderPromptSection(section, dialect).trim()).filter(Boolean).join("\n\n");
-}
+  spawn,
+  spawnSync
+} from "./chunk-DYGVRAMS.js";
+import {
+  DEFAULT_MODELS,
+  DEFAULT_THOTH_COMMAND,
+  OPENCODE_PROMPT_DIALECT,
+  POLL_INTERVAL_BACKGROUND_MS,
+  SUBAGENT_NAMES,
+  appendPromptSections,
+  composeAgentPrompt,
+  context7,
+  createOrchestratorPromptSections,
+  createReadOnlySpecialistPromptSections,
+  createWriteCapableSpecialistPromptSections,
+  detectModelFamily,
+  exa,
+  getAgentOverride,
+  getModelFamilyPromptSection,
+  getOpenCodeConfigPaths,
+  getStepBudgetPromptSection,
+  grep_app,
+  installCustomSkills,
+  loadAgentPrompt,
+  loadPluginConfig,
+  renderRolePrompt,
+  stripJsonComments
+} from "./chunk-OES76C67.js";
 
-// 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/index.ts
+import path4 from "path";
 
 // src/agents/deep.ts
 var DEEP_PROMPT = renderRolePrompt(
@@ -1428,112 +492,39 @@ import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
 function getLogFile() {
   const os2 = require2("node:os");
-  const path6 = require2("node:path");
-  return path6.join(os2.tmpdir(), "thoth-agents.log");
+  const path5 = require2("node:path");
+  const configuredPath = process.env.THOTH_AGENTS_LOG_FILE?.trim();
+  return configuredPath || path5.join(os2.tmpdir(), "thoth-agents.log");
 }
 function log(message, data) {
   try {
-    const fs4 = require2("node:fs");
+    const fs3 = require2("node:fs");
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const logEntry = `[${timestamp}] ${message} ${data ? JSON.stringify(data) : ""}
 `;
-    fs4.appendFileSync(getLogFile(), logEntry);
+    fs3.appendFileSync(getLogFile(), logEntry);
   } catch {
   }
 }
 
 // src/hooks/auto-update-checker/cache.ts
-import * as fs2 from "fs";
-import * as path3 from "path";
-
-// src/cli/system.ts
-import { statSync as statSync2 } from "fs";
-
-// src/utils/subprocess.ts
-import {
-  spawn as nodeSpawn,
-  spawnSync as nodeSpawnSync
-} from "child_process";
-import { Readable } from "stream";
-function emptyReadableStream() {
-  return new ReadableStream({
-    start(controller) {
-      controller.close();
-    }
-  });
-}
-function toWebReadable(stream) {
-  if (!stream) {
-    return emptyReadableStream();
-  }
-  return Readable.toWeb(
-    stream
-  );
-}
-function fallbackStdin() {
-  return {
-    write: () => void 0,
-    end: () => void 0
-  };
-}
-function spawn(command, options = {}) {
-  const child = nodeSpawn(command[0], command.slice(1), {
-    cwd: options.cwd,
-    env: options.env,
-    stdio: [
-      options.stdin ?? "pipe",
-      options.stdout ?? "pipe",
-      options.stderr ?? "pipe"
-    ]
-  });
-  const managed = {
-    stdin: child.stdin ?? fallbackStdin(),
-    stdout: toWebReadable(child.stdout),
-    stderr: toWebReadable(child.stderr),
-    exited: new Promise((resolve4) => {
-      child.on("exit", (code) => {
-        managed.exitCode = code;
-        resolve4(code ?? 1);
-      });
-      child.on("error", () => {
-        managed.exitCode = 1;
-        resolve4(1);
-      });
-    }),
-    exitCode: child.exitCode,
-    kill: () => {
-      child.kill();
-    }
-  };
-  return managed;
-}
-function spawnSync(command, options = {}) {
-  const result = nodeSpawnSync(command[0], command.slice(1), {
-    cwd: options.cwd,
-    env: options.env,
-    stdio: [
-      options.stdin ?? "ignore",
-      options.stdout ?? "pipe",
-      options.stderr ?? "pipe"
-    ]
-  });
-  return { exitCode: result.status };
-}
+import * as fs from "fs";
+import * as path2 from "path";
 
 // src/hooks/auto-update-checker/constants.ts
 import * as os from "os";
-import * as path2 from "path";
+import * as path from "path";
 var PACKAGE_NAME = "thoth-agents";
 var NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
 var NPM_FETCH_TIMEOUT = 5e3;
 function getCacheDir() {
   if (process.platform === "win32") {
-    return path2.join(process.env.LOCALAPPDATA ?? os.homedir(), "opencode");
+    return path.join(process.env.LOCALAPPDATA ?? os.homedir(), "opencode");
   }
-  return path2.join(os.homedir(), ".cache", "opencode");
+  return path.join(os.homedir(), ".cache", "opencode");
 }
 var CACHE_DIR = getCacheDir();
-var INSTALLED_PACKAGE_JSON = path2.join(
+var INSTALLED_PACKAGE_JSON = path.join(
   CACHE_DIR,
   "node_modules",
   PACKAGE_NAME,
@@ -1546,22 +537,22 @@ var USER_OPENCODE_CONFIG_JSONC = configPaths[1];
 // src/hooks/auto-update-checker/cache.ts
 function invalidatePnpmPackageCache(packageName = PACKAGE_NAME) {
   try {
-    const pkgDir = path3.join(CACHE_DIR, "node_modules", packageName);
-    const pkgJsonPath = path3.join(CACHE_DIR, "package.json");
+    const pkgDir = path2.join(CACHE_DIR, "node_modules", packageName);
+    const pkgJsonPath = path2.join(CACHE_DIR, "package.json");
     let packageRemoved = false;
     let dependencyRemoved = false;
-    if (fs2.existsSync(pkgDir)) {
-      fs2.rmSync(pkgDir, { recursive: true, force: true });
+    if (fs.existsSync(pkgDir)) {
+      fs.rmSync(pkgDir, { recursive: true, force: true });
       log(`[auto-update-checker] Package removed: ${pkgDir}`);
       packageRemoved = true;
     }
-    if (fs2.existsSync(pkgJsonPath)) {
+    if (fs.existsSync(pkgJsonPath)) {
       try {
-        const content = fs2.readFileSync(pkgJsonPath, "utf-8");
+        const content = fs.readFileSync(pkgJsonPath, "utf-8");
         const pkgJson = JSON.parse(stripJsonComments(content));
         if (pkgJson.dependencies?.[packageName]) {
           delete pkgJson.dependencies[packageName];
-          fs2.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+          fs.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
           log(
             `[auto-update-checker] Dependency removed from package.json: ${packageName}`
           );
@@ -1588,8 +579,8 @@ function invalidatePnpmPackageCache(packageName = PACKAGE_NAME) {
 }
 
 // src/hooks/auto-update-checker/checker.ts
-import * as fs3 from "fs";
-import * as path4 from "path";
+import * as fs2 from "fs";
+import * as path3 from "path";
 import { fileURLToPath } from "url";
 function isPrereleaseVersion(version) {
   return version.includes("-");
@@ -1611,8 +602,8 @@ function extractChannel(version) {
 }
 function getConfigPaths(directory) {
   return [
-    path4.join(directory, ".opencode", "opencode.json"),
-    path4.join(directory, ".opencode", "opencode.jsonc"),
+    path3.join(directory, ".opencode", "opencode.json"),
+    path3.join(directory, ".opencode", "opencode.jsonc"),
     USER_OPENCODE_CONFIG,
     USER_OPENCODE_CONFIG_JSONC
   ];
@@ -1620,8 +611,8 @@ function getConfigPaths(directory) {
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!fs3.existsSync(configPath)) continue;
-      const content = fs3.readFileSync(configPath, "utf-8");
+      if (!fs2.existsSync(configPath)) continue;
+      const content = fs2.readFileSync(configPath, "utf-8");
       const config = JSON.parse(stripJsonComments(content));
       const plugins = config.plugin ?? [];
       for (const entry of plugins) {
@@ -1640,19 +631,19 @@ function getLocalDevPath(directory) {
 }
 function findPackageJsonUp(startPath) {
   try {
-    const stat = fs3.statSync(startPath);
-    let dir = stat.isDirectory() ? startPath : path4.dirname(startPath);
+    const stat = fs2.statSync(startPath);
+    let dir = stat.isDirectory() ? startPath : path3.dirname(startPath);
     for (let i = 0; i < 10; i++) {
-      const pkgPath = path4.join(dir, "package.json");
-      if (fs3.existsSync(pkgPath)) {
+      const pkgPath = path3.join(dir, "package.json");
+      if (fs2.existsSync(pkgPath)) {
         try {
-          const content = fs3.readFileSync(pkgPath, "utf-8");
+          const content = fs2.readFileSync(pkgPath, "utf-8");
           const pkg = JSON.parse(content);
           if (pkg.name === PACKAGE_NAME) return pkgPath;
         } catch {
         }
       }
-      const parent = path4.dirname(dir);
+      const parent = path3.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -1666,7 +657,7 @@ function getLocalDevVersion(directory) {
   try {
     const pkgPath = findPackageJsonUp(localPath);
     if (!pkgPath) return null;
-    const content = fs3.readFileSync(pkgPath, "utf-8");
+    const content = fs2.readFileSync(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     return pkg.version ?? null;
   } catch {
@@ -1676,8 +667,8 @@ function getLocalDevVersion(directory) {
 function findPluginEntry(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!fs3.existsSync(configPath)) continue;
-      const content = fs3.readFileSync(configPath, "utf-8");
+      if (!fs2.existsSync(configPath)) continue;
+      const content = fs2.readFileSync(configPath, "utf-8");
       const config = JSON.parse(stripJsonComments(content));
       const plugins = config.plugin ?? [];
       for (const entry of plugins) {
@@ -1704,8 +695,8 @@ var cachedPackageVersion = null;
 function getCachedVersion() {
   if (cachedPackageVersion) return cachedPackageVersion;
   try {
-    if (fs3.existsSync(INSTALLED_PACKAGE_JSON)) {
-      const content = fs3.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
+    if (fs2.existsSync(INSTALLED_PACKAGE_JSON)) {
+      const content = fs2.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.version) {
         cachedPackageVersion = pkg.version;
@@ -1715,10 +706,10 @@ function getCachedVersion() {
   } catch {
   }
   try {
-    const currentDir = path4.dirname(fileURLToPath(import.meta.url));
+    const currentDir = path3.dirname(fileURLToPath(import.meta.url));
     const pkgPath = findPackageJsonUp(currentDir);
     if (pkgPath) {
-      const content = fs3.readFileSync(pkgPath, "utf-8");
+      const content = fs2.readFileSync(pkgPath, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.version) {
         cachedPackageVersion = pkg.version;
@@ -1735,8 +726,8 @@ function getCachedVersion() {
 }
 function updatePinnedVersion(configPath, oldEntry, newVersion) {
   try {
-    if (!fs3.existsSync(configPath)) return false;
-    const content = fs3.readFileSync(configPath, "utf-8");
+    if (!fs2.existsSync(configPath)) return false;
+    const content = fs2.readFileSync(configPath, "utf-8");
     const newEntry = `${PACKAGE_NAME}@${newVersion}`;
     const escapedOldEntry = oldEntry.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const entryRegex = new RegExp(`(["'])${escapedOldEntry}\\1`, "g");
@@ -1750,7 +741,7 @@ function updatePinnedVersion(configPath, oldEntry, newVersion) {
     if (updatedContent === content) {
       return false;
     }
-    fs3.writeFileSync(configPath, updatedContent, "utf-8");
+    fs2.writeFileSync(configPath, updatedContent, "utf-8");
     log(
       `[auto-update-checker] Updated ${configPath}: ${oldEntry} \u2192 ${newEntry}`
     );
@@ -2009,22 +1000,22 @@ async function findTmuxPath() {
       return null;
     }
     const stdout = await new Response(proc.stdout).text();
-    const path6 = stdout.trim().split("\n")[0];
-    if (!path6) {
+    const path5 = stdout.trim().split("\n")[0];
+    if (!path5) {
       log("[tmux] findTmuxPath: no path in output");
       return null;
     }
-    const verifyProc = spawn([path6, "-V"], {
+    const verifyProc = spawn([path5, "-V"], {
       stdout: "pipe",
       stderr: "pipe"
     });
     const verifyExit = await verifyProc.exited;
     if (verifyExit !== 0) {
-      log("[tmux] findTmuxPath: tmux -V failed", { path: path6, verifyExit });
+      log("[tmux] findTmuxPath: tmux -V failed", { path: path5, verifyExit });
       return null;
     }
-    log("[tmux] findTmuxPath: found tmux", { path: path6 });
-    return path6;
+    log("[tmux] findTmuxPath: found tmux", { path: path5 });
+    return path5;
   } catch (err) {
     log("[tmux] findTmuxPath: exception", { error: String(err) });
     return null;
@@ -2224,8 +1215,8 @@ function isPwshAvailable() {
   });
   return result.exitCode === 0;
 }
-function escapePowerShellPath(path6) {
-  return path6.replace(/'/g, "''");
+function escapePowerShellPath(path5) {
+  return path5.replace(/'/g, "''");
 }
 function getWindowsZipExtractor() {
   const buildNumber = getWindowsBuildNumber();
@@ -2807,511 +1798,6 @@ function createPostReadNudgeHook() {
   };
 }
 
-// src/cli/custom-skills.ts
-import {
-  copyFileSync as copyFileSync2,
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync3,
-  readdirSync as readdirSync2,
-  rmSync as rmSync2,
-  statSync as statSync5
-} from "fs";
-import { dirname as dirname3, join as join7, parse } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-
-// src/harness/core/skills.ts
-var ORCHESTRATOR_ONLY = ["orchestrator"];
-var SHARED_SKILL_SUPPORT = {
-  name: "_shared",
-  description: "Shared OpenSpec, persistence, and thoth-mem SDD conventions",
-  allowedRoles: [
-    "orchestrator",
-    "explorer",
-    "librarian",
-    "oracle",
-    "designer",
-    "quick",
-    "deep"
-  ],
-  sourcePath: "src/skills/_shared",
-  kind: "shared-support",
-  purpose: "support"
-};
-var BUNDLED_SKILL_REGISTRY = [
-  {
-    name: "requirements-interview",
-    description: "Mandatory step-0 discovery interview to understand user intent, clarify scope, and choose the right path before implementation",
-    allowedRoles: ORCHESTRATOR_ONLY,
-    sourcePath: "src/skills/requirements-interview",
-    kind: "skill",
-    purpose: "requirements"
-  },
-  {
-    name: "thoth-mem-agents",
-    description: "Orchestrator/subagent thoth-mem workflow contract for parent session_id/project ownership, prompt-save prohibitions, and safe durable memory usage",
-    allowedRoles: [
-      "orchestrator",
-      "explorer",
-      "librarian",
-      "oracle",
-      "designer",
-      "quick",
-      "deep"
-    ],
-    sourcePath: "src/skills/thoth-mem-agents",
-    kind: "skill",
-    purpose: "memory"
-  },
-  {
-    name: "plan-reviewer",
-    description: "Review SDD task plans for execution blockers and valid references",
-    allowedRoles: ["orchestrator", "oracle"],
-    sourcePath: "src/skills/plan-reviewer",
-    kind: "skill",
-    purpose: "review"
-  },
-  {
-    name: "sdd-init",
-    description: "Initialize OpenSpec structure and SDD project context",
-    allowedRoles: ORCHESTRATOR_ONLY,
-    sourcePath: "src/skills/sdd-init",
-    kind: "skill",
-    purpose: "sdd"
-  },
-  {
-    name: "sdd-propose",
-    description: "Create change proposals for OpenSpec workflows",
-    allowedRoles: ORCHESTRATOR_ONLY,
-    sourcePath: "src/skills/sdd-propose",
-    kind: "skill",
-    purpose: "sdd"
-  },
-  {
-    name: "sdd-spec",
-    description: "Write OpenSpec delta specifications",
-    allowedRoles: ORCHESTRATOR_ONLY,
-    sourcePath: "src/skills/sdd-spec",
-    kind: "skill",
-    purpose: "sdd"
-  },
-  {
-    name: "sdd-design",
-    description: "Create technical design artifacts for changes",
-    allowedRoles: ORCHESTRATOR_ONLY,
-    sourcePath: "src/skills/sdd-design",
-    kind: "skill",
-    purpose: "sdd"
-  },
-  {
-    name: "sdd-tasks",
-    description: "Generate phased implementation task checklists",
-    allowedRoles: ORCHESTRATOR_ONLY,
-    sourcePath: "src/skills/sdd-tasks",
-    kind: "skill",
-    purpose: "sdd"
-  },
-  {
-    name: "sdd-apply",
-    description: "Execute tasks and persist implementation progress",
-    allowedRoles: ORCHESTRATOR_ONLY,
-    sourcePath: "src/skills/sdd-apply",
-    kind: "skill",
-    purpose: "sdd"
-  },
-  {
-    name: "executing-plans",
-    description: "Execute SDD task lists with real-time progress tracking, sub-agent dispatch, and verification checkpoints",
-    allowedRoles: ORCHESTRATOR_ONLY,
-    sourcePath: "src/skills/executing-plans",
-    kind: "skill",
-    purpose: "sdd"
-  },
-  {
-    name: "sdd-verify",
-    description: "Build verification reports and compliance matrices",
-    allowedRoles: ORCHESTRATOR_ONLY,
-    sourcePath: "src/skills/sdd-verify",
-    kind: "skill",
-    purpose: "sdd"
-  },
-  {
-    name: "sdd-archive",
-    description: "Archive completed OpenSpec changes with audit trails",
-    allowedRoles: ORCHESTRATOR_ONLY,
-    sourcePath: "src/skills/sdd-archive",
-    kind: "skill",
-    purpose: "sdd"
-  }
-];
-var SKILL_REGISTRY = [
-  ...BUNDLED_SKILL_REGISTRY,
-  SHARED_SKILL_SUPPORT
-];
-
-// src/cli/skill-manifest.ts
-import { createHash } from "crypto";
-import {
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync2,
-  readdirSync,
-  readFileSync as readFileSync5,
-  statSync as statSync4,
-  writeFileSync as writeFileSync4
-} from "fs";
-import { join as join6, relative } from "path";
-var SHARED_SKILL_DIRECTORY = "_shared";
-var SKILLS_SOURCE_ROOT = join6("src", "skills");
-var MANIFEST_FILE_NAME = ".skill-manifest.json";
-function getManifestPath() {
-  return join6(getCustomSkillsDir(), MANIFEST_FILE_NAME);
-}
-function listFilesRecursive(dirPath) {
-  if (!existsSync6(dirPath)) {
-    return [];
-  }
-  const files = [];
-  const entries = readdirSync(dirPath).sort(
-    (left, right) => left.localeCompare(right)
-  );
-  for (const entry of entries) {
-    const entryPath = join6(dirPath, entry);
-    const stat = statSync4(entryPath);
-    if (stat.isDirectory()) {
-      files.push(...listFilesRecursive(entryPath));
-      continue;
-    }
-    files.push(entryPath);
-  }
-  return files;
-}
-function readPackageVersion(packageRoot) {
-  const packageJsonPath = join6(packageRoot, "package.json");
-  const packageJson = JSON.parse(readFileSync5(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 (!existsSync6(manifestPath)) {
-    return null;
-  }
-  try {
-    return JSON.parse(readFileSync5(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 });
-  writeFileSync4(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(readFileSync5(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(
-    join6(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 = join6(packageRoot, skill.sourcePath);
-    const targetPath = join6(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 (!existsSync6(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 join7(getConfigDir(), "skills");
-}
-function copyDirRecursive(src, dest) {
-  if (!existsSync7(dest)) {
-    mkdirSync3(dest, { recursive: true });
-  }
-  const entries = readdirSync2(src);
-  for (const entry of entries) {
-    const srcPath = join7(src, entry);
-    const destPath = join7(dest, entry);
-    const stat = statSync5(srcPath);
-    if (stat.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      const destDir = dirname3(destPath);
-      if (!existsSync7(destDir)) {
-        mkdirSync3(destDir, { recursive: true });
-      }
-      copyFileSync2(srcPath, destPath);
-    }
-  }
-}
-function installSharedSkillAssets(packageRoot) {
-  const sharedSourcePath = join7(packageRoot, SHARED_SKILL_SOURCE_PATH);
-  const sharedTargetPath = join7(getCustomSkillsDir(), SHARED_SKILL_DIRECTORY2);
-  if (!existsSync7(sharedSourcePath)) {
-    console.error(`Custom skill shared assets not found: ${sharedSourcePath}`);
-    return false;
-  }
-  rmSync2(sharedTargetPath, { recursive: true, force: true });
-  copyDirRecursive(sharedSourcePath, sharedTargetPath);
-  return true;
-}
-function findPackageRoot(startDir) {
-  let currentDir = startDir;
-  const filesystemRoot = parse(startDir).root;
-  while (true) {
-    if (existsSync7(join7(currentDir, "package.json")) && existsSync7(join7(currentDir, "src", "skills"))) {
-      return currentDir;
-    }
-    if (currentDir === filesystemRoot) {
-      return null;
-    }
-    const parentDir = dirname3(currentDir);
-    if (parentDir === currentDir) {
-      return null;
-    }
-    currentDir = parentDir;
-  }
-}
-function resolvePackageRoot(packageRoot) {
-  if (packageRoot) {
-    return packageRoot;
-  }
-  const moduleDir = fileURLToPath2(new URL(".", import.meta.url));
-  return findPackageRoot(moduleDir) ?? fileURLToPath2(new URL("../..", import.meta.url));
-}
-function installCustomSkillFiles(skill, packageRoot) {
-  const sourcePath = join7(packageRoot, skill.sourcePath);
-  const targetPath = join7(getCustomSkillsDir(), skill.name);
-  if (!existsSync7(sourcePath)) {
-    console.error(`Custom skill source not found: ${sourcePath}`);
-    return false;
-  }
-  rmSync2(targetPath, { recursive: true, force: true });
-  copyDirRecursive(sourcePath, targetPath);
-  return true;
-}
-function removeObsoleteSkills(removedSkillNames) {
-  const removedSkills = [];
-  for (const skillName of removedSkillNames) {
-    const targetPath = join7(getCustomSkillsDir(), skillName);
-    try {
-      console.log(`Removing obsolete bundled skill: ${skillName}`);
-      rmSync2(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(join7(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/hooks/skill-sync.ts
 function formatSkillSyncSummary(report) {
   if (report.updatedSkills.length === 0 && report.removedSkills.length === 0 && report.failedSkills.length === 0) {
@@ -3477,12 +1963,12 @@ var HttpThothClient = class {
     });
     return response !== null;
   }
-  async httpPost(path6, body) {
+  async httpPost(path5, body) {
     if (!this.enabled) {
       return null;
     }
     try {
-      const response = await fetch(`${this.baseUrl}${path6}`, {
+      const response = await fetch(`${this.baseUrl}${path5}`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(body),
@@ -3494,18 +1980,18 @@ var HttpThothClient = class {
       return await response.json();
     } catch (error) {
       log("[thoth] HTTP POST unavailable", {
-        path: path6,
+        path: path5,
         error: error instanceof Error ? error.message : String(error)
       });
       return null;
     }
   }
-  async httpGet(path6) {
+  async httpGet(path5) {
     if (!this.enabled) {
       return null;
     }
     try {
-      const response = await fetch(`${this.baseUrl}${path6}`, {
+      const response = await fetch(`${this.baseUrl}${path5}`, {
         signal: AbortSignal.timeout(this.timeoutMs)
       });
       if (!response.ok) {
@@ -3514,7 +2000,7 @@ var HttpThothClient = class {
       return await response.json();
     } catch (error) {
       log("[thoth] HTTP GET unavailable", {
-        path: path6,
+        path: path5,
         error: error instanceof Error ? error.message : String(error)
       });
       return null;
@@ -3863,29 +2349,6 @@ function createThothMemHook(options) {
   };
 }
 
-// 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
-};
-
 // src/mcp/thoth.ts
 function createThothMcp(config) {
   const environment = {
@@ -3924,19 +2387,19 @@ function createBuiltinMcps(disabledMcps = [], thothConfig) {
 import { tool } from "@opencode-ai/plugin/tool";
 
 // src/tools/ast-grep/cli.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 
 // src/tools/ast-grep/constants.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync9, statSync as statSync6 } from "fs";
+import { existsSync as existsSync4, statSync as statSync2 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import { dirname as dirname4, join as join9 } from "path";
+import { dirname as dirname2, join as join5 } from "path";
 
 // src/tools/ast-grep/downloader.ts
-import { chmodSync, existsSync as existsSync8, mkdirSync as mkdirSync4, unlinkSync } from "fs";
+import { chmodSync, existsSync as existsSync3, mkdirSync, unlinkSync } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { homedir as homedir3 } from "os";
-import { join as join8 } from "path";
+import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
 
 // src/utils/file-io.ts
 import { readFile, writeFile } from "fs/promises";
@@ -3971,19 +2434,19 @@ var PLATFORM_MAP = {
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join8(homedir3(), "AppData", "Local");
-    return join8(base2, "thoth-agents", "bin");
+    const base2 = localAppData || join4(homedir2(), "AppData", "Local");
+    return join4(base2, "thoth-agents", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join8(homedir3(), ".cache");
-  return join8(base, "thoth-agents", "bin");
+  const base = xdgCache || join4(homedir2(), ".cache");
+  return join4(base, "thoth-agents", "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath() {
-  const binaryPath = join8(getCacheDir2(), getBinaryName());
-  return existsSync8(binaryPath) ? binaryPath : null;
+  const binaryPath = join4(getCacheDir2(), getBinaryName());
+  return existsSync3(binaryPath) ? binaryPath : null;
 }
 async function downloadAstGrep(version = DEFAULT_VERSION) {
   const platformKey = `${process.platform}-${process.arch}`;
@@ -3996,8 +2459,8 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir2();
   const binaryName = getBinaryName();
-  const binaryPath = join8(cacheDir, binaryName);
-  if (existsSync8(binaryPath)) {
+  const binaryPath = join4(cacheDir, binaryName);
+  if (existsSync3(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os2 } = platformInfo;
@@ -4005,21 +2468,21 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
   const downloadUrl = `https://github.com/${REPO}/releases/download/${version}/${assetName}`;
   console.log(`[thoth-agents] Downloading ast-grep binary...`);
   try {
-    if (!existsSync8(cacheDir)) {
-      mkdirSync4(cacheDir, { recursive: true });
+    if (!existsSync3(cacheDir)) {
+      mkdirSync(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join8(cacheDir, assetName);
+    const archivePath = join4(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await writeTextFile(archivePath, arrayBuffer);
     await extractZip(archivePath, cacheDir);
-    if (existsSync8(archivePath)) {
+    if (existsSync3(archivePath)) {
       unlinkSync(archivePath);
     }
-    if (process.platform !== "win32" && existsSync8(binaryPath)) {
+    if (process.platform !== "win32" && existsSync3(binaryPath)) {
       chmodSync(binaryPath, 493);
     }
     console.log(`[thoth-agents] ast-grep binary ready.`);
@@ -4073,7 +2536,7 @@ var CLI_LANGUAGES = [
 var MIN_BINARY_SIZE = 1e4;
 function isValidBinary(filePath) {
   try {
-    return statSync6(filePath).size > MIN_BINARY_SIZE;
+    return statSync2(filePath).size > MIN_BINARY_SIZE;
   } catch {
     return false;
   }
@@ -4102,9 +2565,9 @@ function findSgCliPathSync() {
   try {
     const require3 = createRequire3(import.meta.url);
     const cliPkgPath = require3.resolve("@ast-grep/cli/package.json");
-    const cliDir = dirname4(cliPkgPath);
-    const sgPath = join9(cliDir, binaryName);
-    if (existsSync9(sgPath) && isValidBinary(sgPath)) {
+    const cliDir = dirname2(cliPkgPath);
+    const sgPath = join5(cliDir, binaryName);
+    if (existsSync4(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {
@@ -4114,10 +2577,10 @@ function findSgCliPathSync() {
     try {
       const require3 = createRequire3(import.meta.url);
       const pkgPath = require3.resolve(`${platformPkg}/package.json`);
-      const pkgDir = dirname4(pkgPath);
+      const pkgDir = dirname2(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join9(pkgDir, astGrepName);
-      if (existsSync9(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join5(pkgDir, astGrepName);
+      if (existsSync4(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {
@@ -4125,9 +2588,9 @@ function findSgCliPathSync() {
   }
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
-    for (const path6 of homebrewPaths) {
-      if (existsSync9(path6) && isValidBinary(path6)) {
-        return path6;
+    for (const path5 of homebrewPaths) {
+      if (existsSync4(path5) && isValidBinary(path5)) {
+        return path5;
       }
     }
   }
@@ -4144,10 +2607,10 @@ function getSgCliPath() {
   }
   return "sg";
 }
-function setSgCliPath(path6) {
-  resolvedCliPath = path6;
+function setSgCliPath(path5) {
+  resolvedCliPath = path5;
 }
-var DEFAULT_TIMEOUT_MS2 = 3e5;
+var DEFAULT_TIMEOUT_MS = 3e5;
 var DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
 var DEFAULT_MAX_MATCHES = 500;
 
@@ -4155,7 +2618,7 @@ var DEFAULT_MAX_MATCHES = 500;
 var initPromise = null;
 async function getAstGrepPath() {
   const currentPath = getSgCliPath();
-  if (currentPath !== "sg" && existsSync10(currentPath)) {
+  if (currentPath !== "sg" && existsSync5(currentPath)) {
     return currentPath;
   }
   if (initPromise) {
@@ -4163,7 +2626,7 @@ async function getAstGrepPath() {
   }
   initPromise = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync10(syncPath)) {
+    if (syncPath && existsSync5(syncPath)) {
       setSgCliPath(syncPath);
       return syncPath;
     }
@@ -4202,13 +2665,13 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync10(cliPath) && cliPath !== "sg") {
+  if (!existsSync5(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
     }
   }
-  const timeout = DEFAULT_TIMEOUT_MS2;
+  const timeout = DEFAULT_TIMEOUT_MS;
   const proc = spawn([cliPath, ...args], {
     stdout: "pipe",
     stderr: "pipe"
@@ -4495,9 +2958,9 @@ var ast_grep_replace = tool({
 });
 
 // src/tools/lsp/client.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { extname, resolve as resolve2 } from "path";
-import { Readable as Readable2, Writable } from "stream";
+import { Readable, Writable } from "stream";
 import { pathToFileURL } from "url";
 import {
   createMessageConnection,
@@ -4506,9 +2969,9 @@ import {
 } from "vscode-jsonrpc/node";
 
 // src/tools/lsp/config.ts
-import { existsSync as existsSync12 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join10 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join6 } from "path";
 import whichSync from "which";
 
 // src/tools/lsp/config-store.ts
@@ -4539,8 +3002,8 @@ function hasUserLspConfig() {
 }
 
 // src/tools/lsp/constants.ts
-import { existsSync as existsSync11, readdirSync as readdirSync3, statSync as statSync7 } from "fs";
-import { dirname as dirname5, resolve } from "path";
+import { existsSync as existsSync6, readdirSync, statSync as statSync3 } from "fs";
+import { dirname as dirname3, resolve } from "path";
 var SEVERITY_MAP = {
   1: "error",
   2: "warning",
@@ -4559,18 +3022,18 @@ var LOCK_FILE_PATTERNS = [
 function* walkUpDirectories(start, stop) {
   let dir = resolve(start);
   try {
-    if (!statSync7(dir).isDirectory()) {
-      dir = dirname5(dir);
+    if (!statSync3(dir).isDirectory()) {
+      dir = dirname3(dir);
     }
   } catch {
-    dir = dirname5(dir);
+    dir = dirname3(dir);
   }
   let prevDir = "";
   while (dir !== prevDir && dir !== "/") {
     yield dir;
     prevDir = dir;
     if (dir === stop) break;
-    dir = dirname5(dir);
+    dir = dirname3(dir);
   }
 }
 function NearestRoot(includePatterns, excludePatterns) {
@@ -4579,7 +3042,7 @@ function NearestRoot(includePatterns, excludePatterns) {
     if (excludePatterns) {
       for (const dir of walkUpDirectories(file, cwd)) {
         for (const pattern of excludePatterns) {
-          if (existsSync11(`${dir}/${pattern}`)) {
+          if (existsSync6(`${dir}/${pattern}`)) {
             return void 0;
           }
         }
@@ -4589,7 +3052,7 @@ function NearestRoot(includePatterns, excludePatterns) {
       for (const pattern of includePatterns) {
         if (pattern.includes("*")) {
           try {
-            const entries = readdirSync3(dir);
+            const entries = readdirSync(dir);
             const regex = new RegExp(
               `^${pattern.replace(/\./g, "\\.").replace(/\*/g, ".*")}$`
             );
@@ -4598,7 +3061,7 @@ function NearestRoot(includePatterns, excludePatterns) {
             }
           } catch {
           }
-        } else if (existsSync11(`${dir}/${pattern}`)) {
+        } else if (existsSync6(`${dir}/${pattern}`)) {
           return dir;
         }
       }
@@ -5220,11 +3683,11 @@ function isServerInstalled(command) {
   if (command.length === 0) return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    return existsSync12(cmd);
+    return existsSync7(cmd);
   }
   const isWindows = process.platform === "win32";
   const ext = isWindows ? ".exe" : "";
-  const opencodeBin = join10(homedir4(), ".config", "opencode", "bin");
+  const opencodeBin = join6(homedir3(), ".config", "opencode", "bin");
   const searchPath = (process.env.PATH ?? "") + (isWindows ? ";" : ":") + opencodeBin;
   const result = whichSync.sync(cmd, {
     path: searchPath,
@@ -5235,8 +3698,8 @@ function isServerInstalled(command) {
     return true;
   }
   const cwd = process.cwd();
-  const localBin = join10(cwd, "node_modules", ".bin", cmd);
-  if (existsSync12(localBin) || existsSync12(localBin + ext)) {
+  const localBin = join6(cwd, "node_modules", ".bin", cmd);
+  if (existsSync7(localBin) || existsSync7(localBin + ext)) {
     return true;
   }
   return false;
@@ -5433,7 +3896,7 @@ var LSPClient = class {
     }
     this.startStderrReading();
     const stdoutReader = this.proc.stdout.getReader();
-    const nodeReadable = new Readable2({
+    const nodeReadable = new Readable({
       async read() {
         try {
           const { done, value } = await stdoutReader.read();
@@ -5576,7 +4039,7 @@ stderr: ${stderr}` : "")
       log("[lsp] openFile: already open, skipping", { filePath: absPath });
       return;
     }
-    const text = readFileSync6(absPath, "utf-8");
+    const text = readFileSync3(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     log("[lsp] openFile: opening document", {
@@ -5667,22 +4130,22 @@ import { tool as tool2 } from "@opencode-ai/plugin/tool";
 
 // src/tools/lsp/utils.ts
 import {
-  existsSync as existsSync13,
-  readFileSync as readFileSync7,
-  statSync as statSync8,
+  existsSync as existsSync8,
+  readFileSync as readFileSync4,
+  statSync as statSync4,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync3
 } from "fs";
-import { dirname as dirname6, extname as extname2, join as join11, resolve as resolve3 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname4, extname as extname2, join as join7, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 function findServerProjectRoot(filePath, server) {
   if (server.root) {
-    return server.root(filePath) ?? dirname6(resolve3(filePath));
+    return server.root(filePath) ?? dirname4(resolve3(filePath));
   }
-  return dirname6(resolve3(filePath));
+  return dirname4(resolve3(filePath));
 }
 function uriToPath(uri) {
-  return fileURLToPath3(uri);
+  return fileURLToPath2(uri);
 }
 function formatServerLookupError(result) {
   if (result.status === "not_installed") {
@@ -5708,7 +4171,7 @@ async function withLspClient(filePath, fn) {
     throw new Error(formatServerLookupError(result));
   }
   const server = result.server;
-  const root = findServerProjectRoot(absPath, server) ?? dirname6(absPath);
+  const root = findServerProjectRoot(absPath, server) ?? dirname4(absPath);
   log("[lsp] withLspClient: acquiring client", {
     filePath: absPath,
     server: server.id,
@@ -5779,7 +4242,7 @@ function filterDiagnosticsBySeverity(diagnostics, severityFilter) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    const content = readFileSync7(filePath, "utf-8");
+    const content = readFileSync4(filePath, "utf-8");
     const lines = content.split("\n");
     const sortedEdits = [...edits].sort((a, b) => {
       if (b.range.start.line !== a.range.start.line) {
@@ -5806,7 +4269,7 @@ function applyTextEditsToFile(filePath, edits) {
         );
       }
     }
-    writeFileSync5(filePath, lines.join("\n"), "utf-8");
+    writeFileSync3(filePath, lines.join("\n"), "utf-8");
     return { success: true, editCount: edits.length };
   } catch (err) {
     return {
@@ -5853,7 +4316,7 @@ function applyWorkspaceEdit(edit) {
         if (change.kind === "create") {
           try {
             const filePath = uriToPath(change.uri);
-            writeFileSync5(filePath, "", "utf-8");
+            writeFileSync3(filePath, "", "utf-8");
             result.filesModified.push(filePath);
           } catch (err) {
             result.success = false;
@@ -5863,8 +4326,8 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = uriToPath(change.oldUri);
             const newPath = uriToPath(change.newUri);
-            const content = readFileSync7(oldPath, "utf-8");
-            writeFileSync5(newPath, content, "utf-8");
+            const content = readFileSync4(oldPath, "utf-8");
+            writeFileSync3(newPath, content, "utf-8");
             unlinkSync2(oldPath);
             result.filesModified.push(newPath);
           } catch (err) {
@@ -6247,7 +4710,7 @@ var TmuxSessionManager = class {
 // src/index.ts
 function resolveProjectName(project, directory) {
   const runtimeProjectName = "name" in project && typeof project.name === "string" ? project.name : void 0;
-  return runtimeProjectName || path5.basename(directory) || "thoth-agents";
+  return runtimeProjectName || path4.basename(directory) || "thoth-agents";
 }
 var ThothAgents = async (ctx, _options) => {
   const { client, directory, project, $: shell } = ctx;