thoth-agents 0.10.0 → 0.12.0

package/dist/index.js

@@ -1,28 +1,107 @@
 import {
   formatGateVerdict,
   summarizeGateResult
-} from "./chunk-RWQPMWEM.js";
+} from "./chunk-JLU3FSBT.js";
 import {
   createAgents,
-  renderOpenCodeAgentConfigs,
-  spawn,
-  spawnSync
-} from "./chunk-RN2ERZLZ.js";
+  renderOpenCodeAgentConfigs
+} from "./chunk-QOA2AETX.js";
 import {
   context7,
   exa,
-  grep_app
-} from "./chunk-62L3ORXN.js";
+  grep_app,
+  spawn,
+  spawnSync
+} from "./chunk-MIDGZE34.js";
 import {
-  POLL_INTERVAL_BACKGROUND_MS,
-  getAgentRole,
-  getOpenCodeConfigPaths,
-  loadPluginConfig,
-  stripJsonComments
-} from "./chunk-RVQ6IIBR.js";
+  loadPluginConfig
+} from "./chunk-NY2IPJ7V.js";
 
-// src/index.ts
-import { fileURLToPath as fileURLToPath3 } from "url";
+// src/opencode/permission-rules.ts
+var ACTIONS = {
+  read: "read",
+  glob: "glob",
+  grep: "grep",
+  list: "read",
+  codesearch: "read",
+  lsp: "read",
+  edit: "edit",
+  write: "edit",
+  patch: "edit",
+  bash: "shell",
+  task: "subagent",
+  webfetch: "webfetch",
+  exa: "exa_*",
+  external_directory: "external_directory",
+  skill: "skill",
+  question: "question",
+  todowrite: "todowrite"
+};
+var RESTRICTION = { allow: 0, ask: 1, deny: 2 };
+function specificity(rule) {
+  return Number(rule.action !== "*") + 2 * Number(rule.resource !== "*");
+}
+function translatePermissionRules(permission) {
+  if (typeof permission === "string") {
+    return [{ action: "*", resource: "*", effect: permission }];
+  }
+  const rules = [];
+  for (const [key, value] of Object.entries(permission ?? {})) {
+    if (!value) continue;
+    const action = ACTIONS[key] ?? key;
+    const entries = typeof value === "string" ? [["*", value]] : Object.entries(value);
+    for (const [resource, effect] of entries) {
+      const existing = rules.find(
+        (rule) => rule.action === action && rule.resource === resource
+      );
+      if (!existing) rules.push({ action, resource, effect });
+      else if (RESTRICTION[effect] > RESTRICTION[existing.effect])
+        existing.effect = effect;
+    }
+  }
+  return [
+    { action: "*", resource: "*", effect: "ask" },
+    ...rules.sort((a, b) => specificity(a) - specificity(b))
+  ];
+}
+
+// src/opencode/agents.ts
+var ROLE_COLORS = {
+  orchestrator: "#7c3aed",
+  explorer: "#0ea5e9",
+  librarian: "#0284c7",
+  oracle: "#f59e0b",
+  designer: "#ec4899",
+  worker: "#10b981"
+};
+async function registerAgents(ctx, deps) {
+  await ctx.agent.transform((editor) => {
+    for (const { name } of deps.agentDefs) {
+      const config = deps.agents[name];
+      const first = deps.effectiveModelArrays[name]?.[0];
+      const model = first?.id ?? config.model;
+      const variant = first ? first.variant : config.variant;
+      editor.update(name, (agent) => {
+        agent.description = config.description;
+        agent.system = config.prompt;
+        agent.mode = name === "orchestrator" ? "primary" : "subagent";
+        agent.hidden = config.hidden ?? false;
+        agent.color = /^#[0-9a-f]{6}$/i.test(config.color ?? "") ? config.color : ROLE_COLORS[name];
+        agent.steps = config.steps;
+        agent.permissions = translatePermissionRules(config.permission);
+        const separator = model?.indexOf("/") ?? -1;
+        agent.model = model && separator > 0 && separator < model.length - 1 ? {
+          providerID: model.slice(0, separator),
+          id: model.slice(separator + 1),
+          ...variant ? { variant } : {}
+        } : void 0;
+      });
+    }
+    editor.default("orchestrator");
+    editor.remove("explore");
+    editor.remove("general");
+  });
+}
 
 // src/harness/opencode-init-command.ts
 import { existsSync, readFileSync } from "fs";
@@ -62,664 +141,160 @@ ${contract}`
   };
 }
 
-// src/utils/logger.ts
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-function getLogFile() {
-  const os2 = require2("node:os");
-  const path3 = require2("node:path");
-  const configuredPath = process.env.THOTH_AGENTS_LOG_FILE?.trim();
-  return configuredPath || path3.join(os2.tmpdir(), "thoth-agents.log");
-}
-function log(message, data) {
-  try {
-    const fs2 = require2("node:fs");
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const logEntry = `[${timestamp}] ${message} ${data ? JSON.stringify(data) : ""}
-`;
-    fs2.appendFileSync(getLogFile(), logEntry);
-  } catch {
-  }
-}
-
-// src/hooks/auto-update-checker/checker.ts
-import * as fs from "fs";
-import * as path2 from "path";
-import { fileURLToPath } from "url";
-
-// src/hooks/auto-update-checker/constants.ts
-import * as os from "os";
-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 path.join(process.env.LOCALAPPDATA ?? os.homedir(), "opencode");
-  }
-  return path.join(os.homedir(), ".cache", "opencode");
-}
-var CACHE_DIR = getCacheDir();
-var INSTALLED_PACKAGE_JSON = path.join(
-  CACHE_DIR,
-  "node_modules",
-  PACKAGE_NAME,
-  "package.json"
-);
-var configPaths = getOpenCodeConfigPaths();
-var USER_OPENCODE_CONFIG = configPaths[0];
-var USER_OPENCODE_CONFIG_JSONC = configPaths[1];
+// src/opencode/command.ts
+async function registerCommand(ctx, deps) {
+  const command = createOpenCodeInitCommand({
+    projectRoot: deps.directory,
+    packageRoot: deps.packageRoot
+  });
+  await ctx.command.transform((editor) => {
+    editor.add({
+      name: "thoth-init",
+      description: command.description,
+      async execute({ sessionID, prompt, delivery }) {
+        const args = prompt.text.trim();
+        const text = command.template + (args ? `
 
-// src/hooks/auto-update-checker/checker.ts
-function isPrereleaseVersion(version) {
-  return version.includes("-");
-}
-function isDistTag(version) {
-  return !/^\d/.test(version);
-}
-function extractChannel(version) {
-  if (!version) return "latest";
-  if (isDistTag(version)) return version;
-  if (isPrereleaseVersion(version)) {
-    const prereleasePart = version.split("-")[1];
-    if (prereleasePart) {
-      const channelMatch = prereleasePart.match(/^(alpha|beta|rc|canary|next)/);
-      if (channelMatch) return channelMatch[1];
-    }
-  }
-  return "latest";
-}
-function getConfigPaths(directory) {
-  return [
-    path2.join(directory, ".opencode", "opencode.json"),
-    path2.join(directory, ".opencode", "opencode.jsonc"),
-    USER_OPENCODE_CONFIG,
-    USER_OPENCODE_CONFIG_JSONC
-  ];
-}
-function getLocalDevPath(directory) {
-  for (const configPath of getConfigPaths(directory)) {
-    try {
-      if (!fs.existsSync(configPath)) continue;
-      const content = fs.readFileSync(configPath, "utf-8");
-      const config = JSON.parse(stripJsonComments(content));
-      const plugins = config.plugin ?? [];
-      for (const entry of plugins) {
-        if (entry.startsWith("file://") && entry.includes(PACKAGE_NAME)) {
-          try {
-            return fileURLToPath(entry);
-          } catch {
-            return entry.replace("file://", "");
-          }
-        }
+${args}` : "");
+        await ctx.session.switchAgent({ sessionID, agent: "orchestrator" });
+        await ctx.session.prompt({ sessionID, text, delivery });
       }
-    } catch {
-    }
-  }
-  return null;
-}
-function findPackageJsonUp(startPath) {
-  try {
-    const stat = fs.statSync(startPath);
-    let dir = stat.isDirectory() ? startPath : path2.dirname(startPath);
-    for (let i = 0; i < 10; i++) {
-      const pkgPath = path2.join(dir, "package.json");
-      if (fs.existsSync(pkgPath)) {
-        try {
-          const content = fs.readFileSync(pkgPath, "utf-8");
-          const pkg = JSON.parse(content);
-          if (pkg.name === PACKAGE_NAME) return pkgPath;
-        } catch {
-        }
-      }
-      const parent = path2.dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-  } catch {
-  }
-  return null;
-}
-function getLocalDevVersion(directory) {
-  const localPath = getLocalDevPath(directory);
-  if (!localPath) return null;
-  try {
-    const pkgPath = findPackageJsonUp(localPath);
-    if (!pkgPath) return null;
-    const content = fs.readFileSync(pkgPath, "utf-8");
-    const pkg = JSON.parse(content);
-    return pkg.version ?? null;
-  } catch {
-    return null;
-  }
-}
-function findPluginEntry(directory) {
-  for (const configPath of getConfigPaths(directory)) {
-    try {
-      if (!fs.existsSync(configPath)) continue;
-      const content = fs.readFileSync(configPath, "utf-8");
-      const config = JSON.parse(stripJsonComments(content));
-      const plugins = config.plugin ?? [];
-      for (const entry of plugins) {
-        if (entry === PACKAGE_NAME) {
-          return { entry, isPinned: false, pinnedVersion: null, configPath };
-        }
-        if (entry.startsWith(`${PACKAGE_NAME}@`)) {
-          const pinnedVersion = entry.slice(PACKAGE_NAME.length + 1);
-          const isPinned = pinnedVersion !== "latest";
-          return {
-            entry,
-            isPinned,
-            pinnedVersion: isPinned ? pinnedVersion : null,
-            configPath
-          };
-        }
-      }
-    } catch {
-    }
-  }
-  return null;
+    });
+  });
 }
-var cachedPackageVersion = null;
-function getCachedVersion() {
-  if (cachedPackageVersion) return cachedPackageVersion;
-  try {
-    if (fs.existsSync(INSTALLED_PACKAGE_JSON)) {
-      const content = fs.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
-      const pkg = JSON.parse(content);
-      if (pkg.version) {
-        cachedPackageVersion = pkg.version;
-        return pkg.version;
-      }
-    }
-  } catch {
+
+// src/opencode/context.ts
+import { fileURLToPath } from "url";
+function loadOpenCodeDependencies(ctx) {
+  const directory = ctx.location.directory;
+  const config = loadPluginConfig(directory);
+  const agentDefs = createAgents(config);
+  const agents = renderOpenCodeAgentConfigs(config);
+  const modelArrayMap = {};
+  const runtimeChains = {};
+  const effectiveModelArrays = {};
+  for (const agent of agentDefs) {
+    if (!agent._modelArray?.length) continue;
+    modelArrayMap[agent.name] = [...agent._modelArray];
+    effectiveModelArrays[agent.name] = [...agent._modelArray];
+    runtimeChains[agent.name] = agent._modelArray.map((model) => model.id);
   }
-  try {
-    const currentDir = path2.dirname(fileURLToPath(import.meta.url));
-    const pkgPath = findPackageJsonUp(currentDir);
-    if (pkgPath) {
-      const content = fs.readFileSync(pkgPath, "utf-8");
-      const pkg = JSON.parse(content);
-      if (pkg.version) {
-        cachedPackageVersion = pkg.version;
-        return pkg.version;
+  if (config.fallback?.enabled !== false) {
+    for (const [name, models] of Object.entries(
+      config.fallback?.chains ?? {}
+    )) {
+      if (!models?.length) continue;
+      const currentModel = agents[name]?.model;
+      const effective = effectiveModelArrays[name] ?? (currentModel ? [{ id: currentModel, variant: agents[name]?.variant }] : []);
+      for (const id of models) {
+        if (!effective.some((model) => model.id === id)) effective.push({ id });
       }
+      runtimeChains[name] = effective.map((model) => model.id);
+      effectiveModelArrays[name] = effective;
     }
-  } catch (err) {
-    log(
-      "[auto-update-checker] Failed to resolve version from current directory:",
-      err
-    );
-  }
-  return null;
-}
-async function getLatestVersion(channel = "latest") {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), NPM_FETCH_TIMEOUT);
-  try {
-    const response = await fetch(NPM_REGISTRY_URL, {
-      signal: controller.signal,
-      headers: { Accept: "application/json" }
-    });
-    if (!response.ok) return null;
-    const data = await response.json();
-    return data[channel] ?? data.latest ?? null;
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timeoutId);
   }
-}
-
-// src/hooks/auto-update-checker/index.ts
-function createAutoUpdateCheckerHook(ctx, options = {}) {
-  const { showStartupToast = true } = options;
-  let hasChecked = false;
   return {
-    event: ({ event }) => {
-      if (event.type !== "session.created") return;
-      if (hasChecked) return;
-      const props = event.properties;
-      if (props?.info?.parentID) return;
-      hasChecked = true;
-      setTimeout(async () => {
-        const cachedVersion = getCachedVersion();
-        const localDevVersion = getLocalDevVersion(ctx.directory);
-        const displayVersion = localDevVersion ?? cachedVersion;
-        if (localDevVersion) {
-          if (showStartupToast) {
-            showToast(
-              ctx,
-              `thoth-agents ${displayVersion} (dev)`,
-              "Running in local development mode.",
-              "info"
-            );
-          }
-          log("[auto-update-checker] Local development mode");
-          return;
-        }
-        if (showStartupToast) {
-          showToast(
-            ctx,
-            `thoth-agents ${displayVersion ?? "unknown"}`,
-            "thoth-agents is active.",
-            "info"
-          );
-        }
-        runBackgroundUpdateCheck(ctx).catch((err) => {
-          log("[auto-update-checker] Background update check failed:", err);
-        });
-      }, 0);
-    }
+    directory,
+    // Both src/opencode/context.ts and dist/index.js (or a root chunk) resolve
+    // the package root here; nested source modules need one extra parent.
+    packageRoot: fileURLToPath(
+      new URL(
+        import.meta.url.endsWith(".ts") ? "../.." : "..",
+        import.meta.url
+      )
+    ),
+    config,
+    agentDefs,
+    agents,
+    modelArrayMap,
+    effectiveModelArrays,
+    runtimeChains
   };
 }
-async function runBackgroundUpdateCheck(ctx) {
-  const pluginInfo = findPluginEntry(ctx.directory);
-  if (!pluginInfo) {
-    log("[auto-update-checker] Plugin not found in config");
-    return;
-  }
-  const cachedVersion = getCachedVersion();
-  const currentVersion = cachedVersion ?? pluginInfo.pinnedVersion;
-  if (!currentVersion) {
-    log("[auto-update-checker] No version found (cached or pinned)");
-    return;
-  }
-  const channel = extractChannel(pluginInfo.pinnedVersion ?? currentVersion);
-  const latestVersion = await getLatestVersion(channel);
-  if (!latestVersion) {
-    log(
-      "[auto-update-checker] Failed to fetch latest version for channel:",
-      channel
-    );
-    return;
-  }
-  if (currentVersion === latestVersion) {
-    log(
-      "[auto-update-checker] Already on latest version for channel:",
-      channel
-    );
-    return;
-  }
-  log(
-    `[auto-update-checker] Update available (${channel}): ${currentVersion} \u2192 ${latestVersion}`
-  );
-  showToast(
-    ctx,
-    `thoth-agents ${latestVersion} available`,
-    `v${currentVersion} \u2192 v${latestVersion}. Run npx thoth-agents@latest install --agent=opencode or use interactive CLI Update.`,
-    "info",
-    1e4
-  );
-  log("[auto-update-checker] Notification only; explicit CLI update required");
-}
-function showToast(ctx, title, message, variant = "info", duration = 3e3) {
-  ctx.client.tui.showToast({
-    body: { title, message, variant, duration }
-  }).catch(() => {
-  });
-}
 
 // src/hooks/delegate-task-retry/patterns.ts
 var DELEGATE_TASK_ERROR_PATTERNS = [
   {
-    pattern: "load_skills",
-    errorType: "missing_load_skills",
-    fixHint: "Add load_skills=[] (empty array when no skill is needed)."
-  },
-  {
-    pattern: "category OR subagent_type",
-    errorType: "mutual_exclusion",
-    fixHint: 'Provide only one: category (e.g., "unspecified-low") OR subagent_type (e.g., "explorer").'
-  },
-  {
-    pattern: "Must provide either category or subagent_type",
-    errorType: "missing_category_or_agent",
-    fixHint: 'Add either category="unspecified-low" or subagent_type="explorer".'
+    pattern: "Unknown agent:",
+    errorType: "unknown_agent",
+    fixHint: "Use an available agent name in the agent argument."
   },
   {
-    pattern: "Unknown category",
-    errorType: "unknown_category",
-    fixHint: "Use a valid category listed in the error output."
+    pattern: "cannot run as a subagent",
+    errorType: "primary_agent",
+    fixHint: "Choose a specialist agent, not a primary agent."
   },
   {
-    pattern: "Unknown agent",
-    errorType: "unknown_agent",
-    fixHint: "Use a valid agent name from the available list."
+    pattern: "Subagent depth limit reached",
+    errorType: "depth_limit",
+    fixHint: "Return to the root coordinator; nesting depth is 1. Do not retry nested delegation."
   },
   {
-    pattern: "Skills not found",
-    errorType: "unknown_skills",
-    fixHint: "Use valid skill names listed in the error output."
+    pattern: "Subagent denied:",
+    errorType: "permission_denied",
+    fixHint: "Return the permission blocker to the root coordinator; do not bypass the denial."
   },
   {
-    pattern: "is not allowed. Allowed agents:",
-    errorType: "background_agent_not_allowed",
-    fixHint: "Use one of the allowed agents shown in the error or delegate from a parent agent that can call this subagent."
+    pattern: "Invalid arguments",
+    errorType: "invalid_arguments",
+    fixHint: "Supply agent, description and prompt; optional model, sessionID and background must have the native types."
   }
 ];
 function detectDelegateTaskError(output) {
-  if (!output || typeof output !== "string") return null;
-  const hasErrorSignal = output.includes("[ERROR]") || output.includes("Invalid arguments") || output.includes("is not allowed. Allowed agents:");
-  if (!hasErrorSignal) return null;
-  for (const pattern of DELEGATE_TASK_ERROR_PATTERNS) {
-    if (output.includes(pattern.pattern)) {
-      return {
-        errorType: pattern.errorType,
-        originalOutput: output
-      };
-    }
-  }
-  return null;
+  const pattern = DELEGATE_TASK_ERROR_PATTERNS.find(
+    (entry) => output.includes(entry.pattern)
+  );
+  return pattern ? { errorType: pattern.errorType, originalOutput: output } : null;
 }
 
 // src/hooks/delegate-task-retry/guidance.ts
-function extractAvailableList(output) {
-  const match = output.match(/Allowed agents:\s*(.+)$/m);
-  if (match) return match[1].trim();
-  const available = output.match(/Available[^:]*:\s*(.+)$/m);
-  if (available) return available[1].trim();
-  return null;
-}
 function buildRetryGuidance(errorInfo) {
   const pattern = DELEGATE_TASK_ERROR_PATTERNS.find(
-    (p) => p.errorType === errorInfo.errorType
+    (entry) => entry.errorType === errorInfo.errorType
   );
-  if (!pattern) {
-    return "\n[delegate-task retry] Fix parameters and retry with corrected arguments.";
-  }
-  const available = extractAvailableList(errorInfo.originalOutput);
   const lines = [
-    "",
-    "[delegate-task retry suggestion]",
+    "[subagent retry suggestion]",
     `Error type: ${errorInfo.errorType}`,
-    `Fix: ${pattern.fixHint}`
+    `Fix: ${pattern?.fixHint ?? "Correct the native subagent arguments before retrying."}`
   ];
-  if (available) {
-    lines.push(`Available: ${available}`);
-  }
-  if (errorInfo.errorType === "background_agent_not_allowed") {
+  if (errorInfo.errorType !== "depth_limit" && errorInfo.errorType !== "permission_denied") {
     lines.push(
-      "Retry now with corrected parameters.",
-      "Use `background=true` only for `explorer` or `librarian`; otherwise retry without background.",
-      "If the host enables `OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true`, collect results with `task_status` before reporting completion.",
-      "Examples:",
-      'task(description="...", prompt="...", subagent_type="explorer", background=true)',
-      'task_status(task_id="ses_...", wait=true)'
+      'Example: subagent({agent:"explorer", description:"Locate entrypoint", prompt:"Find the bounded entrypoint"})',
+      "Use background:true for independent work; completion arrives automatically. Use sessionID to clarify or continue the same child, including while running. Do not poll."
     );
-    return lines.join("\n");
   }
-  lines.push(
-    "Retry now with corrected parameters. Example:",
-    'task(description="...", prompt="...", subagent_type="explorer")'
-  );
   return lines.join("\n");
 }
 
 // src/hooks/delegate-task-retry/hook.ts
-function createDelegateTaskRetryHook(_ctx) {
-  return {
-    "tool.execute.after": async (input, output) => {
-      const toolName = input.tool.toLowerCase();
-      const isDelegateTool = toolName === "task";
-      if (!isDelegateTool) return;
-      if (typeof output.output !== "string") return;
-      const detected = detectDelegateTaskError(output.output);
-      if (!detected) return;
-      output.output += `
-${buildRetryGuidance(detected)}`;
-    }
+function appendErrorGuidance(event, guidance) {
+  const properties = Object.getOwnPropertyDescriptors(event.error);
+  properties.message = {
+    value: `${event.error.message}
+${guidance}`,
+    configurable: true,
+    writable: true,
+    enumerable: true
+  };
+  properties.stack = {
+    value: event.error.stack,
+    configurable: true,
+    writable: true,
+    enumerable: false
+  };
+  event.error = Object.create(Object.getPrototypeOf(event.error), properties);
+}
+function createDelegateTaskRetryHook() {
+  return async (event) => {
+    if (event.tool !== "subagent" || event.status !== "error") return;
+    if (event.error.message.includes("[subagent retry suggestion]")) return;
+    const detected = detectDelegateTaskError(event.error.message);
+    if (!detected) return;
+    appendErrorGuidance(event, buildRetryGuidance(detected));
   };
 }
 
-// src/hooks/foreground-fallback/index.ts
-var RATE_LIMIT_PATTERNS = [
-  /\b429\b/,
-  /rate.?limit/i,
-  /too many requests/i,
-  /quota.?exceeded/i,
-  /usage.?exceeded/i,
-  /usage limit/i,
-  /overloaded/i,
-  /resource.?exhausted/i,
-  /insufficient.?quota/i,
-  /high concurrency/i,
-  /reduce concurrency/i
-];
-function isRateLimitError(error) {
-  if (!error || typeof error !== "object") return false;
-  const err = error;
-  const text = [
-    err.message ?? "",
-    String(err.data?.statusCode ?? ""),
-    err.data?.message ?? "",
-    err.data?.responseBody ?? ""
-  ].join(" ");
-  return RATE_LIMIT_PATTERNS.some((p) => p.test(text));
-}
-function parseModel(model) {
-  const slash = model.indexOf("/");
-  if (slash <= 0 || slash >= model.length - 1) return null;
-  return { providerID: model.slice(0, slash), modelID: model.slice(slash + 1) };
-}
-var DEDUP_WINDOW_MS = 5e3;
-var ForegroundFallbackManager = class {
-  constructor(client, chains, enabled) {
-    this.client = client;
-    this.chains = chains;
-    this.enabled = enabled;
-  }
-  client;
-  chains;
-  enabled;
-  /** sessionID → last observed model string ("providerID/modelID") */
-  sessionModel = /* @__PURE__ */ new Map();
-  /** sessionID → agent name (populated from message.updated info.agent field) */
-  sessionAgent = /* @__PURE__ */ new Map();
-  /** sessionID → set of models already attempted this session */
-  sessionTried = /* @__PURE__ */ new Map();
-  /** Sessions with an active fallback switch in flight */
-  inProgress = /* @__PURE__ */ new Set();
-  /** sessionID → timestamp of last trigger (for deduplication) */
-  lastTrigger = /* @__PURE__ */ new Map();
-  /**
-   * Process an OpenCode plugin event.
-   * Call this from the plugin's `event` hook for every event received.
-   */
-  async handleEvent(rawEvent) {
-    if (!this.enabled) return;
-    const event = rawEvent;
-    if (!event?.type) return;
-    switch (event.type) {
-      case "message.updated": {
-        const info = event.properties?.info;
-        if (!info) break;
-        const sessionID = info.sessionID;
-        if (!sessionID) break;
-        if (typeof info.agent === "string") {
-          this.sessionAgent.set(sessionID, info.agent);
-        }
-        if (typeof info.providerID === "string" && typeof info.modelID === "string") {
-          this.sessionModel.set(
-            sessionID,
-            `${info.providerID}/${info.modelID}`
-          );
-        }
-        if (info.error && isRateLimitError(info.error)) {
-          await this.tryFallback(sessionID);
-        }
-        break;
-      }
-      case "session.error": {
-        const props = event.properties;
-        if (props?.sessionID && props.error && isRateLimitError(props.error)) {
-          await this.tryFallback(props.sessionID);
-        }
-        break;
-      }
-      case "session.status": {
-        const props = event.properties;
-        if (!props?.sessionID || props.status?.type !== "retry") break;
-        const msg = props.status.message?.toLowerCase() ?? "";
-        if (msg.includes("rate limit") || msg.includes("usage limit") || msg.includes("usage exceeded") || msg.includes("quota exceeded") || msg.includes("high concurrency") || msg.includes("reduce concurrency")) {
-          await this.tryFallback(props.sessionID);
-        }
-        break;
-      }
-      case "subagent.session.created": {
-        const props = event.properties;
-        if (props?.sessionID && typeof props.agentName === "string") {
-          this.sessionAgent.set(props.sessionID, props.agentName);
-        }
-        break;
-      }
-      case "session.deleted": {
-        const props = event.properties;
-        const id = props?.info?.id ?? props?.sessionID;
-        if (id) {
-          this.sessionModel.delete(id);
-          this.sessionAgent.delete(id);
-          this.sessionTried.delete(id);
-          this.inProgress.delete(id);
-          this.lastTrigger.delete(id);
-        }
-        break;
-      }
-    }
-  }
-  getSessionModel(sessionId) {
-    return this.sessionModel.get(sessionId);
-  }
-  // ---------------------------------------------------------------------------
-  // Core fallback logic
-  // ---------------------------------------------------------------------------
-  async tryFallback(sessionID) {
-    if (!sessionID) return;
-    if (this.inProgress.has(sessionID)) return;
-    const now = Date.now();
-    if (now - (this.lastTrigger.get(sessionID) ?? 0) < DEDUP_WINDOW_MS) return;
-    this.lastTrigger.set(sessionID, now);
-    this.inProgress.add(sessionID);
-    try {
-      const currentModel = this.sessionModel.get(sessionID);
-      const agentName = this.sessionAgent.get(sessionID);
-      const chain = this.resolveChain(agentName, currentModel);
-      if (!chain.length) {
-        log("[foreground-fallback] no chain configured", {
-          sessionID,
-          agentName
-        });
-        return;
-      }
-      if (!this.sessionTried.has(sessionID)) {
-        this.sessionTried.set(sessionID, /* @__PURE__ */ new Set());
-      }
-      const tried = this.sessionTried.get(sessionID);
-      if (currentModel) tried.add(currentModel);
-      const nextModel = chain.find((m) => !tried.has(m));
-      if (!nextModel) {
-        log("[foreground-fallback] fallback chain exhausted", {
-          sessionID,
-          agentName,
-          tried: [...tried]
-        });
-        return;
-      }
-      tried.add(nextModel);
-      const ref = parseModel(nextModel);
-      if (!ref) {
-        log("[foreground-fallback] invalid model format", {
-          sessionID,
-          nextModel
-        });
-        return;
-      }
-      const result = await this.client.session.messages({
-        path: { id: sessionID }
-      });
-      const messages = result.data ?? [];
-      const lastUser = [...messages].reverse().find((m) => m.info.role === "user");
-      if (!lastUser) {
-        log("[foreground-fallback] no user message found", { sessionID });
-        return;
-      }
-      try {
-        await this.client.session.abort({ path: { id: sessionID } });
-      } catch {
-      }
-      await new Promise((r) => setTimeout(r, 500));
-      await this.client.session.promptAsync({
-        path: { id: sessionID },
-        body: {
-          // biome-ignore lint/suspicious/noExplicitAny: parts array from message history
-          parts: lastUser.parts,
-          model: ref
-        }
-      });
-      this.sessionModel.set(sessionID, nextModel);
-      log("[foreground-fallback] switched to fallback model", {
-        sessionID,
-        agentName,
-        from: currentModel,
-        to: nextModel
-      });
-    } catch (err) {
-      log("[foreground-fallback] fallback attempt failed", {
-        sessionID,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    } finally {
-      this.inProgress.delete(sessionID);
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // Chain resolution
-  // ---------------------------------------------------------------------------
-  /**
-   * Determine the fallback chain to use for a session.
-   *
-   * Priority:
-   * 1. Agent name known AND has a configured chain → return it directly
-   * 2. Agent name known but NO chain configured → return [] (no fallback;
-   *    do NOT bleed into other agents' chains which would re-prompt the
-   *    session with a model belonging to a completely different agent)
-   * 3. Agent name unknown, current model known → search all chains for
-   *    the model to infer which chain to use
-   * 4. Nothing matches → flatten all chains as a last resort (only
-   *    reached when both agent name and current model are unavailable)
-   */
-  resolveChain(agentName, currentModel) {
-    if (agentName) {
-      return this.chains[agentName] ?? [];
-    }
-    if (currentModel) {
-      for (const chain of Object.values(this.chains)) {
-        if (chain.includes(currentModel)) return chain;
-      }
-    }
-    const all = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const chain of Object.values(this.chains)) {
-      for (const m of chain) {
-        if (!seen.has(m)) {
-          seen.add(m);
-          all.push(m);
-        }
-      }
-    }
-    return all;
-  }
-};
-
 // src/hooks/json-error-recovery/hook.ts
-var JSON_ERROR_TOOL_EXCLUDE_LIST = [
-  "bash",
-  "read",
-  "glob",
-  "webfetch",
-  "grep_app_searchgithub",
-  "exa_web_search_exa"
-];
 var JSON_ERROR_PATTERNS = [
   /json parse error/i,
   /failed to parse json/i,
@@ -731,7 +306,6 @@ var JSON_ERROR_PATTERNS = [
   /json[^\n]*unexpected eof/i
 ];
 var JSON_ERROR_REMINDER_MARKER = "[JSON PARSE ERROR - IMMEDIATE ACTION REQUIRED]";
-var JSON_ERROR_EXCLUDED_TOOLS = new Set(JSON_ERROR_TOOL_EXCLUDE_LIST);
 var JSON_ERROR_REMINDER = `
 [JSON PARSE ERROR - IMMEDIATE ACTION REQUIRED]
 
@@ -744,56 +318,74 @@ STOP and do this NOW:
 
 DO NOT repeat the exact same invalid call.
 `;
-function createJsonErrorRecoveryHook(_ctx) {
-  return {
-    "tool.execute.after": async (input, output) => {
-      if (JSON_ERROR_EXCLUDED_TOOLS.has(input.tool.toLowerCase())) return;
-      if (typeof output.output !== "string") return;
-      if (output.output.includes(JSON_ERROR_REMINDER_MARKER)) return;
-      const outputText = output.output;
-      const hasJsonError = JSON_ERROR_PATTERNS.some(
-        (pattern) => pattern.test(outputText)
-      );
-      if (hasJsonError) {
-        output.output += `
-${JSON_ERROR_REMINDER}`;
-      }
-    }
+function createJsonErrorRecoveryHook() {
+  return async (event) => {
+    if (event.tool !== "subagent" || event.status !== "error") return;
+    const text = event.error.message;
+    if (text.includes(JSON_ERROR_REMINDER_MARKER)) return;
+    if (!JSON_ERROR_PATTERNS.some((pattern) => pattern.test(text))) return;
+    appendErrorGuidance(event, JSON_ERROR_REMINDER);
   };
 }
 
 // src/hooks/oracle-gate-verdict/hook.ts
-var ORACLE_AGENT = getAgentRole("oracle").name;
 function createOracleGateVerdictHook(ctx) {
-  return {
-    "tool.execute.after": async (input, output) => {
-      if (input.tool.toLowerCase() !== "task") return;
-      if (input.args?.subagent_type !== ORACLE_AGENT) return;
-      if (typeof output.output !== "string") return;
-      const text = output.output;
-      if (!text.includes("```thoth-result")) return;
-      const opening = "<task_result>";
-      const closing = "</task_result>";
-      const start = text.indexOf(opening);
-      const end = text.lastIndexOf(closing);
-      const wrapped = start !== -1 && end >= start + opening.length;
-      const child = wrapped ? text.slice(start + opening.length, end) : text;
-      const summary = {
-        ...summarizeGateResult(child, { cwd: ctx.directory }),
-        agent: ORACLE_AGENT
-      };
-      const verdict = formatGateVerdict(summary);
-      if (wrapped && text.slice(end + closing.length).endsWith(`
+  const delivered = /* @__PURE__ */ new WeakSet();
+  return async (event) => {
+    if (event.tool !== "subagent" || event.status !== "completed") return;
+    if (delivered.has(event.result)) return;
+    if (!event.input || typeof event.input !== "object" || !("agent" in event.input) || event.input.agent !== "oracle")
+      return;
+    const output = event.result.output;
+    if (!output || typeof output !== "object" || !("status" in output) || output.status !== "completed")
+      return;
+    const content = event.result.content;
+    if (content === void 0) return;
+    const text = typeof content === "string" ? content : content.filter((part) => part.type === "text").map((part) => part.text).join("");
+    const raw = "output" in output && typeof output.output === "string" && text.includes(output.output) ? output.output : void 0;
+    const message = raw ?? text;
+    if (!message.trim().split(/\r\n|\r|\n/).includes("```thoth-result"))
+      return;
+    const end = text.lastIndexOf("</subagent>");
+    const tail = end < 0 ? "" : text.slice(end + "</subagent>".length);
+    if (tail.split(/\r\n|\r|\n/).some((line) => line.startsWith("thoth-gate-verdict ")))
+      return;
+    if (Array.isArray(content) && content.some((part) => {
+      if (part.type !== "text") return false;
+      const lines = part.text.split(/\r\n|\r|\n/);
+      return lines.length === 3 && lines[0] === "" && lines[1] === "" && lines[2].startsWith("thoth-gate-verdict ");
+    }))
+      return;
+    const bare = raw === void 0 || !raw.trimStart().startsWith("<subagent ");
+    const summary = {
+      ...summarizeGateResult(bare ? message : "", { cwd: ctx.directory }),
+      agent: "oracle"
+    };
+    const verdict = formatGateVerdict(summary);
+    event.result = {
+      ...event.result,
+      content: typeof content === "string" ? `${content}
 
-${verdict}`))
-        return;
-      output.output += `
+${verdict}` : [...content, { type: "text", text: `
 
-${verdict}`;
-    }
+${verdict}` }]
+    };
+    delivered.add(event.result);
   };
 }
 
+// src/opencode/delegation-hooks.ts
+async function registerDelegationHooks(ctx, deps) {
+  const retry = createDelegateTaskRetryHook();
+  const recover = createJsonErrorRecoveryHook();
+  const verdict = createOracleGateVerdictHook({ directory: deps.directory });
+  await ctx.tool.hook("execute.after", async (event) => {
+    await retry(event);
+    await recover(event);
+    await verdict(event);
+  });
+}
+
 // src/mcp/index.ts
 function createAllBuiltinMcps() {
   return {
@@ -811,271 +403,427 @@ function createBuiltinMcps(disabledMcps = []) {
   );
 }
 
-// src/tools/ast-grep/tools.ts
-import { tool } from "@opencode-ai/plugin/tool";
-
-// src/tools/ast-grep/cli.ts
-import { existsSync as existsSync5 } from "fs";
+// src/opencode/mcp.ts
+async function registerMcp(ctx, deps) {
+  await ctx.mcp.transform((editor) => {
+    for (const [name, config] of Object.entries(
+      createBuiltinMcps(deps.config.disabled_mcps)
+    )) {
+      editor.set(name, config);
+    }
+  });
+}
 
-// src/tools/ast-grep/constants.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync4, statSync as statSync2 } from "fs";
-import { createRequire as createRequire3 } from "module";
-import { dirname as dirname2, join as join5 } from "path";
+// src/opencode/permissions.ts
+async function registerPermissions(ctx, deps) {
+  const specialists = new Set(
+    deps.agentDefs.map(({ name }) => name).filter((name) => name !== "orchestrator")
+  );
+  await ctx.permission.hook("evaluate", (event) => {
+    if (event.action !== "subagent" || !event.agent || !specialists.has(event.agent))
+      return;
+    event.effect = "deny";
+    event.message = `Thoth role "${event.agent}" cannot delegate: only orchestrator may call subagent.`;
+  });
+}
 
-// src/tools/ast-grep/downloader.ts
-import { chmodSync, existsSync as existsSync3, mkdirSync, unlinkSync } from "fs";
-import { createRequire as createRequire2 } from "module";
-import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
+// src/utils/logger.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function getLogFile() {
+  const os = require2("node:os");
+  const path = require2("node:path");
+  const configuredPath = process.env.THOTH_AGENTS_LOG_FILE?.trim();
+  return configuredPath || path.join(os.tmpdir(), "thoth-agents.log");
+}
+function log(message, data) {
+  try {
+    const fs = require2("node:fs");
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logEntry = `[${timestamp}] ${message} ${data ? JSON.stringify(data) : ""}
+`;
+    fs.appendFileSync(getLogFile(), logEntry);
+  } catch {
+  }
+}
 
-// src/utils/tmux.ts
-var tmuxPath = null;
-var tmuxChecked = false;
-var storedConfig = null;
-var serverAvailable = null;
-var serverCheckUrl = null;
-async function isServerRunning(serverUrl) {
-  if (serverCheckUrl === serverUrl && serverAvailable === true) {
-    return true;
+// src/hooks/foreground-fallback/index.ts
+var RETRYABLE = /* @__PURE__ */ new Set([
+  "provider.rate-limit",
+  "provider.quota",
+  "provider.free-limit",
+  "provider.chatgpt-limit",
+  "provider.go-limit",
+  "provider.budget-limit",
+  "provider.model-budget-limit",
+  "provider.transport",
+  "provider.timeout",
+  "provider.internal",
+  "provider.invalid-output"
+]);
+function isRateLimitError(error) {
+  if (!error || typeof error !== "object") return false;
+  const value = error;
+  return value.type !== void 0 && RETRYABLE.has(value.type);
+}
+function modelRef(value) {
+  const slash = value.indexOf("/");
+  if (slash <= 0 || slash === value.length - 1) return;
+  const [id, variant] = value.slice(slash + 1).split("#");
+  if (!id) return;
+  return {
+    providerID: value.slice(0, slash),
+    id,
+    ...variant ? { variant } : {}
+  };
+}
+var ForegroundFallbackManager = class {
+  constructor(session, chains, models = {}) {
+    this.session = session;
+    this.chains = chains;
+    this.models = models;
   }
-  const healthUrl = new URL("/health", serverUrl).toString();
-  const timeoutMs = 3e3;
-  const maxAttempts = 2;
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    let response = null;
+  session;
+  chains;
+  models;
+  tried = /* @__PURE__ */ new Map();
+  switching = /* @__PURE__ */ new Set();
+  forget(sessionID) {
+    this.tried.delete(sessionID);
+  }
+  async retry(input) {
+    if (!Object.hasOwn(this.chains, input.agent)) return;
+    const chain = this.chains[input.agent];
+    const current = `${input.model.providerID}/${input.model.id}`;
+    const inChain = chain.some((entry) => {
+      const ref = modelRef(entry);
+      return ref && `${ref.providerID}/${ref.id}` === current;
+    });
+    if (!inChain || !isRateLimitError(input.error)) return;
+    const lock = JSON.stringify([input.sessionID, input.agent]);
+    if (this.switching.has(lock)) return;
+    this.switching.add(lock);
     try {
-      response = await fetch(healthUrl, { signal: controller.signal }).catch(
-        () => null
-      );
+      let agents = this.tried.get(input.sessionID);
+      if (!agents) {
+        agents = /* @__PURE__ */ new Map();
+        this.tried.set(input.sessionID, agents);
+      }
+      let tried = agents.get(input.agent);
+      if (!tried) {
+        tried = /* @__PURE__ */ new Set();
+        agents.set(input.agent, tried);
+      }
+      tried.add(current);
+      for (const entry of chain) {
+        const ref = modelRef(entry);
+        if (!ref) continue;
+        const id = `${ref.providerID}/${ref.id}`;
+        if (tried.has(id)) continue;
+        tried.add(id);
+        const variant = this.models[input.agent]?.find(
+          (model) => model.id === entry
+        )?.variant;
+        await this.session.switchModel({
+          sessionID: input.sessionID,
+          model: {
+            ...ref,
+            ...variant ? { variant } : {}
+          }
+        });
+        input.decision = { retry: true, delay: 0 };
+        return;
+      }
+    } catch (error) {
+      log("[foreground-fallback] model switch failed", {
+        sessionID: input.sessionID,
+        error: String(error)
+      });
     } finally {
-      clearTimeout(timeout);
-    }
-    const available = response?.ok ?? false;
-    if (available) {
-      serverCheckUrl = serverUrl;
-      serverAvailable = true;
-      log("[tmux] isServerRunning: checked", { serverUrl, available, attempt });
-      return true;
-    }
-    if (attempt < maxAttempts) {
-      await new Promise((r) => setTimeout(r, 250));
+      this.switching.delete(lock);
     }
   }
-  log("[tmux] isServerRunning: checked", { serverUrl, available: false });
-  return false;
-}
-async function findTmuxPath() {
-  const isWindows = process.platform === "win32";
-  const cmd = isWindows ? "where" : "which";
-  try {
-    const proc = spawn([cmd, "tmux"], {
-      stdout: "pipe",
-      stderr: "pipe"
+};
+
+// src/opencode/session-state.ts
+import { readdir, readFile, stat } from "fs/promises";
+import { join as join2 } from "path";
+function missing(error) {
+  return error.code === "ENOENT";
+}
+var SessionState = class {
+  constructor(directory, instructions) {
+    this.directory = directory;
+    this.instructions = instructions;
+  }
+  directory;
+  instructions;
+  parents = /* @__PURE__ */ new Map();
+  running = /* @__PURE__ */ new Set();
+  published = /* @__PURE__ */ new Map();
+  records = /* @__PURE__ */ new Map();
+  queue = Promise.resolve();
+  serialize(run) {
+    const result = this.queue.then(run);
+    this.queue = result.catch(() => {
     });
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-      log("[tmux] findTmuxPath: 'which tmux' failed", { exitCode });
-      return null;
-    }
-    const stdout = await new Response(proc.stdout).text();
-    const path3 = stdout.trim().split("\n")[0];
-    if (!path3) {
-      log("[tmux] findTmuxPath: no path in output");
-      return null;
-    }
-    const verifyProc = spawn([path3, "-V"], {
-      stdout: "pipe",
-      stderr: "pipe"
+    return result;
+  }
+  refresh(sessionID) {
+    return this.serialize(() => this.publish(sessionID));
+  }
+  event(event) {
+    return this.serialize(async () => {
+      const { sessionID } = event.data;
+      if (event.type === "session.created") {
+        if (event.data.parentID) {
+          this.parents.set(sessionID, event.data.parentID);
+          this.running.add(sessionID);
+          await this.publish(event.data.parentID);
+        }
+        await this.publish(sessionID);
+        return;
+      }
+      const parent = this.parents.get(sessionID);
+      if (event.type === "session.status") {
+        if (event.data.status.type === "idle") this.running.delete(sessionID);
+        else if (parent) this.running.add(sessionID);
+        if (parent) await this.publish(parent);
+        if (this.published.has(sessionID)) await this.publish(sessionID);
+        return;
+      }
+      this.parents.delete(sessionID);
+      this.running.delete(sessionID);
+      this.published.delete(sessionID);
+      for (const [child, owner] of this.parents) {
+        if (owner !== sessionID) continue;
+        this.parents.delete(child);
+        this.running.delete(child);
+      }
+      if (parent) await this.publish(parent);
     });
-    const verifyExit = await verifyProc.exited;
-    if (verifyExit !== 0) {
-      log("[tmux] findTmuxPath: tmux -V failed", { path: path3, verifyExit });
-      return null;
-    }
-    log("[tmux] findTmuxPath: found tmux", { path: path3 });
-    return path3;
-  } catch (err) {
-    log("[tmux] findTmuxPath: exception", { error: String(err) });
-    return null;
   }
-}
-async function getTmuxPath() {
-  if (tmuxChecked) {
-    return tmuxPath;
+  async inventory() {
+    const root = join2(this.directory, ".thoth", "changes");
+    const entries = await readdir(root, { withFileTypes: true }).catch(
+      (error) => {
+        if (missing(error)) return [];
+        throw error;
+      }
+    );
+    const active = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name === "archive") continue;
+      const id = entry.name;
+      const path = join2(root, id, `${id}.md`);
+      try {
+        const info = await stat(path);
+        if (!info.isFile()) continue;
+        active.add(id);
+        const fingerprint = `${info.mtimeMs}:${info.ctimeMs}:${info.size}`;
+        if (this.records.get(id)?.fingerprint === fingerprint) continue;
+        const content = await readFile(path, "utf8");
+        const title = /^#\s+(.+)$/m.exec(content)?.[1]?.trim() ?? id;
+        const status = content.match(/^\*\*(?:Status|Phase)\*\*:\s*.+$/gm) ?? [];
+        this.records.set(id, {
+          fingerprint,
+          label: `${title}${status.length ? ` (${status.join("; ")})` : ""}`
+        });
+      } catch (error) {
+        if (!missing(error)) throw error;
+        active.delete(id);
+      }
+    }
+    for (const id of this.records.keys())
+      if (!active.has(id)) this.records.delete(id);
+    return [...this.records].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(
+      ([id, record]) => `- .thoth/changes/${id}/${id}.md \u2014 ${record.label}`
+    );
   }
-  tmuxPath = await findTmuxPath();
-  tmuxChecked = true;
-  log("[tmux] getTmuxPath: initialized", { tmuxPath });
-  return tmuxPath;
-}
-function isInsideTmux() {
-  return !!process.env.TMUX;
-}
-async function applyLayout(tmux, layout, mainPaneSize) {
-  try {
-    const layoutProc = spawn([tmux, "select-layout", layout], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    await layoutProc.exited;
-    if (layout === "main-horizontal" || layout === "main-vertical") {
-      const sizeOption = layout === "main-horizontal" ? "main-pane-height" : "main-pane-width";
-      const sizeProc = spawn(
-        [tmux, "set-window-option", sizeOption, `${mainPaneSize}%`],
-        {
-          stdout: "pipe",
-          stderr: "pipe"
-        }
-      );
-      await sizeProc.exited;
-      const reapplyProc = spawn([tmux, "select-layout", layout], {
-        stdout: "pipe",
-        stderr: "pipe"
+  async publish(sessionID) {
+    const records = await this.inventory();
+    const children = [...this.parents].filter(
+      ([child, parent]) => parent === sessionID && this.running.has(child)
+    ).map(([child]) => child).sort();
+    const value = [
+      "Thoth state",
+      "Active SDD records:",
+      ...records.length ? records : ["- none"],
+      "Running delegated sessions:",
+      ...children.length ? children.map((id) => `- ${id}`) : ["- none"]
+    ].join("\n");
+    if (this.published.get(sessionID) !== value) {
+      await this.instructions.entry.put({
+        sessionID,
+        key: "thoth.state",
+        value
       });
-      await reapplyProc.exited;
+      this.published.set(sessionID, value);
     }
-    log("[tmux] applyLayout: applied", { layout, mainPaneSize });
-  } catch (err) {
-    log("[tmux] applyLayout: exception", { error: String(err) });
+    return value;
   }
-}
-async function spawnTmuxPane(sessionId, description, config, serverUrl) {
-  log("[tmux] spawnTmuxPane called", {
-    sessionId,
-    description,
-    config,
-    serverUrl
+};
+
+// src/opencode/session-hooks.ts
+async function registerSessionHooks(ctx, deps) {
+  const names = new Set(deps.agentDefs.map((agent) => agent.name));
+  const chains = Object.fromEntries(
+    Object.entries(deps.runtimeChains).filter(([name]) => names.has(name))
+  );
+  const fallback = new ForegroundFallbackManager(
+    ctx.session,
+    chains,
+    deps.effectiveModelArrays
+  );
+  const state = new SessionState(deps.directory, ctx.session.instructions);
+  await ctx.session.hook("retry", (input) => fallback.retry(input));
+  await ctx.session.hook("prompt", async (input) => {
+    await state.refresh(input.sessionID);
   });
-  if (!config.enabled) {
-    log("[tmux] spawnTmuxPane: config.enabled is false, skipping");
-    return { success: false };
-  }
-  if (!isInsideTmux()) {
-    log("[tmux] spawnTmuxPane: not inside tmux, skipping");
-    return { success: false };
-  }
-  const serverRunning = await isServerRunning(serverUrl);
-  if (!serverRunning) {
-    const defaultPort = process.env.OPENCODE_PORT ?? "4096";
-    log("[tmux] spawnTmuxPane: OpenCode server not running, skipping", {
-      serverUrl,
-      hint: `Start opencode with --port ${defaultPort}`
-    });
-    return { success: false };
-  }
-  const tmux = await getTmuxPath();
-  if (!tmux) {
-    log("[tmux] spawnTmuxPane: tmux binary not found, skipping");
-    return { success: false };
-  }
-  storedConfig = config;
-  try {
-    const opencodeCmd = `opencode attach ${serverUrl} --session ${sessionId}`;
-    const args = [
-      "split-window",
-      "-h",
-      "-d",
-      // Don't switch focus to new pane
-      "-P",
-      // Print pane info
-      "-F",
-      "#{pane_id}",
-      // Format: just the pane ID
-      opencodeCmd
-    ];
-    log("[tmux] spawnTmuxPane: executing", { tmux, args, opencodeCmd });
-    const proc = spawn([tmux, ...args], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const exitCode = await proc.exited;
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    const paneId = stdout.trim();
-    log("[tmux] spawnTmuxPane: split result", {
-      exitCode,
-      paneId,
-      stderr: stderr.trim()
+  await ctx.session.hook("compaction", async (input) => {
+    const value = await state.refresh(input.sessionID);
+    if (input.result) {
+      input.result.summary += `
+
+${value}`;
+      return;
+    }
+    input.messages.push({
+      role: "user",
+      content: [
+        {
+          type: "text",
+          text: `Preserve this current Thoth state in the compaction summary:
+${value}`
+        }
+      ]
     });
-    if (exitCode === 0 && paneId) {
-      const renameProc = spawn(
-        [tmux, "select-pane", "-t", paneId, "-T", description.slice(0, 30)],
-        { stdout: "ignore", stderr: "ignore" }
+  });
+  const signal = new AbortController();
+  const events = ctx.event.subscribe({
+    types: ["session.created", "session.status", "session.deleted"],
+    signal: signal.signal
+  });
+  void (async () => {
+    try {
+      for await (const event of events) {
+        if (event.type === "session.deleted")
+          fallback.forget(event.data.sessionID);
+        try {
+          await state.event(event);
+        } catch (error) {
+          log("[session-state] update failed", { error: String(error) });
+        }
+      }
+    } catch (error) {
+      log("[session-state] subscription ended", { error: String(error) });
+    } finally {
+      signal.abort();
+    }
+  })();
+}
+
+// src/opencode/skills.ts
+import { readFile as readFile2 } from "fs/promises";
+import { resolve } from "path";
+import { parse } from "yaml";
+var ownedSkills = [
+  "thoth-init",
+  "thoth-sdd",
+  "thoth-constitution",
+  "thoth-archive",
+  "plan-reviewer"
+];
+async function registerSkills(ctx, deps) {
+  const skills = [];
+  for (const id of ownedSkills) {
+    const path = resolve(deps.packageRoot, "skills", id, "SKILL.md");
+    try {
+      const source = await readFile2(path, "utf8");
+      const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/.exec(
+        source
       );
-      await renameProc.exited;
-      const layout = config.layout ?? "main-vertical";
-      const mainPaneSize = config.main_pane_size ?? 60;
-      await applyLayout(tmux, layout, mainPaneSize);
-      log("[tmux] spawnTmuxPane: SUCCESS, pane created and layout applied", {
-        paneId,
-        layout
+      if (!match) throw new Error("Missing YAML frontmatter");
+      const metadata = parse(match[1]);
+      if (metadata?.name !== id || typeof metadata?.description !== "string" || !metadata.description.trim()) {
+        throw new Error(`Expected name ${id} and a non-empty description`);
+      }
+      skills.push({
+        id,
+        name: metadata.name,
+        description: metadata.description,
+        path,
+        content: match[2].trim()
       });
-      return { success: true, paneId };
+    } catch (cause) {
+      throw new Error(
+        `Cannot load bundled skill ${path}: ${cause instanceof Error ? cause.message : String(cause)}`,
+        { cause }
+      );
     }
-    return { success: false };
-  } catch (err) {
-    log("[tmux] spawnTmuxPane: exception", { error: String(err) });
-    return { success: false };
   }
+  await ctx.skill.transform((editor) => {
+    for (const skill of skills) {
+      if (editor.get(skill.id))
+        editor.update(skill.id, (existing) => {
+          Object.assign(existing, skill);
+        });
+      else editor.add(skill);
+    }
+  });
 }
-async function closeTmuxPane(paneId) {
-  log("[tmux] closeTmuxPane called", { paneId });
-  if (!paneId) {
-    log("[tmux] closeTmuxPane: no paneId provided");
-    return false;
-  }
-  const tmux = await getTmuxPath();
-  if (!tmux) {
-    log("[tmux] closeTmuxPane: tmux binary not found");
-    return false;
-  }
-  try {
-    log("[tmux] closeTmuxPane: sending Ctrl+C for graceful shutdown", {
-      paneId
-    });
-    const ctrlCProc = spawn([tmux, "send-keys", "-t", paneId, "C-c"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    await ctrlCProc.exited;
-    await new Promise((r) => setTimeout(r, 250));
-    log("[tmux] closeTmuxPane: killing pane", { paneId });
-    const proc = spawn([tmux, "kill-pane", "-t", paneId], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const exitCode = await proc.exited;
-    const stderr = await new Response(proc.stderr).text();
-    log("[tmux] closeTmuxPane: result", { exitCode, stderr: stderr.trim() });
-    if (exitCode === 0) {
-      log("[tmux] closeTmuxPane: SUCCESS, pane closed", { paneId });
-      if (storedConfig) {
-        const layout = storedConfig.layout ?? "main-vertical";
-        const mainPaneSize = storedConfig.main_pane_size ?? 60;
-        await applyLayout(tmux, layout, mainPaneSize);
-        log("[tmux] closeTmuxPane: layout reapplied", { layout });
+
+// src/tools/ast-grep/tools.ts
+import { z } from "zod";
+
+// src/tools/define-tool.ts
+function defineTool(definition) {
+  return {
+    name: definition.name,
+    description: definition.description,
+    input: definition.input,
+    async execute(input, context) {
+      context.signal.throwIfAborted();
+      let onAbort = () => {
+      };
+      const aborted = new Promise((_, reject) => {
+        onAbort = () => reject(context.signal.reason);
+        context.signal.addEventListener("abort", onAbort, { once: true });
+      });
+      try {
+        const content = await Promise.race([
+          definition.execute(input, context),
+          aborted
+        ]);
+        context.signal.throwIfAborted();
+        if (definition.showOutput) {
+          await context.progress({ output: content });
+          context.signal.throwIfAborted();
+          return { content, metadata: { output: content } };
+        }
+        return { content };
+      } finally {
+        context.signal.removeEventListener("abort", onAbort);
       }
-      return true;
     }
-    log("[tmux] closeTmuxPane: failed (pane may already be closed)", {
-      paneId
-    });
-    return false;
-  } catch (err) {
-    log("[tmux] closeTmuxPane: exception", { error: String(err) });
-    return false;
-  }
-}
-function startTmuxCheck() {
-  if (!tmuxChecked) {
-    getTmuxPath().catch(() => {
-    });
-  }
+  };
 }
 
+// src/tools/ast-grep/cli.ts
+import { existsSync as existsSync4 } from "fs";
+
+// src/tools/ast-grep/constants.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync3, statSync } from "fs";
+import { createRequire as createRequire3 } from "module";
+import { dirname, join as join4 } from "path";
+
+// src/tools/ast-grep/downloader.ts
+import { chmodSync, existsSync as existsSync2, mkdirSync, unlinkSync } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { homedir } from "os";
+import { join as join3 } from "path";
+
 // src/utils/zip-extractor.ts
 import { release } from "os";
 var WINDOWS_BUILD_WITH_TAR = 17134;
@@ -1097,8 +845,8 @@ function isPwshAvailable() {
   });
   return result.exitCode === 0;
 }
-function escapePowerShellPath(path3) {
-  return path3.replace(/'/g, "''");
+function escapePowerShellPath(path) {
+  return path.replace(/'/g, "''");
 }
 function getWindowsZipExtractor() {
   const buildNumber = getWindowsBuildNumber();
@@ -1166,7 +914,7 @@ async function extractZip(archivePath, destDir) {
 }
 
 // src/utils/file-io.ts
-import { readFile, writeFile } from "fs/promises";
+import { readFile as readFile3, writeFile } from "fs/promises";
 async function writeTextFile(filePath, contents) {
   await writeFile(
     filePath,
@@ -1195,22 +943,22 @@ var PLATFORM_MAP = {
   "win32-arm64": { arch: "aarch64", os: "pc-windows-msvc" },
   "win32-ia32": { arch: "i686", os: "pc-windows-msvc" }
 };
-function getCacheDir2() {
+function getCacheDir() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join4(homedir2(), "AppData", "Local");
-    return join4(base2, "thoth-agents", "bin");
+    const base2 = localAppData || join3(homedir(), "AppData", "Local");
+    return join3(base2, "thoth-agents", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join4(homedir2(), ".cache");
-  return join4(base, "thoth-agents", "bin");
+  const base = xdgCache || join3(homedir(), ".cache");
+  return join3(base, "thoth-agents", "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath() {
-  const binaryPath = join4(getCacheDir2(), getBinaryName());
-  return existsSync3(binaryPath) ? binaryPath : null;
+  const binaryPath = join3(getCacheDir(), getBinaryName());
+  return existsSync2(binaryPath) ? binaryPath : null;
 }
 async function downloadAstGrep(version = DEFAULT_VERSION) {
   const platformKey = `${process.platform}-${process.arch}`;
@@ -1221,32 +969,32 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
     );
     return null;
   }
-  const cacheDir = getCacheDir2();
+  const cacheDir = getCacheDir();
   const binaryName = getBinaryName();
-  const binaryPath = join4(cacheDir, binaryName);
-  if (existsSync3(binaryPath)) {
+  const binaryPath = join3(cacheDir, binaryName);
+  if (existsSync2(binaryPath)) {
     return binaryPath;
   }
-  const { arch, os: os2 } = platformInfo;
-  const assetName = `app-${arch}-${os2}.zip`;
+  const { arch, os } = platformInfo;
+  const assetName = `app-${arch}-${os}.zip`;
   const downloadUrl = `https://github.com/${REPO}/releases/download/${version}/${assetName}`;
   console.log(`[thoth-agents] Downloading ast-grep binary...`);
   try {
-    if (!existsSync3(cacheDir)) {
+    if (!existsSync2(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 = join4(cacheDir, assetName);
+    const archivePath = join3(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await writeTextFile(archivePath, arrayBuffer);
     await extractZip(archivePath, cacheDir);
-    if (existsSync3(archivePath)) {
+    if (existsSync2(archivePath)) {
       unlinkSync(archivePath);
     }
-    if (process.platform !== "win32" && existsSync3(binaryPath)) {
+    if (process.platform !== "win32" && existsSync2(binaryPath)) {
       chmodSync(binaryPath, 493);
     }
     console.log(`[thoth-agents] ast-grep binary ready.`);
@@ -1300,7 +1048,7 @@ var CLI_LANGUAGES = [
 var MIN_BINARY_SIZE = 1e4;
 function isValidBinary(filePath) {
   try {
-    return statSync2(filePath).size > MIN_BINARY_SIZE;
+    return statSync(filePath).size > MIN_BINARY_SIZE;
   } catch {
     return false;
   }
@@ -1329,9 +1077,9 @@ function findSgCliPathSync() {
   try {
     const require3 = createRequire3(import.meta.url);
     const cliPkgPath = require3.resolve("@ast-grep/cli/package.json");
-    const cliDir = dirname2(cliPkgPath);
-    const sgPath = join5(cliDir, binaryName);
-    if (existsSync4(sgPath) && isValidBinary(sgPath)) {
+    const cliDir = dirname(cliPkgPath);
+    const sgPath = join4(cliDir, binaryName);
+    if (existsSync3(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {
@@ -1341,10 +1089,10 @@ function findSgCliPathSync() {
     try {
       const require3 = createRequire3(import.meta.url);
       const pkgPath = require3.resolve(`${platformPkg}/package.json`);
-      const pkgDir = dirname2(pkgPath);
+      const pkgDir = dirname(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join5(pkgDir, astGrepName);
-      if (existsSync4(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join4(pkgDir, astGrepName);
+      if (existsSync3(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {
@@ -1352,9 +1100,9 @@ function findSgCliPathSync() {
   }
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
-    for (const path3 of homebrewPaths) {
-      if (existsSync4(path3) && isValidBinary(path3)) {
-        return path3;
+    for (const path of homebrewPaths) {
+      if (existsSync3(path) && isValidBinary(path)) {
+        return path;
       }
     }
   }
@@ -1371,8 +1119,8 @@ function getSgCliPath() {
   }
   return "sg";
 }
-function setSgCliPath(path3) {
-  resolvedCliPath = path3;
+function setSgCliPath(path) {
+  resolvedCliPath = path;
 }
 var DEFAULT_TIMEOUT_MS = 3e5;
 var DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
@@ -1382,7 +1130,7 @@ var DEFAULT_MAX_MATCHES = 500;
 var initPromise = null;
 async function getAstGrepPath() {
   const currentPath = getSgCliPath();
-  if (currentPath !== "sg" && existsSync5(currentPath)) {
+  if (currentPath !== "sg" && existsSync4(currentPath)) {
     return currentPath;
   }
   if (initPromise) {
@@ -1390,7 +1138,7 @@ async function getAstGrepPath() {
   }
   initPromise = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync5(syncPath)) {
+    if (syncPath && existsSync4(syncPath)) {
       setSgCliPath(syncPath);
       return syncPath;
     }
@@ -1404,6 +1152,7 @@ async function getAstGrepPath() {
   return initPromise;
 }
 async function runSg(options) {
+  options.signal?.throwIfAborted();
   const args = [
     "run",
     "-p",
@@ -1429,18 +1178,21 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync5(cliPath) && cliPath !== "sg") {
+  if (!existsSync4(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
     }
   }
+  options.signal?.throwIfAborted();
   const timeout = DEFAULT_TIMEOUT_MS;
   const proc = spawn([cliPath, ...args], {
     windowsHide: true,
     stdout: "pipe",
     stderr: "pipe"
   });
+  const onAbort = () => proc.kill();
+  options.signal?.addEventListener("abort", onAbort, { once: true });
   const timeoutPromise = new Promise((_, reject) => {
     const id = setTimeout(() => {
       proc.kill();
@@ -1459,6 +1211,7 @@ async function runSg(options) {
     stderr = await new Response(proc.stderr).text();
     exitCode = await proc.exited;
   } catch (e) {
+    options.signal?.throwIfAborted();
     const error = e;
     if (error.message?.includes("timeout")) {
       return {
@@ -1495,7 +1248,10 @@ Auto-download failed. Manual install options:
       truncated: false,
       error: `Failed to spawn ast-grep: ${error.message}`
     };
+  } finally {
+    options.signal?.removeEventListener("abort", onAbort);
   }
+  options.signal?.throwIfAborted();
   if (exitCode !== 0 && stdout.trim() === "") {
     if (stderr.includes("No files found")) {
       return { matches: [], totalMatches: 0, truncated: false };
@@ -1649,24 +1405,23 @@ function getEmptyResultHint(pattern, lang) {
 }
 
 // src/tools/ast-grep/tools.ts
-function showOutputToUser(context, output) {
-  const ctx = context;
-  ctx.metadata?.({ metadata: { output } });
-}
-var ast_grep_search = tool({
+var ast_grep_search = defineTool({
+  showOutput: true,
+  name: "ast_grep_search",
   description: "Search code patterns across filesystem using AST-aware matching. Supports 25 languages. Use meta-variables: $VAR (single node), $$$ (multiple nodes). IMPORTANT: Patterns must be complete AST nodes (valid code). For functions, include params and body: 'export async function $NAME($$$) { $$$ }' not 'export async function $NAME'. Examples: 'console.log($MSG)', 'def $FUNC($$$):', 'async function $NAME($$$)'",
-  args: {
-    pattern: tool.schema.string().describe(
+  input: z.object({
+    pattern: z.string().describe(
       "AST pattern with meta-variables ($VAR, $$$). Must be complete AST node."
     ),
-    lang: tool.schema.enum(CLI_LANGUAGES).describe("Target language"),
-    paths: tool.schema.array(tool.schema.string()).optional().describe("Paths to search (default: ['.'])"),
-    globs: tool.schema.array(tool.schema.string()).optional().describe("Include/exclude globs (prefix ! to exclude)"),
-    context: tool.schema.number().optional().describe("Context lines around match")
-  },
+    lang: z.enum(CLI_LANGUAGES).describe("Target language"),
+    paths: z.array(z.string()).optional().describe("Paths to search (default: ['.'])"),
+    globs: z.array(z.string()).optional().describe("Include/exclude globs (prefix ! to exclude)"),
+    context: z.number().optional().describe("Context lines around match")
+  }),
   execute: async (args, context) => {
     try {
       const result = await runSg({
+        signal: context.signal,
         pattern: args.pattern,
         lang: args.lang,
         paths: args.paths,
@@ -1682,28 +1437,28 @@ var ast_grep_search = tool({
 ${hint}`;
         }
       }
-      showOutputToUser(context, output);
       return output;
     } catch (e) {
-      const output = `Error: ${e instanceof Error ? e.message : String(e)}`;
-      showOutputToUser(context, output);
-      return output;
+      return `Error: ${e instanceof Error ? e.message : String(e)}`;
     }
   }
 });
-var ast_grep_replace = tool({
+var ast_grep_replace = defineTool({
+  showOutput: true,
+  name: "ast_grep_replace",
   description: "Replace code patterns across filesystem with AST-aware rewriting. Dry-run by default. Use meta-variables in rewrite to preserve matched content. Example: pattern='console.log($MSG)' rewrite='logger.info($MSG)'",
-  args: {
-    pattern: tool.schema.string().describe("AST pattern to match"),
-    rewrite: tool.schema.string().describe("Replacement pattern (can use $VAR from pattern)"),
-    lang: tool.schema.enum(CLI_LANGUAGES).describe("Target language"),
-    paths: tool.schema.array(tool.schema.string()).optional().describe("Paths to search"),
-    globs: tool.schema.array(tool.schema.string()).optional().describe("Include/exclude globs"),
-    dryRun: tool.schema.boolean().optional().describe("Preview changes without applying (default: true)")
-  },
+  input: z.object({
+    pattern: z.string().describe("AST pattern to match"),
+    rewrite: z.string().describe("Replacement pattern (can use $VAR from pattern)"),
+    lang: z.enum(CLI_LANGUAGES).describe("Target language"),
+    paths: z.array(z.string()).optional().describe("Paths to search"),
+    globs: z.array(z.string()).optional().describe("Include/exclude globs"),
+    dryRun: z.boolean().optional().describe("Preview changes without applying (default: true)")
+  }),
   execute: async (args, context) => {
     try {
       const result = await runSg({
+        signal: context.signal,
         pattern: args.pattern,
         rewrite: args.rewrite,
         lang: args.lang,
@@ -1711,20 +1466,16 @@ var ast_grep_replace = tool({
         globs: args.globs,
         updateAll: args.dryRun === false
       });
-      const output = formatReplaceResult(result, args.dryRun !== false);
-      showOutputToUser(context, output);
-      return output;
+      return formatReplaceResult(result, args.dryRun !== false);
     } catch (e) {
-      const output = `Error: ${e instanceof Error ? e.message : String(e)}`;
-      showOutputToUser(context, output);
-      return output;
+      return `Error: ${e instanceof Error ? e.message : String(e)}`;
     }
   }
 });
 
 // src/tools/lsp/client.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { extname, resolve as resolve2 } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { extname, resolve as resolve3 } from "path";
 import { Readable, Writable } from "stream";
 import { pathToFileURL } from "url";
 import {
@@ -1734,31 +1485,13 @@ import {
 } from "vscode-jsonrpc/node.js";
 
 // src/tools/lsp/config.ts
-import { existsSync as existsSync7 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join6 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join5 } from "path";
 import whichSync from "which";
 
 // src/tools/lsp/config-store.ts
 var userConfig = /* @__PURE__ */ new Map();
-function setUserLspConfig(config) {
-  userConfig.clear();
-  if (config) {
-    for (const [id, server] of Object.entries(config)) {
-      if (server && typeof server === "object") {
-        const s = server;
-        userConfig.set(id, {
-          id,
-          command: s.command,
-          extensions: s.extensions,
-          disabled: s.disabled,
-          env: s.env,
-          initialization: s.initialization
-        });
-      }
-    }
-  }
-}
 function getAllUserLspConfigs() {
   return new Map(userConfig);
 }
@@ -1767,8 +1500,8 @@ function hasUserLspConfig() {
 }
 
 // src/tools/lsp/constants.ts
-import { existsSync as existsSync6, readdirSync, statSync as statSync3 } from "fs";
-import { dirname as dirname3, resolve } from "path";
+import { existsSync as existsSync5, readdirSync, statSync as statSync2 } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
 var SEVERITY_MAP = {
   1: "error",
   2: "warning",
@@ -1785,20 +1518,20 @@ var LOCK_FILE_PATTERNS = [
   "bun.lock"
 ];
 function* walkUpDirectories(start, stop) {
-  let dir = resolve(start);
+  let dir = resolve2(start);
   try {
-    if (!statSync3(dir).isDirectory()) {
-      dir = dirname3(dir);
+    if (!statSync2(dir).isDirectory()) {
+      dir = dirname2(dir);
     }
   } catch {
-    dir = dirname3(dir);
+    dir = dirname2(dir);
   }
   let prevDir = "";
   while (dir !== prevDir && dir !== "/") {
     yield dir;
     prevDir = dir;
     if (dir === stop) break;
-    dir = dirname3(dir);
+    dir = dirname2(dir);
   }
 }
 function NearestRoot(includePatterns, excludePatterns) {
@@ -1807,7 +1540,7 @@ function NearestRoot(includePatterns, excludePatterns) {
     if (excludePatterns) {
       for (const dir of walkUpDirectories(file, cwd)) {
         for (const pattern of excludePatterns) {
-          if (existsSync6(`${dir}/${pattern}`)) {
+          if (existsSync5(`${dir}/${pattern}`)) {
             return void 0;
           }
         }
@@ -1826,7 +1559,7 @@ function NearestRoot(includePatterns, excludePatterns) {
             }
           } catch {
           }
-        } else if (existsSync6(`${dir}/${pattern}`)) {
+        } else if (existsSync5(`${dir}/${pattern}`)) {
           return dir;
         }
       }
@@ -2448,11 +2181,11 @@ function isServerInstalled(command) {
   if (command.length === 0) return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    return existsSync7(cmd);
+    return existsSync6(cmd);
   }
   const isWindows = process.platform === "win32";
   const ext = isWindows ? ".exe" : "";
-  const opencodeBin = join6(homedir3(), ".config", "opencode", "bin");
+  const opencodeBin = join5(homedir2(), ".config", "opencode", "bin");
   const searchPath = (process.env.PATH ?? "") + (isWindows ? ";" : ":") + opencodeBin;
   const result = whichSync.sync(cmd, {
     path: searchPath,
@@ -2463,8 +2196,8 @@ function isServerInstalled(command) {
     return true;
   }
   const cwd = process.cwd();
-  const localBin = join6(cwd, "node_modules", ".bin", cmd);
-  if (existsSync7(localBin) || existsSync7(localBin + ext)) {
+  const localBin = join5(cwd, "node_modules", ".bin", cmd);
+  if (existsSync6(localBin) || existsSync6(localBin + ext)) {
     return true;
   }
   return false;
@@ -2725,7 +2458,7 @@ var LSPClient = class {
       this.processExited = true;
     });
     this.connection.listen();
-    await new Promise((resolve4) => setTimeout(resolve4, 100));
+    await new Promise((resolve5) => setTimeout(resolve5, 100));
     if (this.proc.exitCode !== null) {
       const stderr = this.stderrBuffer.join("\n");
       log("[lsp] LSPClient.start: server exited immediately", {
@@ -2800,12 +2533,12 @@ stderr: ${stderr}` : "")
     log("[lsp] LSPClient.initialize: complete", { server: this.server.id });
   }
   async openFile(filePath) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     if (this.openedFiles.has(absPath)) {
       log("[lsp] openFile: already open, skipping", { filePath: absPath });
       return;
     }
-    const text = readFileSync3(absPath, "utf-8");
+    const text = readFileSync2(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     log("[lsp] openFile: opening document", {
@@ -2825,7 +2558,7 @@ stderr: ${stderr}` : "")
     await new Promise((r) => setTimeout(r, 1e3));
   }
   async definition(filePath, line, character) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     await this.openFile(absPath);
     return this.connection?.sendRequest("textDocument/definition", {
       textDocument: { uri: pathToFileURL(absPath).href },
@@ -2833,7 +2566,7 @@ stderr: ${stderr}` : "")
     });
   }
   async references(filePath, line, character, includeDeclaration = true) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     await this.openFile(absPath);
     return this.connection?.sendRequest("textDocument/references", {
       textDocument: { uri: pathToFileURL(absPath).href },
@@ -2842,7 +2575,7 @@ stderr: ${stderr}` : "")
     });
   }
   async diagnostics(filePath) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     const uri = pathToFileURL(absPath).href;
     await this.openFile(absPath);
     await new Promise((r) => setTimeout(r, 500));
@@ -2861,7 +2594,7 @@ stderr: ${stderr}` : "")
     return { items: this.diagnosticsStore.get(uri) ?? [] };
   }
   async rename(filePath, line, character, newName) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     await this.openFile(absPath);
     return this.connection?.sendRequest("textDocument/rename", {
       textDocument: { uri: pathToFileURL(absPath).href },
@@ -2892,23 +2625,23 @@ stderr: ${stderr}` : "")
 };
 
 // src/tools/lsp/tools.ts
-import { tool as tool2 } from "@opencode-ai/plugin/tool";
+import { z as z2 } from "zod";
 
 // src/tools/lsp/utils.ts
 import {
-  existsSync as existsSync8,
-  readFileSync as readFileSync4,
-  statSync as statSync4,
+  existsSync as existsSync7,
+  readFileSync as readFileSync3,
+  statSync as statSync3,
   unlinkSync as unlinkSync2,
   writeFileSync
 } from "fs";
-import { dirname as dirname4, extname as extname2, join as join7, resolve as resolve3 } from "path";
+import { dirname as dirname3, extname as extname2, join as join6, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function findServerProjectRoot(filePath, server) {
   if (server.root) {
-    return server.root(filePath) ?? dirname4(resolve3(filePath));
+    return server.root(filePath) ?? dirname3(resolve4(filePath));
   }
-  return dirname4(resolve3(filePath));
+  return dirname3(resolve4(filePath));
 }
 function uriToPath(uri) {
   return fileURLToPath2(uri);
@@ -2926,7 +2659,7 @@ function formatServerLookupError(result) {
   return `No LSP server configured for extension: ${result.extension}`;
 }
 async function withLspClient(filePath, fn) {
-  const absPath = resolve3(filePath);
+  const absPath = resolve4(filePath);
   const ext = extname2(absPath);
   const result = findServerForExtension(ext);
   if (result.status !== "found") {
@@ -2937,7 +2670,7 @@ async function withLspClient(filePath, fn) {
     throw new Error(formatServerLookupError(result));
   }
   const server = result.server;
-  const root = findServerProjectRoot(absPath, server) ?? dirname4(absPath);
+  const root = findServerProjectRoot(absPath, server) ?? dirname3(absPath);
   log("[lsp] withLspClient: acquiring client", {
     filePath: absPath,
     server: server.id,
@@ -3008,7 +2741,7 @@ function filterDiagnosticsBySeverity(diagnostics, severityFilter) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    const content = readFileSync4(filePath, "utf-8");
+    const content = readFileSync3(filePath, "utf-8");
     const lines = content.split("\n");
     const sortedEdits = [...edits].sort((a, b) => {
       if (b.range.start.line !== a.range.start.line) {
@@ -3092,7 +2825,7 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = uriToPath(change.oldUri);
             const newPath = uriToPath(change.newUri);
-            const content = readFileSync4(oldPath, "utf-8");
+            const content = readFileSync3(oldPath, "utf-8");
             writeFileSync(newPath, content, "utf-8");
             unlinkSync2(oldPath);
             result.filesModified.push(newPath);
@@ -3154,16 +2887,18 @@ function formatApplyResult(result) {
 
 // src/tools/lsp/tools.ts
 var formatError = (e) => `Error: ${e instanceof Error ? e.message : String(e)}`;
-var lsp_goto_definition = tool2({
+var lsp_goto_definition = defineTool({
+  name: "lsp_goto_definition",
   description: "Jump to symbol definition. Find WHERE something is defined.",
-  args: {
-    filePath: tool2.schema.string().describe("Absolute path to the file"),
-    line: tool2.schema.number().min(1).describe("1-based line number"),
-    character: tool2.schema.number().min(0).describe("0-based character offset")
-  },
-  execute: async (args) => {
+  input: z2.object({
+    filePath: z2.string().describe("Absolute path to the file"),
+    line: z2.number().min(1).describe("1-based line number"),
+    character: z2.number().min(0).describe("0-based character offset")
+  }),
+  execute: async (args, context) => {
     try {
       const result = await withLspClient(args.filePath, async (client) => {
+        context.signal.throwIfAborted();
         return await client.definition(
           args.filePath,
           args.line,
@@ -3183,17 +2918,19 @@ var lsp_goto_definition = tool2({
     }
   }
 });
-var lsp_find_references = tool2({
+var lsp_find_references = defineTool({
+  name: "lsp_find_references",
   description: "Find ALL usages/references of a symbol across the entire workspace.",
-  args: {
-    filePath: tool2.schema.string().describe("Absolute path to the file"),
-    line: tool2.schema.number().min(1).describe("1-based line number"),
-    character: tool2.schema.number().min(0).describe("0-based character offset"),
-    includeDeclaration: tool2.schema.boolean().optional().describe("Include the declaration itself")
-  },
-  execute: async (args) => {
+  input: z2.object({
+    filePath: z2.string().describe("Absolute path to the file"),
+    line: z2.number().min(1).describe("1-based line number"),
+    character: z2.number().min(0).describe("0-based character offset"),
+    includeDeclaration: z2.boolean().optional().describe("Include the declaration itself")
+  }),
+  execute: async (args, context) => {
     try {
       const result = await withLspClient(args.filePath, async (client) => {
+        context.signal.throwIfAborted();
         return await client.references(
           args.filePath,
           args.line,
@@ -3219,15 +2956,17 @@ var lsp_find_references = tool2({
     }
   }
 });
-var lsp_diagnostics = tool2({
+var lsp_diagnostics = defineTool({
+  name: "lsp_diagnostics",
   description: "Get errors, warnings, hints from language server BEFORE running build.",
-  args: {
-    filePath: tool2.schema.string().describe("Absolute path to the file"),
-    severity: tool2.schema.enum(["error", "warning", "information", "hint", "all"]).optional().describe("Filter by severity level")
-  },
-  execute: async (args) => {
+  input: z2.object({
+    filePath: z2.string().describe("Absolute path to the file"),
+    severity: z2.enum(["error", "warning", "information", "hint", "all"]).optional().describe("Filter by severity level")
+  }),
+  execute: async (args, context) => {
     try {
       const result = await withLspClient(args.filePath, async (client) => {
+        context.signal.throwIfAborted();
         return await client.diagnostics(args.filePath);
       });
       let diagnostics = [];
@@ -3257,17 +2996,19 @@ var lsp_diagnostics = tool2({
     }
   }
 });
-var lsp_rename = tool2({
+var lsp_rename = defineTool({
+  name: "lsp_rename",
   description: "Rename symbol across entire workspace. APPLIES changes to all files.",
-  args: {
-    filePath: tool2.schema.string().describe("Absolute path to the file"),
-    line: tool2.schema.number().min(1).describe("1-based line number"),
-    character: tool2.schema.number().min(0).describe("0-based character offset"),
-    newName: tool2.schema.string().describe("New symbol name")
-  },
-  execute: async (args) => {
+  input: z2.object({
+    filePath: z2.string().describe("Absolute path to the file"),
+    line: z2.number().min(1).describe("1-based line number"),
+    character: z2.number().min(0).describe("0-based character offset"),
+    newName: z2.string().describe("New symbol name")
+  }),
+  execute: async (args, context) => {
     try {
       const edit = await withLspClient(args.filePath, async (client) => {
+        context.signal.throwIfAborted();
         return await client.rename(
           args.filePath,
           args.line,
@@ -3275,6 +3016,7 @@ var lsp_rename = tool2({
           args.newName
         );
       });
+      context.signal.throwIfAborted();
       const result = applyWorkspaceEdit(edit);
       return formatApplyResult(result);
     } catch (e) {
@@ -3283,375 +3025,34 @@ var lsp_rename = tool2({
   }
 });
 
-// src/utils/tmux-session-manager.ts
-var SESSION_TIMEOUT_MS = 10 * 60 * 1e3;
-var SESSION_MISSING_GRACE_MS = POLL_INTERVAL_BACKGROUND_MS * 3;
-var TmuxSessionManager = class {
-  client;
-  tmuxConfig;
-  serverUrl;
-  sessions = /* @__PURE__ */ new Map();
-  pollInterval;
-  enabled = false;
-  constructor(ctx, tmuxConfig) {
-    this.client = ctx.client;
-    this.tmuxConfig = tmuxConfig;
-    const defaultPort = process.env.OPENCODE_PORT ?? "4096";
-    this.serverUrl = ctx.serverUrl?.toString() ?? `http://localhost:${defaultPort}`;
-    this.enabled = tmuxConfig.enabled && isInsideTmux();
-    log("[tmux-session-manager] initialized", {
-      enabled: this.enabled,
-      tmuxConfig: this.tmuxConfig,
-      serverUrl: this.serverUrl
-    });
-  }
-  /**
-   * Handle session.created events.
-   * Spawns a tmux pane for child sessions (those with parentID).
-   */
-  async onSessionCreated(event) {
-    if (!this.enabled) return;
-    if (event.type !== "session.created") return;
-    const info = event.properties?.info;
-    if (!info?.id || !info?.parentID) {
-      return;
-    }
-    const sessionId = info.id;
-    const parentId = info.parentID;
-    const title = info.title ?? "Subagent";
-    if (this.sessions.has(sessionId)) {
-      log("[tmux-session-manager] session already tracked", { sessionId });
-      return;
-    }
-    log("[tmux-session-manager] child session created, spawning pane", {
-      sessionId,
-      parentId,
-      title
-    });
-    const paneResult = await spawnTmuxPane(
-      sessionId,
-      title,
-      this.tmuxConfig,
-      this.serverUrl
-    ).catch((err) => {
-      log("[tmux-session-manager] failed to spawn pane", {
-        error: String(err)
-      });
-      return { success: false, paneId: void 0 };
-    });
-    if (paneResult.success && paneResult.paneId) {
-      const now = Date.now();
-      this.sessions.set(sessionId, {
-        sessionId,
-        paneId: paneResult.paneId,
-        parentId,
-        title,
-        createdAt: now,
-        lastSeenAt: now
-      });
-      log("[tmux-session-manager] pane spawned", {
-        sessionId,
-        paneId: paneResult.paneId
-      });
-      this.startPolling();
-    }
-  }
-  /**
-   * Handle session.status events for completion detection.
-   * Uses session.status instead of deprecated session.idle.
-   *
-   * When a session becomes idle (completed), close its pane.
-   */
-  async onSessionStatus(event) {
-    if (!this.enabled) return;
-    if (event.type !== "session.status") return;
-    const sessionId = event.properties?.sessionID;
-    if (!sessionId) return;
-    if (event.properties?.status?.type === "idle") {
-      await this.closeSession(sessionId);
-    }
-  }
-  /**
-   * Handle session.deleted events.
-   * When a session is deleted, close its tmux pane immediately.
-   */
-  async onSessionDeleted(event) {
-    if (!this.enabled) return;
-    if (event.type !== "session.deleted") return;
-    const sessionId = event.properties?.sessionID;
-    if (!sessionId) return;
-    log("[tmux-session-manager] session deleted, closing pane", {
-      sessionId
-    });
-    await this.closeSession(sessionId);
-  }
-  startPolling() {
-    if (this.pollInterval) return;
-    this.pollInterval = setInterval(
-      () => this.pollSessions(),
-      POLL_INTERVAL_BACKGROUND_MS
-    );
-    log("[tmux-session-manager] polling started");
-  }
-  stopPolling() {
-    if (this.pollInterval) {
-      clearInterval(this.pollInterval);
-      this.pollInterval = void 0;
-      log("[tmux-session-manager] polling stopped");
-    }
-  }
-  /**
-   * Poll sessions for status updates (fallback for reliability).
-   * Also handles timeout and missing session detection.
-   */
-  async pollSessions() {
-    if (this.sessions.size === 0) {
-      this.stopPolling();
-      return;
-    }
-    try {
-      const statusResult = await this.client.session.status();
-      const allStatuses = statusResult.data ?? {};
-      const now = Date.now();
-      const sessionsToClose = [];
-      for (const [sessionId, tracked] of this.sessions.entries()) {
-        const status = allStatuses[sessionId];
-        const isIdle = status?.type === "idle";
-        if (status) {
-          tracked.lastSeenAt = now;
-          tracked.missingSince = void 0;
-        } else if (!tracked.missingSince) {
-          tracked.missingSince = now;
-        }
-        const missingTooLong = !!tracked.missingSince && now - tracked.missingSince >= SESSION_MISSING_GRACE_MS;
-        const isTimedOut = now - tracked.createdAt > SESSION_TIMEOUT_MS;
-        if (isIdle || missingTooLong || isTimedOut) {
-          sessionsToClose.push(sessionId);
-        }
-      }
-      for (const sessionId of sessionsToClose) {
-        await this.closeSession(sessionId);
-      }
-    } catch (err) {
-      log("[tmux-session-manager] poll error", { error: String(err) });
-    }
-  }
-  async closeSession(sessionId) {
-    const tracked = this.sessions.get(sessionId);
-    if (!tracked) return;
-    log("[tmux-session-manager] closing session pane", {
-      sessionId,
-      paneId: tracked.paneId
-    });
-    await closeTmuxPane(tracked.paneId);
-    this.sessions.delete(sessionId);
-    if (this.sessions.size === 0) {
-      this.stopPolling();
-    }
-  }
-  /**
-   * Clean up all tracked sessions.
-   */
-  async cleanup() {
-    this.stopPolling();
-    if (this.sessions.size > 0) {
-      log("[tmux-session-manager] closing all panes", {
-        count: this.sessions.size
-      });
-      const closePromises = Array.from(this.sessions.values()).map(
-        (s) => closeTmuxPane(s.paneId).catch(
-          (err) => log("[tmux-session-manager] cleanup error for pane", {
-            paneId: s.paneId,
-            error: String(err)
-          })
-        )
-      );
-      await Promise.all(closePromises);
-      this.sessions.clear();
-    }
-    log("[tmux-session-manager] cleanup complete");
-  }
-};
+// src/opencode/tools.ts
+async function registerTools(ctx, _deps) {
+  await ctx.tool.transform((editor) => {
+    editor.add(lsp_goto_definition);
+    editor.add(lsp_find_references);
+    editor.add(lsp_diagnostics);
+    editor.add(lsp_rename);
+    editor.add(ast_grep_search);
+    editor.add(ast_grep_replace);
+  });
+}
 
 // src/index.ts
-var ThothAgents = async (ctx, _options) => {
-  const { client, directory } = ctx;
-  const config = loadPluginConfig(directory);
-  const agentDefs = createAgents(config);
-  const agents = renderOpenCodeAgentConfigs(config);
-  const packageRoot = fileURLToPath3(new URL("..", import.meta.url));
-  const thothInitCommand = createOpenCodeInitCommand({
-    projectRoot: directory,
-    packageRoot
-  });
-  const modelArrayMap = {};
-  for (const agentDef of agentDefs) {
-    if (agentDef._modelArray && agentDef._modelArray.length > 0) {
-      modelArrayMap[agentDef.name] = agentDef._modelArray;
-    }
-  }
-  const runtimeChains = {};
-  for (const agentDef of agentDefs) {
-    if (agentDef._modelArray?.length) {
-      runtimeChains[agentDef.name] = agentDef._modelArray.map((m) => m.id);
-    }
-  }
-  if (config.fallback?.enabled !== false) {
-    const chains = config.fallback?.chains ?? {};
-    for (const [agentName, chainModels] of Object.entries(chains)) {
-      if (!chainModels?.length) continue;
-      const existing = runtimeChains[agentName] ?? [];
-      const seen = new Set(existing);
-      for (const m of chainModels) {
-        if (!seen.has(m)) {
-          seen.add(m);
-          existing.push(m);
-        }
-      }
-      runtimeChains[agentName] = existing;
-    }
+var plugin = {
+  id: "thoth-agents",
+  async setup(ctx) {
+    const deps = loadOpenCodeDependencies(ctx);
+    await registerAgents(ctx, deps);
+    await registerTools(ctx, deps);
+    await registerMcp(ctx, deps);
+    await registerCommand(ctx, deps);
+    await registerSkills(ctx, deps);
+    await registerPermissions(ctx, deps);
+    await registerDelegationHooks(ctx, deps);
+    await registerSessionHooks(ctx, deps);
   }
-  const tmuxConfig = {
-    enabled: config.tmux?.enabled ?? false,
-    layout: config.tmux?.layout ?? "main-vertical",
-    main_pane_size: config.tmux?.main_pane_size ?? 60
-  };
-  log("[plugin] initialized with tmux config", {
-    tmuxConfig,
-    rawTmuxConfig: config.tmux,
-    directory
-  });
-  if (tmuxConfig.enabled) {
-    startTmuxCheck();
-  }
-  const mcps = createBuiltinMcps(config.disabled_mcps);
-  const tmuxSessionManager = new TmuxSessionManager(ctx, tmuxConfig);
-  const autoUpdateChecker = createAutoUpdateCheckerHook(ctx, {
-    showStartupToast: true
-  });
-  const delegateTaskRetryHook = createDelegateTaskRetryHook(ctx);
-  const jsonErrorRecoveryHook = createJsonErrorRecoveryHook(ctx);
-  const oracleGateVerdictHook = createOracleGateVerdictHook(ctx);
-  const foregroundFallback = new ForegroundFallbackManager(
-    client,
-    runtimeChains,
-    config.fallback?.enabled !== false && Object.keys(runtimeChains).length > 0
-  );
-  return {
-    name: "thoth-agents",
-    agent: agents,
-    tool: {
-      lsp_goto_definition,
-      lsp_find_references,
-      lsp_diagnostics,
-      lsp_rename,
-      ast_grep_search,
-      ast_grep_replace
-    },
-    mcp: mcps,
-    config: async (opencodeConfig) => {
-      const lspConfig = opencodeConfig.lsp;
-      setUserLspConfig(lspConfig);
-      const commands = opencodeConfig.command ?? {};
-      if (!commands["thoth-init"]) {
-        commands["thoth-init"] = thothInitCommand;
-      }
-      opencodeConfig.command = commands;
-      if (config.setDefaultAgent !== false && !opencodeConfig.default_agent) {
-        opencodeConfig.default_agent = "orchestrator";
-      }
-      if (!opencodeConfig.agent) {
-        opencodeConfig.agent = { ...agents };
-      } else {
-        for (const [name, pluginAgent] of Object.entries(agents)) {
-          const existing = opencodeConfig.agent[name];
-          if (existing) {
-            opencodeConfig.agent[name] = {
-              ...pluginAgent,
-              ...existing
-            };
-          } else {
-            opencodeConfig.agent[name] = {
-              ...pluginAgent
-            };
-          }
-        }
-      }
-      const configAgent = opencodeConfig.agent;
-      const fallbackChainsEnabled = config.fallback?.enabled !== false;
-      const fallbackChains = fallbackChainsEnabled ? config.fallback?.chains ?? {} : {};
-      const effectiveArrays = {};
-      for (const [agentName, models] of Object.entries(modelArrayMap)) {
-        effectiveArrays[agentName] = [...models];
-      }
-      for (const [agentName, chainModels] of Object.entries(fallbackChains)) {
-        if (!chainModels || chainModels.length === 0) continue;
-        if (!effectiveArrays[agentName]) {
-          const entry = configAgent[agentName];
-          const currentModel = typeof entry?.model === "string" ? entry.model : void 0;
-          effectiveArrays[agentName] = currentModel ? [{ id: currentModel }] : [];
-        }
-        const seen = new Set(effectiveArrays[agentName].map((m) => m.id));
-        for (const chainModel of chainModels) {
-          if (!seen.has(chainModel)) {
-            seen.add(chainModel);
-            effectiveArrays[agentName].push({ id: chainModel });
-          }
-        }
-      }
-      if (Object.keys(effectiveArrays).length > 0) {
-        for (const [agentName, modelArray] of Object.entries(effectiveArrays)) {
-          if (modelArray.length === 0) continue;
-          const chosen = modelArray[0];
-          const entry = configAgent[agentName];
-          if (entry) {
-            entry.model = chosen.id;
-            if (chosen.variant) {
-              entry.variant = chosen.variant;
-            }
-          }
-          log("[plugin] resolved model from array", {
-            agent: agentName,
-            model: chosen.id,
-            variant: chosen.variant
-          });
-        }
-      }
-      const configMcp = opencodeConfig.mcp;
-      if (!configMcp) {
-        opencodeConfig.mcp = { ...mcps };
-      } else {
-        Object.assign(configMcp, mcps);
-      }
-    },
-    event: async (input) => {
-      await foregroundFallback.handleEvent(input.event);
-      await autoUpdateChecker.event(input);
-      await tmuxSessionManager.onSessionCreated(
-        input.event
-      );
-      await tmuxSessionManager.onSessionStatus(
-        input.event
-      );
-      await tmuxSessionManager.onSessionDeleted(
-        input.event
-      );
-    },
-    // Post-tool hooks: delegation retry, JSON recovery, then Oracle gate verdicts.
-    "tool.execute.after": async (input, output) => {
-      await delegateTaskRetryHook["tool.execute.after"](
-        input,
-        output
-      );
-      await jsonErrorRecoveryHook["tool.execute.after"](
-        input,
-        output
-      );
-      await oracleGateVerdictHook["tool.execute.after"](input, output);
-    }
-  };
 };
-var src_default = ThothAgents;
+var src_default = plugin;
 export {
   src_default as default
 };