thoth-agents 0.2.11 → 0.3.1

package/dist/index.js

@@ -3,30 +3,66 @@ import {
   renderOpenCodeAgentConfigs,
   spawn,
   spawnSync
-} from "./chunk-6BNAV534.js";
+} from "./chunk-YUCGIJPP.js";
 import {
-  DEFAULT_THOTH_COMMAND,
   POLL_INTERVAL_BACKGROUND_MS,
   context7,
   exa,
   getOpenCodeConfigPaths,
   grep_app,
-  installCustomSkills,
   loadPluginConfig,
   stripJsonComments
-} from "./chunk-OZE7JVGS.js";
+} from "./chunk-XO74DXBZ.js";
 
 // src/index.ts
-import path4 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/harness/opencode-init-command.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function createOpenCodeInitCommand({
+  projectRoot,
+  packageRoot
+}) {
+  const skillPath = join(packageRoot, "skills", "thoth-init", "SKILL.md");
+  const scriptPath = join(
+    packageRoot,
+    "skills",
+    "thoth-init",
+    "scripts",
+    "init.mjs"
+  );
+  if (!existsSync(skillPath) || !existsSync(scriptPath)) {
+    throw new Error("The bundled thoth-init skill is incomplete.");
+  }
+  const contract = readFileSync(skillPath, "utf8");
+  return {
+    description: "Initialize thoth-agents project SDD governance",
+    agent: "orchestrator",
+    subtask: false,
+    template: `Initialize this project now using the bundled thoth-init skill.
+
+The operation must stay project-scoped, idempotent, and offline. Run:
+
+node "${scriptPath}" --project "${projectRoot}" --harness opencode --json
+
+Inspect the JSON result, report created and preserved files, and do not download
+skills or invoke the thoth-agents CLI.
+
+Bundled skill contract:
+
+${contract}`
+  };
+}
 
 // src/utils/logger.ts
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
 function getLogFile() {
   const os2 = require2("node:os");
-  const path5 = require2("node:path");
+  const path4 = require2("node:path");
   const configuredPath = process.env.THOTH_AGENTS_LOG_FILE?.trim();
-  return configuredPath || path5.join(os2.tmpdir(), "thoth-agents.log");
+  return configuredPath || path4.join(os2.tmpdir(), "thoth-agents.log");
 }
 function log(message, data) {
   try {
@@ -465,557 +501,154 @@ function showToast(ctx, title, message, variant = "info", duration = 3e3) {
   });
 }
 
-// src/utils/internal-initiator.ts
-var LITE_INTERNAL_INITIATOR_MARKER = "<!-- LITE_INTERNAL_INITIATOR -->";
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function hasInternalInitiatorMarker(part) {
-  if (!isRecord(part) || part.type !== "text") {
-    return false;
+// 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 category",
+    errorType: "unknown_category",
+    fixHint: "Use a valid category listed in the error output."
+  },
+  {
+    pattern: "Unknown agent",
+    errorType: "unknown_agent",
+    fixHint: "Use a valid agent name from the available list."
+  },
+  {
+    pattern: "Skills not found",
+    errorType: "unknown_skills",
+    fixHint: "Use valid skill names listed in the error output."
+  },
+  {
+    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."
   }
-  if (typeof part.text !== "string") {
-    return false;
+];
+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 part.text.includes(LITE_INTERNAL_INITIATOR_MARKER);
+  return null;
 }
 
-// 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/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
+  );
+  if (!pattern) {
+    return "\n[delegate-task retry] Fix parameters and retry with corrected arguments.";
   }
-  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;
-    try {
-      response = await fetch(healthUrl, { signal: controller.signal }).catch(
-        () => null
-      );
-    } 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));
-    }
+  const available = extractAvailableList(errorInfo.originalOutput);
+  const lines = [
+    "",
+    "[delegate-task retry suggestion]",
+    `Error type: ${errorInfo.errorType}`,
+    `Fix: ${pattern.fixHint}`
+  ];
+  if (available) {
+    lines.push(`Available: ${available}`);
   }
-  log("[tmux] isServerRunning: checked", { serverUrl, available: false });
-  return false;
+  if (errorInfo.errorType === "background_agent_not_allowed") {
+    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)'
+    );
+    return lines.join("\n");
+  }
+  lines.push(
+    "Retry now with corrected parameters. Example:",
+    'task(description="...", prompt="...", subagent_type="explorer")'
+  );
+  return lines.join("\n");
 }
-async function findTmuxPath() {
-  const isWindows = process.platform === "win32";
-  const cmd = isWindows ? "where" : "which";
-  try {
-    const proc = spawn([cmd, "tmux"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    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 path5 = stdout.trim().split("\n")[0];
-    if (!path5) {
-      log("[tmux] findTmuxPath: no path in output");
-      return null;
-    }
-    const verifyProc = spawn([path5, "-V"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const verifyExit = await verifyProc.exited;
-    if (verifyExit !== 0) {
-      log("[tmux] findTmuxPath: tmux -V failed", { path: path5, verifyExit });
-      return null;
+
+// 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)}`;
     }
-    log("[tmux] findTmuxPath: found tmux", { path: path5 });
-    return path5;
-  } catch (err) {
-    log("[tmux] findTmuxPath: exception", { error: String(err) });
-    return null;
-  }
+  };
 }
-async function getTmuxPath() {
-  if (tmuxChecked) {
-    return tmuxPath;
-  }
-  tmuxPath = await findTmuxPath();
-  tmuxChecked = true;
-  log("[tmux] getTmuxPath: initialized", { tmuxPath });
-  return tmuxPath;
+
+// 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 isInsideTmux() {
-  return !!process.env.TMUX;
+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) };
 }
-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"
-      });
-      await reapplyProc.exited;
-    }
-    log("[tmux] applyLayout: applied", { layout, mainPaneSize });
-  } catch (err) {
-    log("[tmux] applyLayout: exception", { error: String(err) });
-  }
-}
-async function spawnTmuxPane(sessionId, description, config, serverUrl) {
-  log("[tmux] spawnTmuxPane called", {
-    sessionId,
-    description,
-    config,
-    serverUrl
-  });
-  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()
-    });
-    if (exitCode === 0 && paneId) {
-      const renameProc = spawn(
-        [tmux, "select-pane", "-t", paneId, "-T", description.slice(0, 30)],
-        { stdout: "ignore", stderr: "ignore" }
-      );
-      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
-      });
-      return { success: true, paneId };
-    }
-    return { success: false };
-  } catch (err) {
-    log("[tmux] spawnTmuxPane: exception", { error: String(err) });
-    return { success: false };
-  }
-}
-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 });
-      }
-      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/utils/zip-extractor.ts
-import { release } from "os";
-var WINDOWS_BUILD_WITH_TAR = 17134;
-function getWindowsBuildNumber() {
-  if (process.platform !== "win32") return null;
-  const parts = release().split(".");
-  if (parts.length >= 3) {
-    const build = parseInt(parts[2], 10);
-    if (!Number.isNaN(build)) return build;
-  }
-  return null;
-}
-function isPwshAvailable() {
-  if (process.platform !== "win32") return false;
-  const result = spawnSync(["where", "pwsh"], {
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  return result.exitCode === 0;
-}
-function escapePowerShellPath(path5) {
-  return path5.replace(/'/g, "''");
-}
-function getWindowsZipExtractor() {
-  const buildNumber = getWindowsBuildNumber();
-  if (buildNumber !== null && buildNumber >= WINDOWS_BUILD_WITH_TAR) {
-    return "tar";
-  }
-  if (isPwshAvailable()) {
-    return "pwsh";
-  }
-  return "powershell";
-}
-async function extractZip(archivePath, destDir) {
-  let proc;
-  if (process.platform === "win32") {
-    const extractor = getWindowsZipExtractor();
-    switch (extractor) {
-      case "tar":
-        proc = spawn(["tar", "-xf", archivePath, "-C", destDir], {
-          stdout: "ignore",
-          stderr: "pipe"
-        });
-        break;
-      case "pwsh":
-        proc = spawn(
-          [
-            "pwsh",
-            "-Command",
-            `Expand-Archive -Path '${escapePowerShellPath(archivePath)}' -DestinationPath '${escapePowerShellPath(destDir)}' -Force`
-          ],
-          {
-            stdout: "ignore",
-            stderr: "pipe"
-          }
-        );
-        break;
-      default:
-        proc = spawn(
-          [
-            "powershell",
-            "-Command",
-            `Expand-Archive -Path '${escapePowerShellPath(archivePath)}' -DestinationPath '${escapePowerShellPath(destDir)}' -Force`
-          ],
-          {
-            stdout: "ignore",
-            stderr: "pipe"
-          }
-        );
-        break;
-    }
-  } else {
-    proc = spawn(["unzip", "-o", archivePath, "-d", destDir], {
-      stdout: "ignore",
-      stderr: "pipe"
-    });
-  }
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    const stderr = await new Response(proc.stderr).text();
-    throw new Error(`zip extraction failed (exit ${exitCode}): ${stderr}`);
-  }
-}
-
-// src/hooks/chat-headers.ts
-var INTERNAL_MARKER_CACHE_LIMIT = 1e3;
-var internalMarkerCache = /* @__PURE__ */ new Map();
-function getProviderID(input) {
-  return input.provider.info?.id || input.model.providerID;
-}
-function isCopilotProvider(providerID) {
-  return providerID === "github-copilot" || providerID === "github-copilot-enterprise";
-}
-async function hasInternalMarker(client, sessionID, messageID) {
-  const cacheKey = `${sessionID}:${messageID}`;
-  const cached = internalMarkerCache.get(cacheKey);
-  if (cached !== void 0) {
-    return cached;
-  }
-  try {
-    const response = await client.session.message({
-      path: { id: sessionID, messageID }
-    });
-    const hasMarker = (response.data?.parts ?? []).some(
-      hasInternalInitiatorMarker
-    );
-    if (hasMarker) {
-      if (internalMarkerCache.size >= INTERNAL_MARKER_CACHE_LIMIT) {
-        internalMarkerCache.clear();
-      }
-      internalMarkerCache.set(cacheKey, true);
-    }
-    return hasMarker;
-  } catch {
-    return false;
-  }
-}
-function createChatHeadersHook(ctx) {
-  return {
-    "chat.headers": async (input, output) => {
-      if (!isCopilotProvider(getProviderID(input))) {
-        return;
-      }
-      if (input.model.api.npm === "@ai-sdk/github-copilot") {
-        return;
-      }
-      if (!input.message.id || input.message.role !== "user") {
-        return;
-      }
-      if (!await hasInternalMarker(
-        ctx.client,
-        input.sessionID,
-        input.message.id
-      )) {
-        return;
-      }
-      output.headers["x-initiator"] = "agent";
-    }
-  };
-}
-
-// 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 category",
-    errorType: "unknown_category",
-    fixHint: "Use a valid category listed in the error output."
-  },
-  {
-    pattern: "Unknown agent",
-    errorType: "unknown_agent",
-    fixHint: "Use a valid agent name from the available list."
-  },
-  {
-    pattern: "Skills not found",
-    errorType: "unknown_skills",
-    fixHint: "Use valid skill names listed in the error output."
-  },
-  {
-    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."
-  }
-];
-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;
-}
-
-// 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
-  );
-  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]",
-    `Error type: ${errorInfo.errorType}`,
-    `Fix: ${pattern.fixHint}`
-  ];
-  if (available) {
-    lines.push(`Available: ${available}`);
-  }
-  if (errorInfo.errorType === "background_agent_not_allowed") {
-    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)'
-    );
-    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)}`;
-    }
-  };
-}
-
-// 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;
+var DEDUP_WINDOW_MS = 5e3;
+var ForegroundFallbackManager = class {
+  constructor(client, chains, enabled) {
+    this.client = client;
+    this.chains = chains;
+    this.enabled = enabled;
   }
   client;
   chains;
@@ -1259,690 +892,383 @@ function createJsonErrorRecoveryHook(_ctx) {
       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}`;
-      }
-    }
-  };
-}
-
-// src/hooks/phase-reminder/index.ts
-var PHASE_REMINDER = `<reminder>Recall Workflow Rules:
-Understand \u2192 split discovery into surgical probes with explorer/librarian \u2192 synthesize the decision and internal handoff \u2192 execute \u2192 verify.
-If delegating, write sub-agent prompts in English and launch the specialist in the same turn you mention it. If multiple delegations are independent, emit all tool calls in a single response.
-Before write-capable dispatch, give concrete scope, anchors, steps, non-goals, and verification.
-In SDD, after oracle returns [OKAY], give a deep approved-plan overview, then ask the user before implementation.</reminder>`;
-var PHASE_REMINDER_SEPARATOR = "\n\n---\n\n";
-function stripPhaseReminder(text) {
-  if (!text) {
-    return "";
-  }
-  const prefix = `${PHASE_REMINDER}${PHASE_REMINDER_SEPARATOR}`;
-  return text.startsWith(prefix) ? text.slice(prefix.length) : text;
-}
-function createPhaseReminderHook() {
-  return {
-    "experimental.chat.messages.transform": async (_input, output) => {
-      const { messages } = output;
-      if (messages.length === 0) {
-        return;
-      }
-      let lastUserMessageIndex = -1;
-      for (let i = messages.length - 1; i >= 0; i--) {
-        if (messages[i].info.role === "user") {
-          lastUserMessageIndex = i;
-          break;
-        }
-      }
-      if (lastUserMessageIndex === -1) {
-        return;
-      }
-      const lastUserMessage = messages[lastUserMessageIndex];
-      const agent = lastUserMessage.info.agent;
-      if (agent && agent !== "orchestrator") {
-        return;
-      }
-      const textPartIndex = lastUserMessage.parts.findIndex(
-        (p) => p.type === "text" && p.text !== void 0
+      const hasJsonError = JSON_ERROR_PATTERNS.some(
+        (pattern) => pattern.test(outputText)
       );
-      if (textPartIndex === -1) {
-        return;
-      }
-      const originalText = lastUserMessage.parts[textPartIndex].text ?? "";
-      if (originalText.includes(LITE_INTERNAL_INITIATOR_MARKER)) {
-        return;
+      if (hasJsonError) {
+        output.output += `
+${JSON_ERROR_REMINDER}`;
       }
-      lastUserMessage.parts[textPartIndex].text = `${PHASE_REMINDER}${PHASE_REMINDER_SEPARATOR}${originalText}`;
     }
   };
 }
 
-// src/hooks/post-read-nudge/index.ts
-var NUDGE = "\n\n---\nWorkflow Reminder: delegate based on rules; launch specialists in this same turn. If multiple delegations are independent, emit all tool calls in one response.";
-function createPostReadNudgeHook() {
+// src/mcp/index.ts
+function createAllBuiltinMcps() {
   return {
-    "tool.execute.after": async (input, output) => {
-      if (input.tool !== "Read" && input.tool !== "read") {
-        return;
-      }
-      output.output = output.output + NUDGE;
-    }
+    exa,
+    context7,
+    grep_app
   };
 }
+function createBuiltinMcps(disabledMcps = []) {
+  const allBuiltinMcps = createAllBuiltinMcps();
+  return Object.fromEntries(
+    Object.entries(allBuiltinMcps).filter(
+      ([name]) => !disabledMcps.includes(name)
+    )
+  );
+}
 
-// src/hooks/skill-sync.ts
-function formatSkillSyncSummary(report) {
-  if (report.updatedSkills.length === 0 && report.removedSkills.length === 0 && report.failedSkills.length === 0) {
-    return "Skills up to date";
-  }
-  const parts = [];
-  if (report.updatedSkills.length > 0) {
-    parts.push(
-      `Updated ${report.updatedSkills.length} skill${report.updatedSkills.length === 1 ? "" : "s"}`
-    );
-  }
-  if (report.removedSkills.length > 0) {
-    parts.push(
-      `removed ${report.removedSkills.length} obsolete skill${report.removedSkills.length === 1 ? "" : "s"}`
-    );
+// src/tools/ast-grep/tools.ts
+import { tool } from "@opencode-ai/plugin/tool";
+
+// src/tools/ast-grep/cli.ts
+import { existsSync as existsSync6 } from "fs";
+
+// src/tools/ast-grep/constants.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync5, statSync as statSync2 } from "fs";
+import { createRequire as createRequire3 } from "module";
+import { dirname as dirname2, join as join6 } from "path";
+
+// src/tools/ast-grep/downloader.ts
+import { chmodSync, existsSync as existsSync4, mkdirSync, unlinkSync } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { homedir as homedir2 } from "os";
+import { join as join5 } from "path";
+
+// 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;
   }
-  if (report.failedSkills.length > 0) {
-    parts.push(
-      `failed ${report.failedSkills.length} skill${report.failedSkills.length === 1 ? "" : "s"}`
-    );
+  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;
+    try {
+      response = await fetch(healthUrl, { signal: controller.signal }).catch(
+        () => null
+      );
+    } 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));
+    }
   }
-  return parts.join(", ");
+  log("[tmux] isServerRunning: checked", { serverUrl, available: false });
+  return false;
 }
-function syncSkillsOnStartup(dependencies = {}) {
-  const install = dependencies.install ?? installCustomSkills;
-  const logger = dependencies.logger ?? log;
-  const warn = dependencies.warn ?? console.warn;
-  const errorLogger = dependencies.error ?? console.error;
+async function findTmuxPath() {
+  const isWindows = process.platform === "win32";
+  const cmd = isWindows ? "where" : "which";
   try {
-    const report = install();
-    const summary = formatSkillSyncSummary(report);
-    logger(`[skill-sync] ${summary}`, {
-      updatedSkills: report.updatedSkills.map(({ skill }) => skill.name),
-      removedSkills: report.removedSkills,
-      skippedSkills: report.skippedSkills.map((skill) => skill.name),
-      failedSkills: report.failedSkills.map(({ skill }) => skill.name)
+    const proc = spawn([cmd, "tmux"], {
+      stdout: "pipe",
+      stderr: "pipe"
     });
-    if (report.failedSkills.length > 0) {
-      warn(
-        `[skill-sync] Failed to sync ${report.failedSkills.length} bundled skill${report.failedSkills.length === 1 ? "" : "s"}`
-      );
+    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 path4 = stdout.trim().split("\n")[0];
+    if (!path4) {
+      log("[tmux] findTmuxPath: no path in output");
+      return null;
     }
-  } catch (error) {
-    errorLogger("[skill-sync] Failed to sync bundled skills on startup");
-    logger("[skill-sync] Skill sync failed during plugin startup", error);
+    const verifyProc = spawn([path4, "-V"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const verifyExit = await verifyProc.exited;
+    if (verifyExit !== 0) {
+      log("[tmux] findTmuxPath: tmux -V failed", { path: path4, verifyExit });
+      return null;
+    }
+    log("[tmux] findTmuxPath: found tmux", { path: path4 });
+    return path4;
+  } catch (err) {
+    log("[tmux] findTmuxPath: exception", { error: String(err) });
+    return null;
   }
 }
-
-// src/thoth/client.ts
-var DEFAULT_THOTH_HTTP_PORT = 7438;
-var DEFAULT_THOTH_TIMEOUT_MS = 15e3;
-function isRecord2(value) {
-  return typeof value === "object" && value !== null;
+async function getTmuxPath() {
+  if (tmuxChecked) {
+    return tmuxPath;
+  }
+  tmuxPath = await findTmuxPath();
+  tmuxChecked = true;
+  log("[tmux] getTmuxPath: initialized", { tmuxPath });
+  return tmuxPath;
 }
-function normalizeText(value) {
-  return typeof value === "string" ? value.trim() || null : null;
+function isInsideTmux() {
+  return !!process.env.TMUX;
 }
-function previewText(value, max) {
-  const text = normalizeText(value);
-  if (!text) {
-    return null;
+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"
+      });
+      await reapplyProc.exited;
+    }
+    log("[tmux] applyLayout: applied", { layout, mainPaneSize });
+  } catch (err) {
+    log("[tmux] applyLayout: exception", { error: String(err) });
   }
-  return text.length > max ? `${text.slice(0, max)}...` : text;
 }
-function formatMemoryContext(response) {
-  if (!isRecord2(response)) {
-    return null;
+async function spawnTmuxPane(sessionId, description, config, serverUrl) {
+  log("[tmux] spawnTmuxPane called", {
+    sessionId,
+    description,
+    config,
+    serverUrl
+  });
+  if (!config.enabled) {
+    log("[tmux] spawnTmuxPane: config.enabled is false, skipping");
+    return { success: false };
   }
-  const sessions = Array.isArray(response.sessions) ? response.sessions : [];
-  const observations = Array.isArray(response.observations) ? response.observations : [];
-  const prompts = Array.isArray(response.prompts) ? response.prompts : [];
-  if (sessions.length === 0 && observations.length === 0 && prompts.length === 0) {
-    return null;
+  if (!isInsideTmux()) {
+    log("[tmux] spawnTmuxPane: not inside tmux, skipping");
+    return { success: false };
   }
-  const lines = ["## Memory Context", ""];
-  if (sessions.length > 0) {
-    lines.push("### Recent Sessions");
-    for (const rawSession of sessions) {
-      const sessionId = normalizeText(rawSession.id) ?? "unknown-session";
-      const project = normalizeText(rawSession.project) ?? "unknown-project";
-      const startedAt = normalizeText(rawSession.started_at) ?? "unknown";
-      lines.push(`- [${sessionId}] (${project}) \u2014 started ${startedAt}`);
-      const summary = previewText(rawSession.summary, 300);
-      if (summary) {
-        lines.push(`  Summary: ${summary}`);
-      }
-    }
-    lines.push("");
-  }
-  if (observations.length > 0) {
-    lines.push("### Recent Observations");
-    for (const rawObservation of observations) {
-      const type = normalizeText(rawObservation.type) ?? "manual";
-      const title = normalizeText(rawObservation.title) ?? "Untitled";
-      const createdAt = normalizeText(rawObservation.created_at) ?? "unknown";
-      lines.push(`- [${type}] ${title} (${createdAt})`);
-      const content = previewText(rawObservation.content, 300);
-      if (content) {
-        lines.push(`  ${content}`);
-      }
-    }
-    lines.push("");
+  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 };
   }
-  if (prompts.length > 0) {
-    lines.push("### Recent Prompts");
-    for (const rawPrompt of prompts) {
-      const content = previewText(rawPrompt.content, 200);
-      if (!content) {
-        continue;
-      }
-      const createdAt = normalizeText(rawPrompt.created_at) ?? "unknown";
-      lines.push(`- ${content} (${createdAt})`);
-    }
-    lines.push("");
+  const tmux = await getTmuxPath();
+  if (!tmux) {
+    log("[tmux] spawnTmuxPane: tmux binary not found, skipping");
+    return { success: false };
   }
-  const stats = isRecord2(response.stats) ? response.stats : void 0;
-  if (stats) {
-    lines.push("### Stats");
-    lines.push(
-      `- Sessions: ${typeof stats.sessions === "number" ? stats.sessions : 0}, Observations: ${typeof stats.observations === "number" ? stats.observations : 0}, Prompts: ${typeof stats.prompts === "number" ? stats.prompts : 0}`
-    );
+  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()
+    });
+    if (exitCode === 0 && paneId) {
+      const renameProc = spawn(
+        [tmux, "select-pane", "-t", paneId, "-T", description.slice(0, 30)],
+        { stdout: "ignore", stderr: "ignore" }
+      );
+      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
+      });
+      return { success: true, paneId };
+    }
+    return { success: false };
+  } catch (err) {
+    log("[tmux] spawnTmuxPane: exception", { error: String(err) });
+    return { success: false };
   }
-  return lines.join("\n");
 }
-var HttpThothClient = class {
-  enabled;
-  baseUrl;
-  timeoutMs;
-  project;
-  directory;
-  constructor(options) {
-    this.enabled = options.enabled !== false;
-    const port = options.httpPort ?? DEFAULT_THOTH_HTTP_PORT;
-    this.baseUrl = `http://127.0.0.1:${port}`;
-    this.timeoutMs = options.timeoutMs ?? DEFAULT_THOTH_TIMEOUT_MS;
-    this.project = options.project;
-    this.directory = options.directory;
-  }
-  async memContext(sessionId, limit = 10) {
-    const params = new URLSearchParams({
-      project: this.project,
-      limit: String(limit)
+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"
     });
-    if (sessionId) {
-      params.set("session_id", sessionId);
+    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 });
+      }
+      return true;
     }
-    const response = await this.httpGet(`/context?${params.toString()}`);
-    return formatMemoryContext(response);
-  }
-  async memSessionStart(sessionId) {
-    const response = await this.httpPost("/sessions", {
-      id: sessionId,
-      project: this.project,
-      directory: this.directory
+    log("[tmux] closeTmuxPane: failed (pane may already be closed)", {
+      paneId
     });
-    return response !== null;
+    return false;
+  } catch (err) {
+    log("[tmux] closeTmuxPane: exception", { error: String(err) });
+    return false;
   }
-  async memSavePrompt(sessionId, content) {
-    const response = await this.httpPost("/prompts", {
-      session_id: sessionId,
-      content,
-      project: this.project
+}
+function startTmuxCheck() {
+  if (!tmuxChecked) {
+    getTmuxPath().catch(() => {
     });
-    return response !== null;
-  }
-  async httpPost(path5, body) {
-    if (!this.enabled) {
-      return null;
-    }
-    try {
-      const response = await fetch(`${this.baseUrl}${path5}`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(this.timeoutMs)
-      });
-      if (!response.ok) {
-        return null;
-      }
-      return await response.json();
-    } catch (error) {
-      log("[thoth] HTTP POST unavailable", {
-        path: path5,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return null;
-    }
-  }
-  async httpGet(path5) {
-    if (!this.enabled) {
-      return null;
-    }
-    try {
-      const response = await fetch(`${this.baseUrl}${path5}`, {
-        signal: AbortSignal.timeout(this.timeoutMs)
-      });
-      if (!response.ok) {
-        return null;
-      }
-      return await response.json();
-    } catch (error) {
-      log("[thoth] HTTP GET unavailable", {
-        path: path5,
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return null;
-    }
   }
-};
-function createThothClient(options) {
-  return new HttpThothClient(options);
 }
 
-// src/hooks/thoth-mem/protocol.ts
-var SDD_TOPIC_KEY_FORMAT = "sdd/{change}/{artifact}";
-var FIRST_ACTION_INSTRUCTION = 'FIRST ACTION REQUIRED: Call mem_session(action="summary") with the content of the compacted summary. This preserves what was accomplished before compaction. Do this BEFORE any other work. Then call mem_context(recall_query=...) for fused recent context, and use the recall funnel (mem_recall(mode="compact") -> mem_recall(mode="context") -> mem_get(...)) for precise retrieval.';
-var SESSION_SUMMARY_TEMPLATE = `Use this exact structure for \`mem_session(action="summary")\` content:
-
-## Goal
-[What we were working on this session]
-
-## Instructions
-[User preferences or constraints discovered during this session]
-
-## Discoveries
-- [Technical findings, gotchas, non-obvious learnings]
-
-## Accomplished
-- [Completed items with key details]
-
-## Next Steps
-- [What remains to be done]
-
-## Relevant Files
-- path/to/file.ts - [what it does or what changed]`;
-function buildCompactionReminder(sessionID) {
-  return `FIRST ACTION REQUIRED: this session was compacted. Call \`mem_session(action="summary")\` with the content of the compacted summary and \`session_id\` \`${sessionID}\`. This preserves what was accomplished before compaction. Do this BEFORE any other work. After that, call \`mem_context(recall_query=...)\` for fused recent context, and use the recall funnel (\`mem_recall(mode="compact")\` -> \`mem_recall(mode="context")\` -> \`mem_get(...)\`) for precise retrieval.`;
-}
-function buildCompactorInstruction(project) {
-  return `CRITICAL INSTRUCTION: place this at the TOP of the compacted summary exactly as an action item for the resumed agent: "FIRST ACTION REQUIRED: Call mem_session(action="summary") with the content of this compacted summary. Use project: '${project}'. This preserves what was accomplished before compaction. Do this BEFORE any other work."`;
-}
-function buildMemoryInstructions(sessionID, project) {
-  return `
-<memory_protocol>
-Persistent memory is available through thoth-mem. Follow this protocol.
-
-IMPORTANT: Your current session_id is \`${sessionID}\` and project is \`${project}\`.
-Always pass these values when calling memory tools that accept them.
-
-### CORE TOOLS
-mem_save, mem_recall, mem_context, mem_get, mem_project, mem_session
-
-### OWNERSHIP AND SUBAGENT HANDOFF
-- Root owns \`mem_session(action="start"|"checkpoint"|"summary")\` and \`mem_save(kind="prompt"|"session_summary")\`.
-- Start root memory-backed workflows with \`mem_session(action="start")\` before any other thoth-mem operation when tools and identity are available.
-- Save the real user prompt with \`mem_save(kind="prompt")\`; never save generated subagent prompts as user intent.
-- Before memory-dependent delegation, save the handoff body with \`mem_session(action="summary")\` or \`mem_save(kind="session_summary")\`.
-- Subagent handoff prompts carry parent \`session_id\`, \`project\`, permissions, and recovery instructions only; do not ask subagents to own session lifecycle actions or save prompts.
-
-### WHEN TO SAVE
-Call \`mem_save(kind="observation")\` IMMEDIATELY after ANY of these:
-- Architecture, design, or workflow decision made
-- Bug fixed (include root cause)
-- Non-obvious discovery, gotcha, or edge case found
-- Configuration change or environment setup
-- Pattern or convention established (naming, structure, approach)
-- User preference or constraint learned
-- Feature implemented with non-obvious approach
-- User confirms a recommendation ("dale", "go with that", "sounds good", "s\xED, esa")
-- User rejects an approach or expresses a preference ("no, better X", "I prefer X")
-- Discussion concludes with a clear direction chosen
-
-Use \`title\` as Verb + what changed or was learned.
-Use \`kind\` intentionally: \`observation\`, \`prompt\`, \`session_summary\`, or \`passive_learnings\`.
-Use \`type\` from: bugfix | decision | architecture | discovery | pattern | config | learning | manual.
-Set \`scope\` intentionally.
-Reuse a stable \`topic_key\` for the same evolving topic. Do not overwrite unrelated topics.
-Put durable observation details in \`content\` with this structure:
-  - What: concise description of what changed or was learned
-  - Why: why it mattered or what problem it solved
-  - Where: files, paths, or systems involved
-  - Learned: edge cases, caveats, or follow-up notes
-
-**Self-check after EVERY task**: "Did I or the user just make a decision, confirm a recommendation, express a preference, fix a bug, learn something, or establish a convention? If yes \u2192 mem_save(kind="observation") NOW."
-
-### RECALL FUNNEL
-- Broad recovery (session start, after compaction): call \`mem_context(recall_query=...)\` for fused recent context when useful.
-- Targeted retrieval:
-  1. Call \`mem_recall(mode="compact")\` to scan candidate IDs and titles.
-  2. Call \`mem_recall(mode="context")\` to expand the strongest hits into retrieved context.
-  3. Call \`mem_get(...)\` only for records you need in full.
-- Use HyDE/fused recall for semantic or ambiguous searches.
-- Set \`mem_recall\` \`limit\` from 1 to 20 for candidate/result count.
-- Narrow with \`topic_key\`, \`type\`, \`time_from\`, \`time_to\`, \`scope\`, \`project\`, and \`session_id\` filters.
-- Use \`mem_get\` with \`kind="observation"|"prompt"\`; use \`mem_get(include_timeline=true)\` with \`before\`/\`after\`, and \`offset\`/\`max_length\` for large content.
-- Use bounded \`mem_project(action="graph"|"topics"|"topic")\` for relationship and topic navigation; \`mem_project(action="graph")\` relations are \`HAS_TYPE\`, \`IN_PROJECT\`, \`HAS_TOPIC_KEY\`, \`HAS_WHAT\`, \`HAS_WHY\`, \`HAS_WHERE\`, and \`HAS_LEARNED\`; these calls supplement, not replace, the recall funnel.
-- Search proactively on the first message about a project, feature, or problem when prior context may matter.
-- Search before starting work that may have been done before.
-- Search when the user mentions a topic that lacks enough local context.
-
-### SESSION CLOSE PROTOCOL
-- Before ending the session, call \`mem_session(action="summary")\` with this exact template.
-- This is NOT optional. If you skip this, the next session starts blind.
-- Do not claim memory was saved unless the tool call succeeded.
-- If your response includes \`## Key Learnings:\`, preserve them with \`mem_save(kind="passive_learnings")\`.
-
-${SESSION_SUMMARY_TEMPLATE}
-
-### AFTER COMPACTION
-- IMMEDIATELY call \`mem_session(action="summary")\` with the compacted summary content.
-- Then call \`mem_context(recall_query=...)\` for fused recent context.
-- Use the recall funnel (\`mem_recall(mode="compact")\` -> \`mem_recall(mode="context")\` -> \`mem_get(...)\`) for precise artifact/prior-observation retrieval.
-- Only then continue working.
-
-### SDD TOPIC KEY CONVENTION
-- use ${SDD_TOPIC_KEY_FORMAT}
-- examples: sdd/add-user-auth/spec, sdd/add-user-auth/design, sdd/add-user-auth/tasks
-</memory_protocol>
-`.trim();
-}
-function buildSaveNudge() {
-  return "MEMORY REMINDER: It has been a while since your last save. If you have made decisions, discoveries, or completed significant work, call mem_save now.";
-}
-
-// src/hooks/thoth-mem/index.ts
-function isRootSession(session) {
-  return !session.parentID;
-}
-function getSessionInfo(event) {
-  const info = event.properties?.info;
-  return info?.id ? info : null;
-}
-function isTextPart(part) {
-  return part.type === "text";
-}
-function extractPromptText(parts) {
-  const text = parts.filter(isTextPart).map((part) => part.text.trim()).filter((part) => part.length > 0).join("\n\n");
-  return text.length > 0 ? text : null;
-}
-function appendInstruction(target, instruction) {
-  if (target.includes(instruction)) {
-    return target;
-  }
-  return `${target}
-
-${instruction}`;
-}
-function stripPrivateTags(str) {
-  if (!str) {
-    return "";
-  }
-  return str.replace(/<private>[\s\S]*?<\/private>/gi, "[REDACTED]").trim();
-}
-function truncate(str, max) {
-  if (!str) {
-    return "";
+// src/utils/zip-extractor.ts
+import { release } from "os";
+var WINDOWS_BUILD_WITH_TAR = 17134;
+function getWindowsBuildNumber() {
+  if (process.platform !== "win32") return null;
+  const parts = release().split(".");
+  if (parts.length >= 3) {
+    const build = parseInt(parts[2], 10);
+    if (!Number.isNaN(build)) return build;
   }
-  return str.length > max ? `${str.slice(0, max)}...` : str;
-}
-function sanitizePromptText(text) {
-  return truncate(stripPrivateTags(stripPhaseReminder(text)), 2e3);
+  return null;
 }
-function isSessionSummaryTool(toolName, args) {
-  if (!args || typeof args !== "object" || Array.isArray(args)) {
-    return false;
-  }
-  const normalized = toolName.toLowerCase();
-  const isMemSessionTool = normalized === "mem_session" || normalized.endsWith(".mem_session") || normalized.endsWith("_mem_session");
-  return isMemSessionTool && args.action === "summary";
+function isPwshAvailable() {
+  if (process.platform !== "win32") return false;
+  const result = spawnSync(["where", "pwsh"], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  return result.exitCode === 0;
 }
-function isMemSaveTool(toolName) {
-  const normalized = toolName.toLowerCase();
-  return normalized === "mem_save" || normalized.endsWith(".mem_save") || normalized.endsWith("_mem_save");
+function escapePowerShellPath(path4) {
+  return path4.replace(/'/g, "''");
 }
-function createThothMemHook(options) {
-  const enabled = options.enabled !== false;
-  const thoth = createThothClient({
-    project: options.project,
-    directory: options.directory,
-    httpPort: options.thoth?.http_port,
-    timeoutMs: options.thoth?.timeout,
-    enabled
-  });
-  const trackedRootSessions = /* @__PURE__ */ new Set();
-  const needsCompactionFollowUp = /* @__PURE__ */ new Set();
-  const sessionCreatedAt = /* @__PURE__ */ new Map();
-  const lastMemSaveAt = /* @__PURE__ */ new Map();
-  const nudgePending = /* @__PURE__ */ new Set();
-  function isTrackedRootSession(sessionId) {
-    return typeof sessionId === "string" && trackedRootSessions.has(sessionId);
-  }
-  function shouldInjectSaveNudge(sessionId) {
-    if (nudgePending.has(sessionId)) {
-      return false;
-    }
-    if (needsCompactionFollowUp.has(sessionId)) {
-      return false;
-    }
-    const createdAt = sessionCreatedAt.get(sessionId);
-    if (!createdAt || Date.now() - createdAt < 5 * 60 * 1e3) {
-      return false;
-    }
-    const lastSave = lastMemSaveAt.get(sessionId);
-    if (lastSave && Date.now() - lastSave < 15 * 60 * 1e3) {
-      return false;
-    }
-    nudgePending.add(sessionId);
-    return true;
-  }
-  async function handleSessionCreated(session) {
-    if (!enabled || !isRootSession(session)) {
-      return;
-    }
-    const started = await thoth.memSessionStart(session.id);
-    if (started) {
-      trackedRootSessions.add(session.id);
-      sessionCreatedAt.set(session.id, Date.now());
-    } else {
-      log("[thoth] session start unavailable, skipping tracking:", session.id);
-    }
-  }
-  function handleSessionCompacted(session) {
-    if (!enabled || !isRootSession(session) || !session.id) {
-      return;
-    }
-    needsCompactionFollowUp.add(session.id);
+function getWindowsZipExtractor() {
+  const buildNumber = getWindowsBuildNumber();
+  if (buildNumber !== null && buildNumber >= WINDOWS_BUILD_WITH_TAR) {
+    return "tar";
   }
-  function handleSessionDeleted(session) {
-    trackedRootSessions.delete(session.id);
-    needsCompactionFollowUp.delete(session.id);
-    sessionCreatedAt.delete(session.id);
-    lastMemSaveAt.delete(session.id);
-    nudgePending.delete(session.id);
+  if (isPwshAvailable()) {
+    return "pwsh";
   }
-  return {
-    event: async ({ event }) => {
-      switch (event.type) {
-        case "session.created": {
-          const session = getSessionInfo(event);
-          if (!session) {
-            break;
-          }
-          await handleSessionCreated(session);
-          break;
-        }
-        case "session.compacted": {
-          const session = getSessionInfo(event);
-          if (!session) {
-            break;
+  return "powershell";
+}
+async function extractZip(archivePath, destDir) {
+  let proc;
+  if (process.platform === "win32") {
+    const extractor = getWindowsZipExtractor();
+    switch (extractor) {
+      case "tar":
+        proc = spawn(["tar", "-xf", archivePath, "-C", destDir], {
+          stdout: "ignore",
+          stderr: "pipe"
+        });
+        break;
+      case "pwsh":
+        proc = spawn(
+          [
+            "pwsh",
+            "-Command",
+            `Expand-Archive -Path '${escapePowerShellPath(archivePath)}' -DestinationPath '${escapePowerShellPath(destDir)}' -Force`
+          ],
+          {
+            stdout: "ignore",
+            stderr: "pipe"
           }
-          handleSessionCompacted(session);
-          break;
-        }
-        case "session.deleted": {
-          const session = getSessionInfo(event);
-          if (!session) {
-            break;
+        );
+        break;
+      default:
+        proc = spawn(
+          [
+            "powershell",
+            "-Command",
+            `Expand-Archive -Path '${escapePowerShellPath(archivePath)}' -DestinationPath '${escapePowerShellPath(destDir)}' -Force`
+          ],
+          {
+            stdout: "ignore",
+            stderr: "pipe"
           }
-          handleSessionDeleted(session);
-          break;
-        }
-      }
-    },
-    "chat.message": async (input, output) => {
-      void output.message;
-      if (!enabled) {
-        return;
-      }
-      if (!isTrackedRootSession(input.sessionID)) {
-        return;
-      }
-      const promptText = extractPromptText(output.parts);
-      if (!promptText) {
-        return;
-      }
-      const sanitizedPromptText = sanitizePromptText(promptText);
-      if (!sanitizedPromptText || sanitizedPromptText.length <= 10) {
-        return;
-      }
-      await thoth.memSavePrompt(input.sessionID, sanitizedPromptText);
-    },
-    "experimental.chat.system.transform": async (input, output) => {
-      void input.model;
-      if (!enabled || !input.sessionID) {
-        return;
-      }
-      if (!isTrackedRootSession(input.sessionID)) {
-        return;
-      }
-      const memoryInstructions = buildMemoryInstructions(
-        input.sessionID,
-        options.project
-      );
-      const compactionReminder = needsCompactionFollowUp.has(input.sessionID) ? buildCompactionReminder(input.sessionID) : null;
-      const saveNudge = shouldInjectSaveNudge(input.sessionID) ? buildSaveNudge() : null;
-      if (output.system.length === 0) {
-        let systemPrompt = memoryInstructions;
-        if (compactionReminder) {
-          systemPrompt = appendInstruction(systemPrompt, compactionReminder);
-        }
-        if (saveNudge) {
-          systemPrompt = appendInstruction(systemPrompt, saveNudge);
-        }
-        output.system.push(systemPrompt);
-        return;
-      }
-      const lastIndex = output.system.length - 1;
-      let updatedSystemPrompt = appendInstruction(
-        output.system[lastIndex],
-        memoryInstructions
-      );
-      if (compactionReminder) {
-        updatedSystemPrompt = appendInstruction(
-          updatedSystemPrompt,
-          compactionReminder
         );
-      }
-      if (saveNudge) {
-        updatedSystemPrompt = appendInstruction(updatedSystemPrompt, saveNudge);
-      }
-      output.system[lastIndex] = updatedSystemPrompt;
-    },
-    "experimental.session.compacting": async (input, output) => {
-      void output.prompt;
-      if (!enabled) {
-        return;
-      }
-      if (!isTrackedRootSession(input.sessionID)) {
-        return;
-      }
-      needsCompactionFollowUp.add(input.sessionID);
-      output.context.push(buildCompactorInstruction(options.project));
-      output.context.push(FIRST_ACTION_INSTRUCTION);
-      const memoryContext = await thoth.memContext(input.sessionID);
-      if (memoryContext) {
-        output.context.push(memoryContext);
-      }
-    },
-    "tool.execute.after": async (input, output) => {
-      void input.callID;
-      void output.title;
-      void output.output;
-      void output.metadata;
-      if (!enabled) {
-        return;
-      }
-      if (isMemSaveTool(input.tool)) {
-        lastMemSaveAt.set(input.sessionID, Date.now());
-        nudgePending.delete(input.sessionID);
-      }
-      if (isSessionSummaryTool(input.tool, input.args)) {
-        needsCompactionFollowUp.delete(input.sessionID);
-      }
+        break;
     }
-  };
-}
-
-// src/mcp/thoth.ts
-function createThothMcp(config) {
-  const environment = {
-    ...config?.data_dir ? { THOTH_DATA_DIR: config.data_dir } : {},
-    ...typeof config?.http_port === "number" ? { THOTH_HTTP_PORT: String(config.http_port) } : {},
-    ...config?.environment
-  };
-  const mcpConfig = {
-    type: "local",
-    command: [...config?.command ?? DEFAULT_THOTH_COMMAND],
-    ...Object.keys(environment).length > 0 ? { environment } : {},
-    ...typeof config?.timeout === "number" ? { timeout: config.timeout } : {}
-  };
-  return mcpConfig;
-}
-
-// src/mcp/index.ts
-function createAllBuiltinMcps(thothConfig) {
-  return {
-    exa,
-    context7,
-    grep_app,
-    thoth_mem: createThothMcp(thothConfig)
-  };
-}
-function createBuiltinMcps(disabledMcps = [], thothConfig) {
-  const allBuiltinMcps = createAllBuiltinMcps(thothConfig);
-  return Object.fromEntries(
-    Object.entries(allBuiltinMcps).filter(
-      ([name]) => !disabledMcps.includes(name)
-    )
-  );
+  } else {
+    proc = spawn(["unzip", "-o", archivePath, "-d", destDir], {
+      stdout: "ignore",
+      stderr: "pipe"
+    });
+  }
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`zip extraction failed (exit ${exitCode}): ${stderr}`);
+  }
 }
 
-// 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/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/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/file-io.ts
 import { readFile, writeFile } from "fs/promises";
 async function writeTextFile(filePath, contents) {
@@ -1976,19 +1302,19 @@ var PLATFORM_MAP = {
 function getCacheDir2() {
   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 || join5(homedir2(), "AppData", "Local");
+    return join5(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 || join5(homedir2(), ".cache");
+  return join5(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 = join5(getCacheDir2(), getBinaryName());
+  return existsSync4(binaryPath) ? binaryPath : null;
 }
 async function downloadAstGrep(version = DEFAULT_VERSION) {
   const platformKey = `${process.platform}-${process.arch}`;
@@ -2001,8 +1327,8 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir2();
   const binaryName = getBinaryName();
-  const binaryPath = join4(cacheDir, binaryName);
-  if (existsSync3(binaryPath)) {
+  const binaryPath = join5(cacheDir, binaryName);
+  if (existsSync4(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os2 } = platformInfo;
@@ -2010,21 +1336,21 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
   const downloadUrl = `https://github.com/${REPO}/releases/download/${version}/${assetName}`;
   console.log(`[thoth-agents] Downloading ast-grep binary...`);
   try {
-    if (!existsSync3(cacheDir)) {
+    if (!existsSync4(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 = join5(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await writeTextFile(archivePath, arrayBuffer);
     await extractZip(archivePath, cacheDir);
-    if (existsSync3(archivePath)) {
+    if (existsSync4(archivePath)) {
       unlinkSync(archivePath);
     }
-    if (process.platform !== "win32" && existsSync3(binaryPath)) {
+    if (process.platform !== "win32" && existsSync4(binaryPath)) {
       chmodSync(binaryPath, 493);
     }
     console.log(`[thoth-agents] ast-grep binary ready.`);
@@ -2108,8 +1434,8 @@ function findSgCliPathSync() {
     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 sgPath = join6(cliDir, binaryName);
+    if (existsSync5(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {
@@ -2121,8 +1447,8 @@ function findSgCliPathSync() {
       const pkgPath = require3.resolve(`${platformPkg}/package.json`);
       const pkgDir = dirname2(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join5(pkgDir, astGrepName);
-      if (existsSync4(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join6(pkgDir, astGrepName);
+      if (existsSync5(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {
@@ -2130,9 +1456,9 @@ function findSgCliPathSync() {
   }
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
-    for (const path5 of homebrewPaths) {
-      if (existsSync4(path5) && isValidBinary(path5)) {
-        return path5;
+    for (const path4 of homebrewPaths) {
+      if (existsSync5(path4) && isValidBinary(path4)) {
+        return path4;
       }
     }
   }
@@ -2149,8 +1475,8 @@ function getSgCliPath() {
   }
   return "sg";
 }
-function setSgCliPath(path5) {
-  resolvedCliPath = path5;
+function setSgCliPath(path4) {
+  resolvedCliPath = path4;
 }
 var DEFAULT_TIMEOUT_MS = 3e5;
 var DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
@@ -2160,7 +1486,7 @@ var DEFAULT_MAX_MATCHES = 500;
 var initPromise = null;
 async function getAstGrepPath() {
   const currentPath = getSgCliPath();
-  if (currentPath !== "sg" && existsSync5(currentPath)) {
+  if (currentPath !== "sg" && existsSync6(currentPath)) {
     return currentPath;
   }
   if (initPromise) {
@@ -2168,7 +1494,7 @@ async function getAstGrepPath() {
   }
   initPromise = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync5(syncPath)) {
+    if (syncPath && existsSync6(syncPath)) {
       setSgCliPath(syncPath);
       return syncPath;
     }
@@ -2207,7 +1533,7 @@ 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 (!existsSync6(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -2500,7 +1826,7 @@ var ast_grep_replace = tool({
 });
 
 // src/tools/lsp/client.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { extname, resolve as resolve2 } from "path";
 import { Readable, Writable } from "stream";
 import { pathToFileURL } from "url";
@@ -2511,9 +1837,9 @@ import {
 } from "vscode-jsonrpc/node.js";
 
 // src/tools/lsp/config.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import whichSync from "which";
 
 // src/tools/lsp/config-store.ts
@@ -2544,7 +1870,7 @@ function hasUserLspConfig() {
 }
 
 // src/tools/lsp/constants.ts
-import { existsSync as existsSync6, readdirSync, statSync as statSync3 } from "fs";
+import { existsSync as existsSync7, readdirSync, statSync as statSync3 } from "fs";
 import { dirname as dirname3, resolve } from "path";
 var SEVERITY_MAP = {
   1: "error",
@@ -2584,7 +1910,7 @@ function NearestRoot(includePatterns, excludePatterns) {
     if (excludePatterns) {
       for (const dir of walkUpDirectories(file, cwd)) {
         for (const pattern of excludePatterns) {
-          if (existsSync6(`${dir}/${pattern}`)) {
+          if (existsSync7(`${dir}/${pattern}`)) {
             return void 0;
           }
         }
@@ -2603,7 +1929,7 @@ function NearestRoot(includePatterns, excludePatterns) {
             }
           } catch {
           }
-        } else if (existsSync6(`${dir}/${pattern}`)) {
+        } else if (existsSync7(`${dir}/${pattern}`)) {
           return dir;
         }
       }
@@ -3225,11 +2551,11 @@ function isServerInstalled(command) {
   if (command.length === 0) return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    return existsSync7(cmd);
+    return existsSync8(cmd);
   }
   const isWindows = process.platform === "win32";
   const ext = isWindows ? ".exe" : "";
-  const opencodeBin = join6(homedir3(), ".config", "opencode", "bin");
+  const opencodeBin = join7(homedir3(), ".config", "opencode", "bin");
   const searchPath = (process.env.PATH ?? "") + (isWindows ? ";" : ":") + opencodeBin;
   const result = whichSync.sync(cmd, {
     path: searchPath,
@@ -3240,8 +2566,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 = join7(cwd, "node_modules", ".bin", cmd);
+  if (existsSync8(localBin) || existsSync8(localBin + ext)) {
     return true;
   }
   return false;
@@ -3581,7 +2907,7 @@ stderr: ${stderr}` : "")
       log("[lsp] openFile: already open, skipping", { filePath: absPath });
       return;
     }
-    const text = readFileSync3(absPath, "utf-8");
+    const text = readFileSync4(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     log("[lsp] openFile: opening document", {
@@ -3672,13 +2998,13 @@ import { tool as tool2 } from "@opencode-ai/plugin/tool";
 
 // src/tools/lsp/utils.ts
 import {
-  existsSync as existsSync8,
-  readFileSync as readFileSync4,
+  existsSync as existsSync9,
+  readFileSync as readFileSync5,
   statSync as statSync4,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync3
 } from "fs";
-import { dirname as dirname4, extname as extname2, join as join7, resolve as resolve3 } from "path";
+import { dirname as dirname4, extname as extname2, join as join8, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function findServerProjectRoot(filePath, server) {
   if (server.root) {
@@ -3784,7 +3110,7 @@ function filterDiagnosticsBySeverity(diagnostics, severityFilter) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    const content = readFileSync4(filePath, "utf-8");
+    const content = readFileSync5(filePath, "utf-8");
     const lines = content.split("\n");
     const sortedEdits = [...edits].sort((a, b) => {
       if (b.range.start.line !== a.range.start.line) {
@@ -3868,7 +3194,7 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = uriToPath(change.oldUri);
             const newPath = uriToPath(change.newUri);
-            const content = readFileSync4(oldPath, "utf-8");
+            const content = readFileSync5(oldPath, "utf-8");
             writeFileSync3(newPath, content, "utf-8");
             unlinkSync2(oldPath);
             result.filesModified.push(newPath);
@@ -4250,17 +3576,16 @@ var TmuxSessionManager = class {
 };
 
 // src/index.ts
-function resolveProjectName(project, directory) {
-  const runtimeProjectName = "name" in project && typeof project.name === "string" ? project.name : void 0;
-  return runtimeProjectName || path4.basename(directory) || "thoth-agents";
-}
 var ThothAgents = async (ctx, _options) => {
-  const { client, directory, project, $: shell } = ctx;
-  const projectName = resolveProjectName(project, directory);
-  const sessionContext = /* @__PURE__ */ new Map();
+  const { client, directory, $: shell } = 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) {
@@ -4298,16 +3623,10 @@ var ThothAgents = async (ctx, _options) => {
     rawTmuxConfig: config.tmux,
     directory
   });
-  try {
-    syncSkillsOnStartup();
-  } catch (error) {
-    console.error("[plugin] Failed to sync bundled skills on startup");
-    log("[plugin] Skill sync failed during initialization", error);
-  }
   if (tmuxConfig.enabled) {
     startTmuxCheck();
   }
-  const mcps = createBuiltinMcps(config.disabled_mcps, config.thoth);
+  const mcps = createBuiltinMcps(config.disabled_mcps);
   const tmuxSessionManager = new TmuxSessionManager(ctx, tmuxConfig);
   const autoUpdateChecker = createAutoUpdateCheckerHook(
     ctx,
@@ -4317,15 +3636,6 @@ var ThothAgents = async (ctx, _options) => {
     },
     shell
   );
-  const phaseReminderHook = createPhaseReminderHook();
-  const postReadNudgeHook = createPostReadNudgeHook();
-  const thothMemHook = createThothMemHook({
-    project: projectName,
-    directory,
-    thoth: config.thoth,
-    enabled: true
-  });
-  const chatHeadersHook = createChatHeadersHook(ctx);
   const delegateTaskRetryHook = createDelegateTaskRetryHook(ctx);
   const jsonErrorRecoveryHook = createJsonErrorRecoveryHook(ctx);
   const foregroundFallback = new ForegroundFallbackManager(
@@ -4348,6 +3658,11 @@ var ThothAgents = async (ctx, _options) => {
     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";
       }
@@ -4416,16 +3731,8 @@ var ThothAgents = async (ctx, _options) => {
       }
     },
     event: async (input) => {
-      if (input.event.type === "session.deleted") {
-        const deletedEvent = input.event;
-        const deletedSessionId = deletedEvent.properties?.info?.id ?? deletedEvent.properties?.sessionID;
-        if (deletedSessionId) {
-          sessionContext.delete(deletedSessionId);
-        }
-      }
       await foregroundFallback.handleEvent(input.event);
       await autoUpdateChecker.event(input);
-      await thothMemHook.event(input);
       await tmuxSessionManager.onSessionCreated(
         input.event
       );
@@ -4436,56 +3743,7 @@ var ThothAgents = async (ctx, _options) => {
         input.event
       );
     },
-    "chat.headers": chatHeadersHook["chat.headers"],
-    "chat.message": async (input, output) => {
-      const chatInput = input;
-      if (chatInput.sessionID) {
-        const previous = sessionContext.get(chatInput.sessionID);
-        const context = {
-          model: previous?.model,
-          variant: previous?.variant
-        };
-        if (typeof chatInput.model?.providerID === "string" && typeof chatInput.model?.modelID === "string") {
-          context.model = {
-            providerID: chatInput.model.providerID,
-            modelID: chatInput.model.modelID
-          };
-        }
-        if (typeof chatInput.variant === "string") {
-          context.variant = chatInput.variant;
-        }
-        sessionContext.set(chatInput.sessionID, context);
-      }
-      if (thothMemHook["chat.message"]) {
-        await thothMemHook["chat.message"](
-          input,
-          output
-        );
-      }
-    },
-    "experimental.chat.system.transform": async (input, output) => {
-      if (thothMemHook["experimental.chat.system.transform"]) {
-        await thothMemHook["experimental.chat.system.transform"](
-          input,
-          output
-        );
-      }
-    },
-    "experimental.chat.messages.transform": async (input, output) => {
-      await phaseReminderHook["experimental.chat.messages.transform"](
-        input,
-        output
-      );
-    },
-    "experimental.session.compacting": async (input, output) => {
-      if (thothMemHook["experimental.session.compacting"]) {
-        await thothMemHook["experimental.session.compacting"](
-          input,
-          output
-        );
-      }
-    },
-    // Post-tool hooks: retry guidance for delegation errors + post-read nudge
+    // Post-tool hooks: retry guidance for delegation and JSON errors.
     "tool.execute.after": async (input, output) => {
       await delegateTaskRetryHook["tool.execute.after"](
         input,
@@ -4495,16 +3753,6 @@ var ThothAgents = async (ctx, _options) => {
         input,
         output
       );
-      if (thothMemHook["tool.execute.after"]) {
-        await thothMemHook["tool.execute.after"](
-          input,
-          output
-        );
-      }
-      await postReadNudgeHook["tool.execute.after"](
-        input,
-        output
-      );
     }
   };
 };