opencode-snippets 2.2.4 → 3.0.0

package/dist/index.js

@@ -1,736 +1,2323 @@
-import { rmdir, unlink } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createCommandExecuteHandler } from "./src/commands.js";
-import { loadConfig } from "./src/config.js";
-import { assembleMessage, expandHashtags } from "./src/expander.js";
-import { InjectionManager } from "./src/injection-manager.js";
-import { loadSnippets } from "./src/loader.js";
-import { logger } from "./src/logger.js";
-import { deleteSessionMessage, deleteSessionPart, sendIgnoredMessage } from "./src/notification.js";
-import { refreshPendingDraftsForText } from "./src/pending-drafts.js";
-import { consumeSnippetReloadRequest } from "./src/reload-signal.js";
-import { executeShellCommands } from "./src/shell.js";
-import { SkillLoadManager } from "./src/skill-load-manager.js";
-import { loadSkills } from "./src/skill-loader.js";
-import { buildSkillPayloadsFromVisibleText, expandSkillLoads } from "./src/skill-loading.js";
-import { expandSkillTags } from "./src/skill-renderer.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const PLUGIN_ROOT = join(__dirname, "..");
-const SKILL_DIR = join(PLUGIN_ROOT, "skill");
-const MARKER_ID_RANDOM_FILL = "0000000000";
-/**
- * Clean up legacy skill installation from pre-v1.7.0
- * We used to force-install SKILL.md to ~/.config/opencode/skill/snippets/
- * Now we register the skill path instead, so we remove the orphaned file.
- *
- * TODO: Remove this cleanup code around mid-2026 when most users have upgraded.
- */
-async function cleanupLegacySkillInstall() {
-    const home = process.env.HOME || process.env.USERPROFILE || "";
-    if (!home)
-        return;
-    const legacySkillDir = join(home, ".config", "opencode", "skill", "snippets");
-    const legacySkillPath = join(legacySkillDir, "SKILL.md");
-    try {
-        const file = Bun.file(legacySkillPath);
-        if (await file.exists()) {
-            await unlink(legacySkillPath);
-            logger.debug("Cleaned up legacy skill file", { path: legacySkillPath });
-            // Try to remove the empty directory too
-            await rmdir(legacySkillDir).catch(() => {
-                // Directory not empty or doesn't exist - that's fine
-            });
+// index.ts
+import { access as access2, rmdir, unlink as unlink2 } from "node:fs/promises";
+import { dirname as dirname3, join as join7 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/arg-parser.ts
+function parseCommandArgs(input) {
+  const args = [];
+  let current = "";
+  let state = "normal";
+  let hasQuotedContent = false;
+  let i = 0;
+  while (i < input.length) {
+    const char = input[i];
+    if (state === "normal") {
+      if (char === " " || char === "\t") {
+        if (current.length > 0 || hasQuotedContent) {
+          args.push(current);
+          current = "";
+          hasQuotedContent = false;
         }
+      } else if (char === '"') {
+        state = "double";
+        hasQuotedContent = true;
+      } else if (char === "'") {
+        state = "single";
+        hasQuotedContent = true;
+      } else {
+        current += char;
+      }
+    } else if (state === "double") {
+      if (char === "\\") {
+        const next = input[i + 1];
+        if (next === '"' || next === "\\") {
+          current += next;
+          i++;
+        } else {
+          current += char;
+        }
+      } else if (char === '"') {
+        state = "normal";
+      } else {
+        current += char;
+      }
+    } else if (state === "single") {
+      if (char === "\\") {
+        const next = input[i + 1];
+        if (next === "'" || next === "\\") {
+          current += next;
+          i++;
+        } else {
+          current += char;
+        }
+      } else if (char === "'") {
+        state = "normal";
+      } else {
+        current += char;
+      }
     }
-    catch (err) {
-        logger.debug("Failed to cleanup legacy skill", { error: String(err) });
-    }
-}
-/**
- * Snippets Plugin for OpenCode
- *
- * Expands hashtag-based shortcuts in user messages into predefined text snippets.
- * Also provides /snippets commands for managing snippets.
- *
- * @see https://github.com/JosXa/opencode-snippets for full documentation
- */
-export const SnippetsPlugin = async (ctx) => {
-    // Load configuration (global + project-local override)
-    const config = loadConfig(ctx.directory);
-    // Apply config settings
-    logger.debugEnabled = config.logging.debug;
-    // Clean up legacy skill installation (pre-v1.7.0)
-    cleanupLegacySkillInstall();
-    // Load all snippets at startup (global + project directory)
-    const startupStart = performance.now();
-    const snippets = await loadSnippets(ctx.directory);
-    const opencodeSkillDirs = [];
-    const loadRuntimeSkills = () => loadSkills(ctx.directory, { opencodeSkillDirs });
-    // Load skills if either skill feature is enabled. The config hook below refreshes this
-    // after OpenCode exposes paths registered by earlier plugins.
-    let skills = new Map();
-    if (config.experimental.skillRendering || config.experimental.skillLoading) {
-        skills = await loadRuntimeSkills();
+    i++;
+  }
+  if (current.length > 0 || hasQuotedContent) {
+    args.push(current);
+  }
+  return args;
+}
+
+// src/constants.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+var PATTERNS = {
+  HASHTAG: /#([a-z0-9\-_]+)/gi,
+  SHELL_COMMAND: /(!>?)`([^`]+)`/g,
+  SKILL_LOAD: /#skill\(\s*([^\r\n)]+?)\s*\)/gi,
+  SKILL_TAG_SELF_CLOSING: /<skill\s+name=["']([^"']+)["']\s*\/>/gi,
+  SKILL_TAG_BLOCK: /<skill>([^<]+)<\/skill>/gi
+};
+var PATHS = {
+  CONFIG_DIR: join(homedir(), ".config", "opencode"),
+  SNIPPETS_DIR: join(homedir(), ".config", "opencode", "snippet"),
+  SNIPPETS_DIR_ALT: join(homedir(), ".config", "opencode", "snippets"),
+  CONFIG_FILE_GLOBAL: join(homedir(), ".config", "opencode", "snippet", "config.jsonc")
+};
+function getProjectPaths(projectDir) {
+  const snippetDir = join(projectDir, ".opencode", "snippet");
+  return {
+    SNIPPETS_DIR: snippetDir,
+    SNIPPETS_DIR_ALT: join(projectDir, ".opencode", "snippets"),
+    CONFIG_FILE: join(snippetDir, "config.jsonc")
+  };
+}
+var CONFIG = {
+  SNIPPET_EXTENSION: ".md"
+};
+
+// src/loader.ts
+import { access, mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { basename, join as join3 } from "node:path";
+
+// src/cjs-interop.ts
+async function importCjs(pkg) {
+  let val = await import(pkg);
+  for (let i = 0;i < 4; i++) {
+    if (val == null || typeof val === "function")
+      break;
+    if (!("default" in val) || val.default === undefined)
+      break;
+    val = val.default;
+  }
+  return val;
+}
+
+// src/logger.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+class Logger {
+  logDir;
+  debugEnabled;
+  silent;
+  constructor(logDirOverride, debugEnabled = false, silent = false) {
+    this.logDir = logDirOverride ?? join2(PATHS.CONFIG_DIR, "logs", "snippets");
+    this.debugEnabled = debugEnabled;
+    this.silent = silent;
+  }
+  ensureLogDir() {
+    if (!existsSync(this.logDir)) {
+      mkdirSync(this.logDir, { recursive: true });
     }
-    const startupTime = performance.now() - startupStart;
-    logger.debug("Plugin startup complete", {
-        startupTimeMs: startupTime.toFixed(2),
-        snippetCount: snippets.size,
-        skillCount: skills.size,
-        skillRenderingEnabled: config.experimental.skillRendering,
-        skillLoadingEnabled: config.experimental.skillLoading,
-        injectBlocksEnabled: config.experimental.injectBlocks,
-        debugLogging: config.logging.debug,
-    });
-    // Create command handler
-    const commandHandler = createCommandExecuteHandler(ctx.client, snippets, ctx.directory);
-    const injectionManager = new InjectionManager();
-    const skillLoadManager = new SkillLoadManager();
-    const injectionMarkerIdsBySession = new Map();
-    const injectionMarkerRenderQueueBySession = new Map();
-    /**
-     * Processes text parts for snippet expansion, skill rendering, and shell command execution.
-     * Returns collected inject blocks from expanded snippets with snippet names.
-     */
-    const processTextParts = async (parts) => {
-        const messageStart = performance.now();
-        let expandTimeTotal = 0;
-        let skillTimeTotal = 0;
-        let shellTimeTotal = 0;
-        let processedParts = 0;
-        const allInjected = [];
-        const expandOptions = {
-            extractInject: config.experimental.injectBlocks,
-            onInjectBlock: (block) => {
-                allInjected.push(block);
-            },
-        };
-        for (const part of parts) {
-            if (part.type === "text" && part.text) {
-                // 1. Expand skill tags if skill rendering is enabled
-                if (config.experimental.skillRendering && skills.size > 0) {
-                    const skillStart = performance.now();
-                    part.text = expandSkillTags(part.text, skills);
-                    skillTimeTotal += performance.now() - skillStart;
-                }
-                const skillPayloads = [];
-                const loadSkills = async () => {
-                    if (!config.experimental.skillLoading || skills.size === 0)
-                        return;
-                    const skillLoadResult = await expandSkillLoads(part.text || "", skills, snippets, {
-                        expandSkillTagsInContent: config.experimental.skillRendering,
-                        extractInject: config.experimental.injectBlocks,
-                    });
-                    part.text = skillLoadResult.text;
-                    skillPayloads.push(...skillLoadResult.payloads);
-                };
-                if (config.experimental.skillLoading && skills.size > 0) {
-                    const skillStart = performance.now();
-                    // User requirement: reserve explicit #skill(...) syntax even if a plain
-                    // #skill snippet also exists.
-                    await loadSkills();
-                    skillTimeTotal += performance.now() - skillStart;
-                }
-                // 2. Expand hashtags recursively with loop detection
-                const expandStart = performance.now();
-                if (await consumeSnippetReloadRequest(ctx.directory)) {
-                    const fresh = await loadSnippets(ctx.directory);
-                    snippets.clear();
-                    for (const [key, value] of fresh) {
-                        snippets.set(key, value);
-                    }
-                }
-                await refreshPendingDraftsForText(part.text, snippets, ctx.directory, async () => {
-                    await loadSnippets(ctx.directory).then((fresh) => {
-                        snippets.clear();
-                        for (const [key, value] of fresh) {
-                            snippets.set(key, value);
-                        }
-                    });
-                });
-                const expansionResult = expandHashtags(part.text, snippets, new Map(), expandOptions);
-                part.text = assembleMessage(expansionResult);
-                expandTimeTotal += performance.now() - expandStart;
-                // User requirement: snippet-expanded text can also contain #skill(...),
-                // so run skill loading again after hashtag expansion.
-                if (config.experimental.skillLoading && skills.size > 0) {
-                    const skillStart = performance.now();
-                    await loadSkills();
-                    part.skillLoads = skillPayloads;
-                    skillTimeTotal += performance.now() - skillStart;
-                }
-                // 3. Execute shell commands: !`command` or !>`command`
-                const shellStart = performance.now();
-                part.text = await executeShellCommands(part.text, ctx);
-                shellTimeTotal += performance.now() - shellStart;
-                processedParts += 1;
-            }
+  }
+  formatData(data) {
+    if (!data)
+      return "";
+    const parts = [];
+    for (const [key, value] of Object.entries(data)) {
+      if (value === undefined || value === null)
+        continue;
+      if (Array.isArray(value)) {
+        if (value.length === 0)
+          continue;
+        parts.push(`${key}=[${value.slice(0, 3).join(",")}${value.length > 3 ? `...+${value.length - 3}` : ""}]`);
+      } else if (typeof value === "object") {
+        const str = JSON.stringify(value);
+        if (str.length < 50) {
+          parts.push(`${key}=${str}`);
         }
-        if (processedParts > 0) {
-            const totalTime = performance.now() - messageStart;
-            logger.debug("Text parts processing complete", {
-                totalTimeMs: totalTime.toFixed(2),
-                skillTimeMs: skillTimeTotal.toFixed(2),
-                snippetExpandTimeMs: expandTimeTotal.toFixed(2),
-                shellTimeMs: shellTimeTotal.toFixed(2),
-                processedParts,
-                injectedCount: allInjected.length,
-            });
-        }
-        return allInjected;
-    };
-    const isIgnoredMessage = (message) => message.parts.some((part) => part.ignored);
-    const isSkillContentMessage = (message) => message.parts.some((part) => part.type === "text" && (part.text || "").includes("<skill_content name="));
-    const isInjectionMarkerMessage = (message) => isIgnoredMessage(message) &&
-        message.parts.some((part) => part.type === "text" && part.text?.startsWith("↳ Injected "));
-    const injectionMarkerPartIdsByMessage = (messages) => {
-        const ids = new Map();
-        for (const message of messages) {
-            if (!message.info.id || !isInjectionMarkerMessage(message))
-                continue;
-            const partIds = message.parts
-                .filter((part) => part.type === "text" && part.text?.startsWith("↳ Injected "))
-                .map((part) => part.id)
-                .filter((id) => !!id);
-            if (partIds.length > 0)
-                ids.set(message.info.id, partIds);
+      } else {
+        parts.push(`${key}=${value}`);
+      }
+    }
+    return parts.join(" ");
+  }
+  getCallerFile() {
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    try {
+      const err = new Error;
+      Error.prepareStackTrace = (_, stack2) => stack2;
+      const stack = err.stack;
+      Error.prepareStackTrace = originalPrepareStackTrace;
+      for (let i = 3;i < stack.length; i++) {
+        const filename = stack[i]?.getFileName();
+        if (filename && !filename.includes("logger.")) {
+          const match = filename.match(/([^/\\]+)\.[tj]s$/);
+          return match ? match[1] : "unknown";
         }
-        return ids;
+      }
+      return "unknown";
+    } catch {
+      return "unknown";
+    }
+  }
+  write(level, component, message, data) {
+    if (this.silent)
+      return;
+    if (level === "DEBUG" && !this.debugEnabled)
+      return;
+    try {
+      this.ensureLogDir();
+      const timestamp = new Date().toISOString();
+      const dataStr = this.formatData(data);
+      const dailyLogDir = join2(this.logDir, "daily");
+      if (!existsSync(dailyLogDir)) {
+        mkdirSync(dailyLogDir, { recursive: true });
+      }
+      const logLine = `${timestamp} ${level.padEnd(5)} ${component}: ${message}${dataStr ? ` | ${dataStr}` : ""}
+`;
+      const logFile = join2(dailyLogDir, `${new Date().toISOString().split("T")[0]}.log`);
+      writeFileSync(logFile, logLine, { flag: "a" });
+    } catch {}
+  }
+  info(message, data) {
+    const component = this.getCallerFile();
+    this.write("INFO", component, message, data);
+  }
+  debug(message, data) {
+    const component = this.getCallerFile();
+    this.write("DEBUG", component, message, data);
+  }
+  warn(message, data) {
+    const component = this.getCallerFile();
+    this.write("WARN", component, message, data);
+  }
+  error(message, data) {
+    const component = this.getCallerFile();
+    this.write("ERROR", component, message, data);
+  }
+}
+var logger = new Logger(undefined, false, false);
+
+// src/loader.ts
+var matter = await importCjs("gray-matter");
+function getGlobalSnippetDirs(globalDir) {
+  if (globalDir)
+    return [globalDir];
+  return [PATHS.SNIPPETS_DIR_ALT, PATHS.SNIPPETS_DIR];
+}
+function getProjectSnippetDirs(projectDir) {
+  const paths = getProjectPaths(projectDir);
+  return [paths.SNIPPETS_DIR_ALT, paths.SNIPPETS_DIR];
+}
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveWritableSnippetDir(projectDir) {
+  const paths = projectDir ? getProjectPaths(projectDir) : { SNIPPETS_DIR: PATHS.SNIPPETS_DIR, SNIPPETS_DIR_ALT: PATHS.SNIPPETS_DIR_ALT };
+  for (const dir of [paths.SNIPPETS_DIR, paths.SNIPPETS_DIR_ALT]) {
+    if (await pathExists(dir))
+      return dir;
+  }
+  return paths.SNIPPETS_DIR;
+}
+async function loadSnippets(projectDir, globalDir) {
+  const snippets = new Map;
+  for (const dir of getGlobalSnippetDirs(globalDir)) {
+    await loadFromDirectory(dir, snippets, "global");
+  }
+  if (projectDir) {
+    for (const dir of getProjectSnippetDirs(projectDir)) {
+      await loadFromDirectory(dir, snippets, "project");
+    }
+  }
+  return snippets;
+}
+async function loadFromDirectory(dir, registry, source) {
+  try {
+    const files = await readdir(dir);
+    for (const file of files) {
+      if (!file.endsWith(CONFIG.SNIPPET_EXTENSION))
+        continue;
+      const snippet = await loadSnippetFile(dir, file, source);
+      if (snippet) {
+        registerSnippet(registry, snippet);
+      }
+    }
+    logger.debug(`Loaded snippets from ${source} directory`, {
+      path: dir,
+      fileCount: files.length
+    });
+  } catch (error) {
+    logger.debug(`${source} snippets directory not found or unreadable`, {
+      path: dir,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+async function loadSnippetFile(dir, filename, source) {
+  try {
+    const name = basename(filename, CONFIG.SNIPPET_EXTENSION);
+    const filePath = join3(dir, filename);
+    const fileContent = await readFile(filePath, "utf8");
+    const parsed = matter(fileContent);
+    const content = parsed.content.trim();
+    const frontmatter = parsed.data;
+    let aliases = [];
+    const aliasSource = frontmatter.aliases ?? frontmatter.alias;
+    if (aliasSource) {
+      if (Array.isArray(aliasSource)) {
+        aliases = aliasSource;
+      } else {
+        aliases = [aliasSource];
+      }
+    }
+    return {
+      name,
+      content,
+      aliases,
+      description: frontmatter.description,
+      filePath,
+      source
     };
-    const countConversationMessages = (messages) => messages.filter((message) => !isIgnoredMessage(message)).length;
-    const messageIdPrefix = (messageId) => {
-        const match = /^msg_([0-9a-f]{12})/.exec(messageId);
-        return match?.[1];
+  } catch (error) {
+    logger.warn("Failed to load snippet file", {
+      filename,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+function registerSnippet(registry, snippet) {
+  const key = snippet.name.toLowerCase();
+  const existing = registry.get(key);
+  if (existing) {
+    for (const alias of existing.aliases) {
+      registry.delete(alias.toLowerCase());
+    }
+  }
+  registry.set(key, snippet);
+  for (const alias of snippet.aliases) {
+    registry.set(alias.toLowerCase(), snippet);
+  }
+}
+function listSnippets(registry) {
+  const seen = new Set;
+  const snippets = [];
+  for (const snippet of registry.values()) {
+    if (!seen.has(snippet.name)) {
+      seen.add(snippet.name);
+      snippets.push(snippet);
+    }
+  }
+  return snippets;
+}
+async function ensureSnippetsDir(projectDir) {
+  const dir = await resolveWritableSnippetDir(projectDir);
+  await mkdir(dir, { recursive: true });
+  return dir;
+}
+async function createSnippet(name, content, options = {}, projectDir) {
+  const dir = await ensureSnippetsDir(projectDir);
+  const filePath = join3(dir, `${name}${CONFIG.SNIPPET_EXTENSION}`);
+  const frontmatter = {};
+  if (options.aliases?.length) {
+    frontmatter.aliases = options.aliases;
+  }
+  if (options.description) {
+    frontmatter.description = options.description;
+  }
+  let fileContent;
+  if (Object.keys(frontmatter).length > 0) {
+    fileContent = matter.stringify(content, frontmatter);
+  } else {
+    fileContent = content;
+  }
+  await writeFile(filePath, fileContent, "utf8");
+  logger.info("Created snippet", { name, path: filePath });
+  return filePath;
+}
+async function deleteSnippet(name, projectDir) {
+  if (projectDir) {
+    const paths = getProjectPaths(projectDir);
+    for (const dir of [paths.SNIPPETS_DIR, paths.SNIPPETS_DIR_ALT]) {
+      const filePath = join3(dir, `${name}${CONFIG.SNIPPET_EXTENSION}`);
+      try {
+        await unlink(filePath);
+        logger.info("Deleted project snippet", { name, path: filePath });
+        return filePath;
+      } catch {}
+    }
+  }
+  for (const dir of [PATHS.SNIPPETS_DIR, PATHS.SNIPPETS_DIR_ALT]) {
+    const filePath = join3(dir, `${name}${CONFIG.SNIPPET_EXTENSION}`);
+    try {
+      await unlink(filePath);
+      logger.info("Deleted global snippet", { name, path: filePath });
+      return filePath;
+    } catch {}
+  }
+  logger.warn("Snippet not found for deletion", { name });
+  return null;
+}
+async function reloadSnippets(registry, projectDir) {
+  registry.clear();
+  const fresh = await loadSnippets(projectDir);
+  for (const [key, value] of fresh) {
+    registry.set(key, value);
+  }
+}
+
+// src/notification.ts
+async function sendIgnoredMessage(client, sessionId, text, messageId) {
+  try {
+    await client.session.prompt({
+      path: { id: sessionId },
+      body: {
+        messageID: messageId,
+        noReply: true,
+        parts: [{ type: "text", text, ignored: true }]
+      }
+    });
+  } catch (error) {
+    logger.error("Failed to send ignored message", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+async function deleteSessionMessage(client, serverUrl, sessionId, messageId) {
+  try {
+    const session = client.session;
+    const sdkResponse = await session.deleteMessage?.({
+      sessionID: sessionId,
+      messageID: messageId
+    });
+    if (sdkResponse)
+      return sdkResponse.data !== false;
+    const legacySession = client.session;
+    const legacyResponse = await legacySession._client?.delete?.({
+      url: "/session/{id}/message/{messageID}",
+      path: { id: sessionId, messageID: messageId }
+    });
+    if (legacyResponse)
+      return legacyResponse.data !== false;
+    const url = new URL(`/session/${encodeURIComponent(sessionId)}/message/${encodeURIComponent(messageId)}`, serverUrl);
+    const fetchResponse = await fetch(url, {
+      method: "DELETE",
+      signal: AbortSignal.timeout(1000)
+    });
+    if (fetchResponse.ok)
+      return true;
+    logger.debug("Failed to delete ignored message", {
+      messageId,
+      status: fetchResponse.status,
+      statusText: fetchResponse.statusText
+    });
+    return false;
+  } catch (error) {
+    logger.debug("Failed to delete ignored message", {
+      messageId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return false;
+  }
+}
+async function deleteSessionPart(client, serverUrl, sessionId, messageId, partId) {
+  try {
+    const legacySession = client.session;
+    const legacyResponse = await legacySession._client?.delete?.({
+      url: "/session/{id}/message/{messageID}/part/{partID}",
+      path: { id: sessionId, messageID: messageId, partID: partId }
+    });
+    if (legacyResponse)
+      return legacyResponse.data !== false;
+    const url = new URL(`/session/${encodeURIComponent(sessionId)}/message/${encodeURIComponent(messageId)}/part/${encodeURIComponent(partId)}`, serverUrl);
+    const fetchResponse = await fetch(url, {
+      method: "DELETE",
+      signal: AbortSignal.timeout(1000)
+    });
+    if (fetchResponse.ok)
+      return true;
+    logger.debug("Failed to delete ignored message part", {
+      messageId,
+      partId,
+      status: fetchResponse.status,
+      statusText: fetchResponse.statusText
+    });
+    return false;
+  } catch (error) {
+    logger.debug("Failed to delete ignored message part", {
+      messageId,
+      partId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return false;
+  }
+}
+
+// src/commands.ts
+var COMMAND_HANDLED_MARKER = "__SNIPPETS_COMMAND_HANDLED__";
+function parseAddOptions(args) {
+  const result = {
+    aliases: [],
+    description: undefined,
+    isProject: false
+  };
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (!arg.startsWith("--")) {
+      continue;
+    }
+    if (arg === "--project") {
+      result.isProject = true;
+      continue;
+    }
+    if (arg === "--alias" || arg === "--aliases") {
+      const nextArg = args[i + 1];
+      if (nextArg && !nextArg.startsWith("--")) {
+        result.aliases = parseAliasValue(nextArg);
+        i++;
+      }
+      continue;
+    }
+    if (arg.startsWith("--alias=") || arg.startsWith("--aliases=")) {
+      const value = arg.includes("--aliases=") ? arg.slice("--aliases=".length) : arg.slice("--alias=".length);
+      result.aliases = parseAliasValue(value);
+      continue;
+    }
+    if (arg === "--desc" || arg === "--description") {
+      const nextArg = args[i + 1];
+      if (nextArg && !nextArg.startsWith("--")) {
+        result.description = nextArg;
+        i++;
+      }
+      continue;
+    }
+    if (arg.startsWith("--desc=") || arg.startsWith("--description=")) {
+      const value = arg.startsWith("--description=") ? arg.slice("--description=".length) : arg.slice("--desc=".length);
+      result.description = value;
+    }
+  }
+  return result;
+}
+function parseAliasValue(value) {
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function createCommandExecuteHandler(client, snippets, projectDir) {
+  return async (input, output) => {
+    if (input.command === "snippets:reload") {
+      if (output) {
+        output.parts.length = 0;
+      }
+      await handleReloadCommand({
+        client,
+        sessionId: input.sessionID,
+        args: [],
+        rawArguments: input.arguments,
+        snippets,
+        projectDir
+      });
+      throw new Error(COMMAND_HANDLED_MARKER);
+    }
+    if (input.command !== "snippets")
+      return;
+    const args = parseCommandArgs(input.arguments);
+    const subcommand = args[0]?.toLowerCase() || "help";
+    const ctx = {
+      client,
+      sessionId: input.sessionID,
+      args: args.slice(1),
+      rawArguments: input.arguments,
+      snippets,
+      projectDir
     };
-    const markerSuffix = (targetPosition, index) => {
-        const suffix = `000${(index + 1).toString(36)}`.slice(-3);
-        if (targetPosition === 0)
-            return `${MARKER_ID_RANDOM_FILL}${suffix}`;
-        return `zzzzzzzzzzz${suffix}`;
+    try {
+      switch (subcommand) {
+        case "add":
+        case "create":
+        case "new":
+          await handleAddCommand(ctx);
+          break;
+        case "delete":
+        case "remove":
+        case "rm":
+          await handleDeleteCommand(ctx);
+          break;
+        case "list":
+        case "ls":
+          await handleListCommand(ctx);
+          break;
+        default:
+          await handleHelpCommand(ctx);
+          break;
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message === COMMAND_HANDLED_MARKER) {
+        throw error;
+      }
+      logger.error("Command execution failed", {
+        subcommand,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      await sendIgnoredMessage(ctx.client, ctx.sessionId, `Error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    throw new Error(COMMAND_HANDLED_MARKER);
+  };
+}
+async function handleAddCommand(ctx) {
+  const { client, sessionId, args, snippets, projectDir } = ctx;
+  if (args.length === 0) {
+    await sendIgnoredMessage(client, sessionId, `Usage: /snippets add <name> ["content"] [options]
+
+` + `Adds a new snippet. Defaults to global directory.
+
+` + `Examples:
+` + `  /snippets add greeting
+` + `  /snippets add bye "see you later"
+` + `  /snippets add hi "hello there" --aliases hello,hey
+` + `  /snippets add fix "fix imports" --project
+
+` + `Options:
+` + `  --project             Add to project directory (.opencode/snippet/)
+` + `  --aliases X,Y,Z       Add aliases (comma-separated)
+` + '  --desc "..."          Add a description');
+    return;
+  }
+  const name = args[0];
+  let content = "";
+  let optionArgs = args.slice(1);
+  if (args[1] && !args[1].startsWith("--")) {
+    content = args[1];
+    optionArgs = args.slice(2);
+  }
+  const options = parseAddOptions(optionArgs);
+  const targetDir = options.isProject ? projectDir : undefined;
+  const location = options.isProject && projectDir ? "project" : "global";
+  try {
+    const filePath = await createSnippet(name, content, { aliases: options.aliases, description: options.description }, targetDir);
+    await reloadSnippets(snippets, projectDir);
+    let message = `Added ${location} snippet: ${name}
+File: ${filePath}`;
+    if (content) {
+      message += `
+Content: "${truncate(content, 50)}"`;
+    } else {
+      message += `
+
+Edit the file to add your snippet content.`;
+    }
+    if (options.aliases.length > 0) {
+      message += `
+Aliases: ${options.aliases.join(", ")}`;
+    }
+    await sendIgnoredMessage(client, sessionId, message);
+  } catch (error) {
+    await sendIgnoredMessage(client, sessionId, `Failed to add snippet: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function handleDeleteCommand(ctx) {
+  const { client, sessionId, args, snippets, projectDir } = ctx;
+  if (args.length === 0) {
+    await sendIgnoredMessage(client, sessionId, `Usage: /snippets delete <name>
+
+Deletes a snippet by name. ` + "Project snippets are checked first, then global.");
+    return;
+  }
+  const name = args[0];
+  const deletedPath = await deleteSnippet(name, projectDir);
+  if (deletedPath) {
+    await reloadSnippets(snippets, projectDir);
+    await sendIgnoredMessage(client, sessionId, `Deleted snippet: #${name}
+Removed: ${deletedPath}`);
+  } else {
+    await sendIgnoredMessage(client, sessionId, `Snippet not found: #${name}
+
+Use /snippets list to see available snippets.`);
+  }
+}
+async function handleReloadCommand(ctx) {
+  const { snippets, projectDir } = ctx;
+  await reloadSnippets(snippets, projectDir);
+}
+var MAX_CONTENT_PREVIEW_LENGTH = 200;
+var MAX_ALIASES_LENGTH = 50;
+var DIVIDER = "────────────────────────────────────────────────";
+function truncate(text, maxLength) {
+  if (text.length <= maxLength)
+    return text;
+  return `${text.slice(0, maxLength - 3)}...`;
+}
+function formatAliases(aliases) {
+  if (aliases.length === 0)
+    return "";
+  const joined = aliases.join(", ");
+  if (joined.length <= MAX_ALIASES_LENGTH) {
+    return ` (aliases: ${joined})`;
+  }
+  const truncated = truncate(joined, MAX_ALIASES_LENGTH - 10);
+  return ` (aliases: ${truncated} +${aliases.length})`;
+}
+function globalSnippetLocations() {
+  return `${PATHS.SNIPPETS_DIR}/ or ${PATHS.SNIPPETS_DIR_ALT}/`;
+}
+function projectSnippetLocations(projectDir) {
+  const paths = getProjectPaths(projectDir);
+  return `${paths.SNIPPETS_DIR}/ or ${paths.SNIPPETS_DIR_ALT}/`;
+}
+function formatSnippetEntry(s) {
+  const header = `${s.name}${formatAliases(s.aliases)}`;
+  const content = truncate(s.content.trim(), MAX_CONTENT_PREVIEW_LENGTH);
+  return `${header}
+${DIVIDER}
+${content || "(empty)"}`;
+}
+async function handleListCommand(ctx) {
+  const { client, sessionId, snippets, projectDir } = ctx;
+  const snippetList = listSnippets(snippets);
+  if (snippetList.length === 0) {
+    await sendIgnoredMessage(client, sessionId, `No snippets found.
+
+` + `Global snippets: ${globalSnippetLocations()}
+` + (projectDir ? `Project snippets: ${projectSnippetLocations(projectDir)}` : "No project directory detected.") + `
+
+Use /snippets add <name> to add a new snippet.`);
+    return;
+  }
+  const lines = [];
+  const globalSnippets = snippetList.filter((s) => s.source === "global");
+  const projectSnippets = snippetList.filter((s) => s.source === "project");
+  if (globalSnippets.length > 0) {
+    lines.push(`── Global (${globalSnippetLocations()}) ──`, "");
+    for (const s of globalSnippets) {
+      lines.push(formatSnippetEntry(s), "");
+    }
+  }
+  if (projectSnippets.length > 0 && projectDir) {
+    lines.push(`── Project (${projectSnippetLocations(projectDir)}) ──`, "");
+    for (const s of projectSnippets) {
+      lines.push(formatSnippetEntry(s), "");
+    }
+  }
+  await sendIgnoredMessage(client, sessionId, lines.join(`
+`).trimEnd());
+}
+async function handleHelpCommand(ctx) {
+  const { client, sessionId } = ctx;
+  const helpText = `Snippets Command - Manage text snippets
+
+Usage: /snippets <command> [options]
+
+Commands:
+  add <name> ["content"] [options]
+    --project               Add to project directory (default: global)
+    --aliases X,Y,Z         Add aliases (comma-separated)
+    --desc "..."            Add a description
+
+  delete <name>             Delete a snippet
+  list                      List all available snippets
+  /snippets:reload          Reload snippet files from disk
+  help                      Show this help message
+
+Snippet Locations:
+  Global:  ~/.config/opencode/snippet/ or ~/.config/opencode/snippets/
+  Project: <project>/.opencode/snippet/ or <project>/.opencode/snippets/
+
+Usage in messages:
+  Type #snippet-name to expand a snippet inline.
+  Snippets can reference other snippets recursively.
+
+Examples:
+  /snippets add greeting
+  /snippets add bye "see you later"
+  /snippets add hi "hello there" --aliases hello,hey
+  /snippets add fix "fix imports" --project
+  /snippets delete old-snippet
+  /snippets list
+  /snippets:reload`;
+  await sendIgnoredMessage(client, sessionId, helpText);
+}
+
+// src/config.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync as writeFileSync2 } from "node:fs";
+var { parse: parseJsonc } = await importCjs("jsonc-parser");
+var DEFAULT_CONFIG = {
+  logging: {
+    debug: false
+  },
+  experimental: {
+    skillRendering: false,
+    skillLoading: false,
+    injectBlocks: false
+  },
+  injectRecencyMessages: 5
+};
+var DEFAULT_CONFIG_CONTENT = `{
+  // JSON Schema for editor autocompletion
+  "$schema": "https://raw.githubusercontent.com/JosXa/opencode-snippets/v3.0.0/schema/config.schema.json",
+
+  // Logging settings
+  "logging": {
+    // Enable debug logging to file
+    // Logs are written to ~/.config/opencode/logs/snippets/daily/
+    // Values: true, false, "enabled", "disabled"
+    // Default: false
+    "debug": false
+  },
+
+  // Experimental features (may change or be removed)
+  "experimental": {
+    // Enable skill rendering with <skill>name</skill> or <skill name="name" /> syntax
+    // When enabled, skill tags are replaced with the skill's content body
+    // Skills are loaded from OpenCode's standard skill directories
+    // Values: true, false, "enabled", "disabled"
+    // Default: false
+    "skillRendering": false,
+
+    // Enable #skill(name) syntax that shows a placeholder inline while injecting
+    // the OpenCode-style <skill_content> payload to the model after the message
+    // Values: true, false, "enabled", "disabled"
+    // Default: false
+    "skillLoading": false
+  },
+
+  // How many messages from the bottom of the conversation to place injected context
+  // Higher = injection feels "older" to the model, lower = closer to recent context
+  // Default: 5
+  "injectRecencyMessages": 5
+}
+`;
+function normalizeBooleanSetting(value) {
+  if (value === undefined)
+    return;
+  if (typeof value === "boolean")
+    return value;
+  if (value === "enabled")
+    return true;
+  if (value === "disabled")
+    return false;
+  return;
+}
+function normalizePositiveInteger(value) {
+  if (value === undefined)
+    return;
+  const parsed = typeof value === "number" ? value : Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 1)
+    return;
+  return Math.floor(parsed);
+}
+function parseJsoncFile(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const parsed = parseJsonc(content);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    logger.warn("Config file has invalid structure, using defaults", { filePath });
+    return {};
+  } catch (error) {
+    logger.warn("Failed to parse config file", {
+      filePath,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return {};
+  }
+}
+function ensureGlobalConfigExists() {
+  if (!existsSync2(PATHS.SNIPPETS_DIR)) {
+    mkdirSync2(PATHS.SNIPPETS_DIR, { recursive: true });
+    logger.debug("Created global snippets directory", { path: PATHS.SNIPPETS_DIR });
+  }
+  if (!existsSync2(PATHS.CONFIG_FILE_GLOBAL)) {
+    writeFileSync2(PATHS.CONFIG_FILE_GLOBAL, DEFAULT_CONFIG_CONTENT, "utf-8");
+    logger.debug("Created default config file", { path: PATHS.CONFIG_FILE_GLOBAL });
+  }
+}
+function loadConfig(projectDir) {
+  ensureGlobalConfigExists();
+  let config = structuredClone(DEFAULT_CONFIG);
+  if (existsSync2(PATHS.CONFIG_FILE_GLOBAL)) {
+    const globalConfig = parseJsoncFile(PATHS.CONFIG_FILE_GLOBAL);
+    config = mergeConfig(config, globalConfig);
+    logger.debug("Loaded global config", { path: PATHS.CONFIG_FILE_GLOBAL });
+  }
+  if (projectDir) {
+    const projectPaths = getProjectPaths(projectDir);
+    if (existsSync2(projectPaths.CONFIG_FILE)) {
+      const projectConfig = parseJsoncFile(projectPaths.CONFIG_FILE);
+      config = mergeConfig(config, projectConfig);
+      logger.debug("Loaded project config", { path: projectPaths.CONFIG_FILE });
+    }
+  }
+  logger.debug("Final config", {
+    loggingDebug: config.logging.debug,
+    experimentalSkillRendering: config.experimental.skillRendering,
+    experimentalSkillLoading: config.experimental.skillLoading,
+    injectRecencyMessages: config.injectRecencyMessages
+  });
+  return config;
+}
+function mergeConfig(base, raw) {
+  const debugValue = normalizeBooleanSetting(raw.logging?.debug);
+  const skillRenderingValue = normalizeBooleanSetting(raw.experimental?.skillRendering);
+  const skillLoadingValue = normalizeBooleanSetting(raw.experimental?.skillLoading);
+  const injectBlocksValue = normalizeBooleanSetting(raw.experimental?.injectBlocks);
+  const injectRecencyValue = normalizePositiveInteger(raw.injectRecencyMessages);
+  return {
+    logging: {
+      debug: debugValue !== undefined ? debugValue : base.logging.debug
+    },
+    experimental: {
+      skillRendering: skillRenderingValue !== undefined ? skillRenderingValue : base.experimental.skillRendering,
+      skillLoading: skillLoadingValue !== undefined ? skillLoadingValue : base.experimental.skillLoading,
+      injectBlocks: injectBlocksValue !== undefined ? injectBlocksValue : base.experimental.injectBlocks
+    },
+    injectRecencyMessages: injectRecencyValue !== undefined ? injectRecencyValue : base.injectRecencyMessages
+  };
+}
+
+// src/expander.ts
+var MAX_EXPANSION_COUNT = 15;
+var BLOCK_TYPES = ["prepend", "append", "inject"];
+function createCollector() {
+  return {
+    prepend: [],
+    append: [],
+    inject: [],
+    seen: new Set
+  };
+}
+function addBlock(collector, type, snippetName, content, onInjectBlock) {
+  if (!content)
+    return;
+  const key = `${type}\x00${snippetName.toLowerCase()}\x00${content}`;
+  if (collector.seen.has(key))
+    return;
+  collector.seen.add(key);
+  collector[type].push({ type, snippetName, content });
+  if (type === "inject") {
+    onInjectBlock?.({ snippetName, content });
+  }
+}
+function addNestedBlocks(collector, nested, onInjectBlock) {
+  for (const type of BLOCK_TYPES) {
+    for (const block of nested[type]) {
+      addBlock(collector, type, block.snippetName, block.content, onInjectBlock);
+    }
+  }
+}
+function expandBlock(block, registry, expansionCounts, options) {
+  const nested = createCollector();
+  const content = expandText(block, registry, expansionCounts, nested, {
+    ...options,
+    onInjectBlock: undefined
+  });
+  return { content, nested };
+}
+function expandText(text, registry, expansionCounts, collector, options) {
+  const { onInjectBlock } = options;
+  let expanded = text;
+  let hasChanges = true;
+  while (hasChanges) {
+    const previous = expanded;
+    let loopDetected = false;
+    PATTERNS.HASHTAG.lastIndex = 0;
+    expanded = expanded.replace(PATTERNS.HASHTAG, (match, name, offset, input) => {
+      if (name.toLowerCase() === "skill" && input[offset + match.length] === "(") {
+        return match;
+      }
+      const snippet = registry.get(name.toLowerCase());
+      if (snippet === undefined) {
+        return match;
+      }
+      const key = snippet.name.toLowerCase();
+      const count = (expansionCounts.get(key) || 0) + 1;
+      if (count > MAX_EXPANSION_COUNT) {
+        logger.warn(`Loop detected: snippet '#${key}' expanded ${count} times (max: ${MAX_EXPANSION_COUNT})`);
+        loopDetected = true;
+        return match;
+      }
+      expansionCounts.set(key, count);
+      const parsed = parseSnippetBlocks(snippet.content, options);
+      if (parsed === null) {
+        logger.warn(`Failed to parse snippet '${key}', leaving hashtag unchanged`);
+        return match;
+      }
+      if (parsed.inline === "" && parsed.prepend.length === 0 && parsed.append.length === 0 && parsed.inject.length === 0) {
+        return match;
+      }
+      for (const block of parsed.prepend) {
+        const expanded2 = expandBlock(block, registry, expansionCounts, options);
+        addBlock(collector, "prepend", snippet.name, expanded2.content, onInjectBlock);
+        addNestedBlocks(collector, expanded2.nested, onInjectBlock);
+      }
+      for (const block of parsed.append) {
+        const expanded2 = expandBlock(block, registry, expansionCounts, options);
+        addBlock(collector, "append", snippet.name, expanded2.content, onInjectBlock);
+        addNestedBlocks(collector, expanded2.nested, onInjectBlock);
+      }
+      for (const block of parsed.inject) {
+        const expanded2 = expandBlock(block, registry, expansionCounts, options);
+        addBlock(collector, "inject", snippet.name, expanded2.content, onInjectBlock);
+        addNestedBlocks(collector, expanded2.nested, onInjectBlock);
+      }
+      return expandText(parsed.inline, registry, expansionCounts, collector, options);
+    });
+    hasChanges = expanded !== previous && !loopDetected;
+  }
+  return expanded;
+}
+function parseSnippetBlocks(content, options = {}) {
+  const { extractInject = true } = options;
+  const prepend = [];
+  const append = [];
+  const inject = [];
+  let inline = "";
+  const tagTypes = extractInject ? "prepend|append|inject" : "prepend|append";
+  const tagPattern = new RegExp(`<(/?)(?<tagName>${tagTypes})>`, "gi");
+  let lastIndex = 0;
+  let currentBlock = null;
+  let match = tagPattern.exec(content);
+  while (match !== null) {
+    const isClosing = match[1] === "/";
+    const tagName = match.groups?.tagName?.toLowerCase();
+    const tagStart = match.index;
+    const tagEnd = tagStart + match[0].length;
+    if (isClosing) {
+      if (currentBlock === null) {
+        continue;
+      }
+      if (currentBlock.type !== tagName) {
+        logger.warn(`Mismatched closing tag: expected </${currentBlock.type}>, found </${tagName}>`);
+        return null;
+      }
+      const blockContent = content.slice(currentBlock.contentStart, tagStart).trim();
+      if (blockContent) {
+        if (currentBlock.type === "prepend") {
+          prepend.push(blockContent);
+        } else if (currentBlock.type === "append") {
+          append.push(blockContent);
+        } else {
+          inject.push(blockContent);
+        }
+      }
+      lastIndex = tagEnd;
+      currentBlock = null;
+    } else {
+      if (currentBlock !== null) {
+        logger.warn(`Nested tags not allowed: found <${tagName}> inside <${currentBlock.type}>`);
+        return null;
+      }
+      const inlinePart = content.slice(lastIndex, tagStart);
+      inline += inlinePart;
+      currentBlock = { type: tagName, startIndex: tagStart, contentStart: tagEnd };
+    }
+    match = tagPattern.exec(content);
+  }
+  if (currentBlock !== null) {
+    const blockContent = content.slice(currentBlock.contentStart).trim();
+    if (blockContent) {
+      if (currentBlock.type === "prepend") {
+        prepend.push(blockContent);
+      } else if (currentBlock.type === "append") {
+        append.push(blockContent);
+      } else {
+        inject.push(blockContent);
+      }
+    }
+  } else {
+    inline += content.slice(lastIndex);
+  }
+  return {
+    inline: inline.trim(),
+    prepend,
+    append,
+    inject
+  };
+}
+function expandHashtags(text, registry, expansionCounts = new Map, options = {}) {
+  const collector = createCollector();
+  const expanded = expandText(text, registry, expansionCounts, collector, options);
+  return {
+    text: expanded,
+    prepend: collector.prepend.map((block) => block.content),
+    append: collector.append.map((block) => block.content),
+    inject: collector.inject.map((block) => block.content)
+  };
+}
+function assembleMessage(result) {
+  const parts = [];
+  if (result.prepend.length > 0) {
+    parts.push(result.prepend.join(`
+
+`));
+  }
+  if (result.text.trim()) {
+    parts.push(result.text);
+  }
+  if (result.append.length > 0) {
+    parts.push(result.append.join(`
+
+`));
+  }
+  return parts.join(`
+
+`);
+}
+
+// src/injection-manager.ts
+class InjectionManager {
+  activeInjections = new Map;
+  nextOrder = 0;
+  touchInjections(sessionID, injections) {
+    if (injections.length === 0)
+      return false;
+    const session = this.getOrCreateSession(sessionID);
+    let hasNew = false;
+    for (const injection of injections) {
+      const key = this.getInjectionKey(injection);
+      const existing = session.get(key);
+      if (existing) {
+        existing.snippetName = injection.snippetName;
+        existing.content = injection.content;
+        continue;
+      }
+      session.set(key, {
+        ...injection,
+        key,
+        order: this.nextOrder++
+      });
+      hasNew = true;
+    }
+    return hasNew;
+  }
+  getRenderableInjections(sessionID, messageCount, recencyWindow) {
+    const session = this.activeInjections.get(sessionID);
+    if (!session || session.size === 0) {
+      return { injections: [], newlyRegistered: [] };
+    }
+    const window = Math.max(1, recencyWindow);
+    const targetPosition = Math.max(0, messageCount - window);
+    const injections = [...session.values()].sort((a, b) => a.order - b.order).map((injection) => ({
+      ...injection,
+      targetPosition
+    }));
+    return { injections, newlyRegistered: [] };
+  }
+  registerAndGetNew(sessionID, descriptors) {
+    if (descriptors.length === 0)
+      return [];
+    const session = this.getOrCreateSession(sessionID);
+    const newOnes = [];
+    for (const desc of descriptors) {
+      const key = this.getInjectionKey(desc);
+      const existing = session.get(key);
+      if (existing) {
+        existing.snippetName = desc.snippetName;
+        existing.content = desc.content;
+        continue;
+      }
+      const injection = {
+        ...desc,
+        key,
+        order: this.nextOrder++
+      };
+      session.set(key, injection);
+      newOnes.push(injection);
+    }
+    return newOnes;
+  }
+  clearSession(sessionID) {
+    if (this.activeInjections.has(sessionID)) {
+      this.activeInjections.delete(sessionID);
+      logger.debug("Cleared active injections", { sessionID });
+    }
+  }
+  getOrCreateSession(sessionID) {
+    let session = this.activeInjections.get(sessionID);
+    if (!session) {
+      session = new Map;
+      this.activeInjections.set(sessionID, session);
+    }
+    return session;
+  }
+  getInjectionKey(injection) {
+    return `${injection.snippetName}\x00${injection.content}`;
+  }
+}
+
+// src/pending-drafts.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+function statePath() {
+  return join4(PATHS.CONFIG_DIR, "state", "pending-drafts.json");
+}
+function scopeKey(workspaceDir) {
+  return workspaceDir || "__global__";
+}
+function normalizeNames(names) {
+  return [...new Set(names.map((name) => name.trim().toLowerCase()).filter(Boolean))];
+}
+function normalizeState(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return {};
+  return Object.fromEntries(Object.entries(value).filter(([, names]) => Array.isArray(names)).map(([key, names]) => [
+    key,
+    normalizeNames(names.filter((name) => typeof name === "string"))
+  ]).filter(([, names]) => names.length > 0));
+}
+async function readState() {
+  try {
+    return normalizeState(JSON.parse(await readFile2(statePath(), "utf8")));
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return {};
+    logger.warn("Failed to read pending draft state", {
+      error: error instanceof Error ? error.message : String(error),
+      path: statePath()
+    });
+    return {};
+  }
+}
+async function writeState(state) {
+  await mkdir2(join4(PATHS.CONFIG_DIR, "state"), { recursive: true });
+  await writeFile2(statePath(), `${JSON.stringify(state, null, 2)}
+`, "utf8");
+}
+function usedHashtags(text) {
+  const used = new Set;
+  const pattern = new RegExp(PATTERNS.HASHTAG);
+  for (const match of text.matchAll(pattern)) {
+    const token = match[0] || "";
+    const name = match[1]?.toLowerCase();
+    const index = match.index ?? -1;
+    if (!name || index < 0)
+      continue;
+    if (name === "skill" && text[index + token.length] === "(")
+      continue;
+    used.add(name);
+  }
+  return used;
+}
+async function getPendingDrafts(workspaceDir) {
+  const state = await readState();
+  return state[scopeKey(workspaceDir)] || [];
+}
+async function removePendingDrafts(workspaceDir, names) {
+  const key = scopeKey(workspaceDir);
+  const remove = new Set(normalizeNames(names));
+  if (remove.size === 0)
+    return;
+  const state = await readState();
+  const next = (state[key] || []).filter((name) => !remove.has(name));
+  if (next.length > 0) {
+    state[key] = next;
+  } else {
+    delete state[key];
+  }
+  await writeState(state);
+}
+async function refreshPendingDraftsForText(text, registry, workspaceDir, reload) {
+  const pending = await getPendingDrafts(workspaceDir);
+  if (pending.length === 0)
+    return;
+  const used = usedHashtags(text);
+  const matched = pending.filter((name) => used.has(name));
+  if (matched.length === 0)
+    return;
+  await reload();
+  const resolved = matched.filter((name) => {
+    const snippet = registry.get(name);
+    return !!snippet?.content.trim();
+  });
+  if (resolved.length === 0)
+    return;
+  await removePendingDrafts(workspaceDir, resolved);
+}
+
+// src/reload-signal.ts
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+function statePath2() {
+  return join5(PATHS.CONFIG_DIR, "state", "snippet-reload.json");
+}
+function scopeKey2(workspaceDir) {
+  return workspaceDir || "__global__";
+}
+function normalizeState2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return {};
+  return Object.fromEntries(Object.entries(value).filter(([, stamp]) => typeof stamp === "number" && Number.isFinite(stamp)).map(([key, stamp]) => [key, stamp]));
+}
+async function readState2() {
+  try {
+    return normalizeState2(JSON.parse(await readFile3(statePath2(), "utf8")));
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return {};
+    logger.warn("Failed to read snippet reload signal", {
+      error: error instanceof Error ? error.message : String(error),
+      path: statePath2()
+    });
+    return {};
+  }
+}
+async function writeState2(state) {
+  await mkdir3(join5(PATHS.CONFIG_DIR, "state"), { recursive: true });
+  await writeFile3(statePath2(), `${JSON.stringify(state, null, 2)}
+`, "utf8");
+}
+async function consumeSnippetReloadRequest(workspaceDir) {
+  const key = scopeKey2(workspaceDir);
+  const state = await readState2();
+  if (typeof state[key] !== "number")
+    return false;
+  delete state[key];
+  await writeState2(state);
+  return true;
+}
+
+// src/shell.ts
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+var execAsync = promisify(exec);
+async function executeShellCommands(text, ctx) {
+  let result = text;
+  PATTERNS.SHELL_COMMAND.lastIndex = 0;
+  const matches = [...text.matchAll(PATTERNS.SHELL_COMMAND)];
+  for (const match of matches) {
+    const showCommand = match[1] === "!>";
+    const cmd = match[2];
+    const _placeholder = match[0];
+    try {
+      const output = await execAsync(cmd, { cwd: ctx.directory });
+      const text2 = `${output.stdout}${output.stderr}`.trim();
+      const replacement = showCommand ? `$ ${cmd}
+--> ${text2}` : text2;
+      result = result.replace(_placeholder, replacement);
+    } catch (error) {
+      logger.warn("Shell command execution failed", {
+        command: cmd,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return result;
+}
+
+// src/skill-load-manager.ts
+class SkillLoadManager {
+  loads = new Map;
+  pending = new Map;
+  sessionPayloads = new Map;
+  register(sessionID, messageID, payloads) {
+    const session = this.getOrCreateSession(sessionID);
+    session.set(messageID, [...payloads]);
+  }
+  queue(sessionID, payloads, messageID) {
+    const session = this.pending.get(sessionID) || [];
+    session.push({ messageID, payloads: [...payloads] });
+    this.pending.set(sessionID, session);
+  }
+  get(sessionID, messageID) {
+    return [...this.loads.get(sessionID)?.get(messageID) || []];
+  }
+  rememberForSession(sessionID, payloads) {
+    const existing = this.sessionPayloads.get(sessionID) || [];
+    const seen = new Set(existing);
+    const merged = [...existing];
+    for (const payload of payloads) {
+      if (seen.has(payload))
+        continue;
+      seen.add(payload);
+      merged.push(payload);
+    }
+    this.sessionPayloads.set(sessionID, merged);
+  }
+  getSessionPayloads(sessionID) {
+    return [...this.sessionPayloads.get(sessionID) || []];
+  }
+  clearSession(sessionID) {
+    this.loads.delete(sessionID);
+    this.pending.delete(sessionID);
+    this.sessionPayloads.delete(sessionID);
+  }
+  drainPending(sessionID) {
+    const queued = this.pending.get(sessionID) || [];
+    this.pending.delete(sessionID);
+    return queued.map((entry) => ({
+      messageID: entry.messageID,
+      payloads: [...entry.payloads]
+    }));
+  }
+  getOrCreateSession(sessionID) {
+    const existing = this.loads.get(sessionID);
+    if (existing)
+      return existing;
+    const created = new Map;
+    this.loads.set(sessionID, created);
+    return created;
+  }
+}
+
+// src/skill-loader.ts
+import { readdir as readdir2, readFile as readFile4, stat } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname, join as join6, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var matter2 = await importCjs("gray-matter");
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+function getGlobalSkillDirs(homeDir = homedir2()) {
+  return [
+    join6(homeDir, ".config", "opencode", "skill"),
+    join6(homeDir, ".config", "opencode", "skills"),
+    join6(homeDir, ".claude", "skills"),
+    join6(homeDir, ".agents", "skills")
+  ];
+}
+function getProjectSkillDirs(projectDir) {
+  return [
+    join6(projectDir, ".opencode", "skill"),
+    join6(projectDir, ".opencode", "skills"),
+    join6(projectDir, ".claude", "skills"),
+    join6(projectDir, ".agents", "skills")
+  ];
+}
+function getBundledSkillDirs() {
+  return [join6(__dirname2, "..", "..", "skill")];
+}
+function uniqueDirs(dirs) {
+  const seen = new Set;
+  const result = [];
+  for (const dir of dirs) {
+    const key = resolve(dir);
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    result.push(dir);
+  }
+  return result;
+}
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getProjectSearchRoots(projectDir) {
+  const roots = [];
+  let dir = resolve(projectDir);
+  while (true) {
+    roots.push(dir);
+    if (await exists(join6(dir, ".git"))) {
+      break;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return roots.reverse();
+}
+async function loadSkills(projectDir, options = {}) {
+  const skills = new Map;
+  const bundledDirs = options.bundledSkillDirs || getBundledSkillDirs();
+  for (const dir of uniqueDirs([...bundledDirs, ...options.opencodeSkillDirs || []])) {
+    await loadFromDirectory2(dir, skills, "global");
+  }
+  if (options.opencodeSkillDirs && options.opencodeSkillDirs.length > 0) {
+    logger.debug("Loaded OpenCode-exposed skill directories", { paths: options.opencodeSkillDirs });
+  }
+  for (const dir of getGlobalSkillDirs(options.homeDir)) {
+    await loadFromDirectory2(dir, skills, "global");
+  }
+  if (projectDir) {
+    for (const root of await getProjectSearchRoots(projectDir)) {
+      for (const dir of getProjectSkillDirs(root)) {
+        await loadFromDirectory2(dir, skills, "project");
+      }
+    }
+  }
+  logger.debug("Skills loaded", { count: skills.size });
+  return skills;
+}
+async function loadFromDirectory2(dir, registry, source) {
+  try {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const skill = await loadSkill(dir, entry.name, source);
+      if (skill) {
+        registry.set(skill.name.toLowerCase(), skill);
+      }
+    }
+    logger.debug(`Loaded skills from ${source} directory`, { path: dir });
+  } catch {
+    logger.debug(`${source} skill directory not found`, { path: dir });
+  }
+}
+async function loadSkill(baseDir, skillName, source) {
+  const filePath = join6(baseDir, skillName, "SKILL.md");
+  try {
+    const fileContent = await readFile4(filePath, "utf8");
+    const parsed = matter2(fileContent);
+    const content = parsed.content.trim();
+    const frontmatter = parsed.data;
+    const name = frontmatter.name || skillName;
+    return {
+      name,
+      content,
+      description: frontmatter.description,
+      source,
+      filePath
     };
-    const buildMarkerMessageId = (messages, targetPosition, index) => {
-        const realMessages = messages.filter((message) => !isIgnoredMessage(message));
-        const pivot = realMessages[Math.max(0, Math.min(realMessages.length - 1, targetPosition - 1))];
-        if (!pivot?.info.id)
-            return undefined;
-        const prefix = messageIdPrefix(pivot.info.id);
-        if (!prefix)
-            return undefined;
-        return `msg_${prefix}${markerSuffix(targetPosition, index)}`;
+  } catch (error) {
+    logger.warn("Failed to load skill", {
+      skillName,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+function getSkill(registry, name) {
+  return registry.get(name.toLowerCase());
+}
+
+// src/skill-loading.ts
+import { readdir as readdir3 } from "node:fs/promises";
+import { dirname as dirname2, resolve as resolve2 } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// src/skill-renderer.ts
+function expandSkillTags(text, registry) {
+  let expanded = text;
+  PATTERNS.SKILL_TAG_SELF_CLOSING.lastIndex = 0;
+  expanded = expanded.replace(PATTERNS.SKILL_TAG_SELF_CLOSING, (match, name) => {
+    const key = name.trim().toLowerCase();
+    const skill = registry.get(key);
+    if (!skill) {
+      logger.warn(`Skill not found: '${name}', leaving tag unchanged`);
+      return match;
+    }
+    logger.debug(`Expanded skill tag: ${name}`, { source: skill.source });
+    return skill.content;
+  });
+  PATTERNS.SKILL_TAG_BLOCK.lastIndex = 0;
+  expanded = expanded.replace(PATTERNS.SKILL_TAG_BLOCK, (match, name) => {
+    const key = name.trim().toLowerCase();
+    const skill = registry.get(key);
+    if (!skill) {
+      logger.warn(`Skill not found: '${name}', leaving tag unchanged`);
+      return match;
+    }
+    logger.debug(`Expanded skill tag: ${name}`, { source: skill.source });
+    return skill.content;
+  });
+  return expanded;
+}
+
+// src/skill-loading.ts
+var SKILL_FILE_LIMIT = 10;
+function visibleSkillLoad(skill) {
+  return `↳ Loaded ${skill.name}`;
+}
+function pluginNote(skill, marker) {
+  return `Plugin note: \`${marker}\` is not instruction. Do not call \`skill\` again for ${skill.name}.`;
+}
+async function expandSkillLoads(text, registry, snippets, options) {
+  PATTERNS.SKILL_LOAD.lastIndex = 0;
+  const matches = [...text.matchAll(PATTERNS.SKILL_LOAD)];
+  if (matches.length === 0) {
+    return { text, payloads: [] };
+  }
+  let result = "";
+  let lastIndex = 0;
+  const payloads = [];
+  for (const match of matches) {
+    const index = match.index ?? 0;
+    const token = match[0];
+    const parsed = parseSkillName(match[1]);
+    result += text.slice(lastIndex, index);
+    lastIndex = index + token.length;
+    if (!parsed) {
+      result += token;
+      continue;
+    }
+    const skill = getSkill(registry, parsed);
+    if (!skill) {
+      logger.warn(`Skill not found: '${parsed}', leaving syntax unchanged`);
+      result += token;
+      continue;
+    }
+    const marker = visibleSkillLoad(skill);
+    payloads.push(await buildSkillPayload(skill, registry, snippets, marker, options));
+    result += marker;
+  }
+  result += text.slice(lastIndex);
+  return { text: result, payloads };
+}
+async function buildSkillPayloadsFromVisibleText(text, registry, snippets, options) {
+  if (!text.includes("↳ Loaded ")) {
+    return [];
+  }
+  const matches = [];
+  const skills = [...registry.values()].map((skill) => ({ skill, marker: visibleSkillLoad(skill) })).toSorted((a, b) => b.marker.length - a.marker.length);
+  for (const entry of skills) {
+    let from = 0;
+    while (from < text.length) {
+      const start = text.indexOf(entry.marker, from);
+      if (start === -1) {
+        break;
+      }
+      const end = start + entry.marker.length;
+      const overlaps = matches.some((match) => start < match.end && end > match.start);
+      if (!overlaps) {
+        matches.push({ start, end, skill: entry.skill, marker: entry.marker });
+        break;
+      }
+      from = start + 1;
+    }
+  }
+  if (matches.length === 0) {
+    return [];
+  }
+  matches.sort((a, b) => a.start - b.start);
+  return Promise.all(matches.map((match) => buildSkillPayload(match.skill, registry, snippets, match.marker, options)));
+}
+function parseSkillName(input) {
+  if (!input)
+    return null;
+  const trimmed = input.trim();
+  if (!trimmed)
+    return null;
+  const quote = trimmed[0];
+  if ((quote === '"' || quote === "'") && trimmed.at(-1) === quote) {
+    const inner = trimmed.slice(1, -1).trim();
+    return inner || null;
+  }
+  return trimmed;
+}
+async function buildSkillPayload(skill, registry, _snippets, marker, options) {
+  const dir = dirname2(skill.filePath);
+  const base = pathToFileURL(dir).href;
+  const files = await listSkillFiles(dir, SKILL_FILE_LIMIT);
+  const content = renderSkillContent(skill.content, registry, options);
+  return [
+    `<skill_content name="${skill.name}">`,
+    pluginNote(skill, marker),
+    "",
+    `# Skill: ${skill.name}`,
+    "",
+    content,
+    "",
+    `Base directory for this skill: ${base}`,
+    "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.",
+    "Note: file list is sampled.",
+    "",
+    "<skill_files>",
+    files.map((file) => `<file>${file}</file>`).join(`
+`),
+    "</skill_files>",
+    "</skill_content>"
+  ].join(`
+`);
+}
+function renderSkillContent(content, registry, options) {
+  let processed = content;
+  if (options.expandSkillTagsInContent) {
+    processed = expandSkillTags(processed, registry);
+  }
+  return processed;
+}
+async function listSkillFiles(dir, limit) {
+  const files = [];
+  await walkSkillFiles(dir, files, limit);
+  return files;
+}
+async function walkSkillFiles(dir, files, limit) {
+  if (files.length >= limit)
+    return;
+  const entries = await readdir3(dir, { withFileTypes: true, encoding: "utf8" }).catch(() => null);
+  if (!entries)
+    return;
+  for (const entry of entries.toSorted((a, b) => a.name.localeCompare(b.name))) {
+    if (files.length >= limit)
+      return;
+    const filePath = resolve2(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkSkillFiles(filePath, files, limit);
+      continue;
+    }
+    if (!entry.isFile())
+      continue;
+    if (filePath.includes("SKILL.md"))
+      continue;
+    files.push(filePath);
+  }
+}
+
+// index.ts
+var __filename3 = fileURLToPath2(import.meta.url);
+var __dirname3 = dirname3(__filename3);
+var PLUGIN_ROOT = join7(__dirname3, "..");
+var SKILL_DIR = join7(PLUGIN_ROOT, "skill");
+var MARKER_ID_RANDOM_FILL = "0000000000";
+async function cleanupLegacySkillInstall() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  if (!home)
+    return;
+  const legacySkillDir = join7(home, ".config", "opencode", "skill", "snippets");
+  const legacySkillPath = join7(legacySkillDir, "SKILL.md");
+  try {
+    await access2(legacySkillPath);
+    await unlink2(legacySkillPath);
+    logger.debug("Cleaned up legacy skill file", { path: legacySkillPath });
+    await rmdir(legacySkillDir).catch(() => {});
+  } catch (err) {
+    logger.debug("Failed to cleanup legacy skill", { error: String(err) });
+  }
+}
+var SnippetsPlugin = async (ctx) => {
+  const config = loadConfig(ctx.directory);
+  logger.debugEnabled = config.logging.debug;
+  cleanupLegacySkillInstall();
+  const startupStart = performance.now();
+  const snippets = await loadSnippets(ctx.directory);
+  const opencodeSkillDirs = [];
+  const loadRuntimeSkills = () => loadSkills(ctx.directory, { opencodeSkillDirs });
+  let skills = new Map;
+  if (config.experimental.skillRendering || config.experimental.skillLoading) {
+    skills = await loadRuntimeSkills();
+  }
+  const startupTime = performance.now() - startupStart;
+  logger.debug("Plugin startup complete", {
+    startupTimeMs: startupTime.toFixed(2),
+    snippetCount: snippets.size,
+    skillCount: skills.size,
+    skillRenderingEnabled: config.experimental.skillRendering,
+    skillLoadingEnabled: config.experimental.skillLoading,
+    injectBlocksEnabled: config.experimental.injectBlocks,
+    debugLogging: config.logging.debug
+  });
+  const commandHandler = createCommandExecuteHandler(ctx.client, snippets, ctx.directory);
+  const injectionManager = new InjectionManager;
+  const skillLoadManager = new SkillLoadManager;
+  const injectionMarkerIdsBySession = new Map;
+  const injectionMarkerRenderQueueBySession = new Map;
+  const processTextParts = async (parts) => {
+    const messageStart = performance.now();
+    let expandTimeTotal = 0;
+    let skillTimeTotal = 0;
+    let shellTimeTotal = 0;
+    let processedParts = 0;
+    const allInjected = [];
+    const expandOptions = {
+      extractInject: config.experimental.injectBlocks,
+      onInjectBlock: (block) => {
+        allInjected.push(block);
+      }
     };
-    const getPersistedMessages = async (sessionID) => {
-        try {
-            const response = await ctx.client.session.messages({ path: { id: sessionID } });
-            return (response.data || []).map((message) => ({
-                info: message.info,
-                parts: message.parts,
-            }));
+    for (const part of parts) {
+      if (part.type === "text" && part.text) {
+        if (config.experimental.skillRendering && skills.size > 0) {
+          const skillStart = performance.now();
+          part.text = expandSkillTags(part.text, skills);
+          skillTimeTotal += performance.now() - skillStart;
         }
-        catch (error) {
-            logger.debug("Failed to load session messages for injection markers", {
-                sessionID,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return [];
-        }
-    };
-    const renderInjectionMarkers = async (sessionID, messages, injections) => {
-        if (injections.length === 0)
+        const skillPayloads = [];
+        const loadSkills2 = async () => {
+          if (!config.experimental.skillLoading || skills.size === 0)
             return;
-        const next = new Set();
-        const pending = [];
-        injections.forEach((injection, index) => {
-            const id = buildMarkerMessageId(messages, injection.targetPosition, index);
-            if (!id)
-                return;
-            next.add(id);
-            pending.push({ id, text: `↳ Injected ${injection.snippetName}` });
-        });
-        const persistedMarkerIds = messages
-            .filter(isInjectionMarkerMessage)
-            .map((message) => message.info.id)
-            .filter((id) => !!id);
-        const persistedMarkerPartIds = injectionMarkerPartIdsByMessage(messages);
-        const previous = new Set([
-            ...persistedMarkerIds,
-            ...(injectionMarkerIdsBySession.get(sessionID) || []),
-        ]);
-        const kept = new Set();
-        const current = new Set();
-        logger.debug("Rendering injection markers", {
-            sessionID,
-            messageCount: countConversationMessages(messages),
-            injectionCount: injections.length,
-            nextMarkerIds: [...next],
-            persistedMarkerIds,
-            persistedMarkerPartIds: Object.fromEntries(persistedMarkerPartIds),
-            previousMarkerIds: [...previous],
-        });
-        for (const id of previous) {
-            if (!next.has(id)) {
-                let deleted = true;
-                for (const partId of persistedMarkerPartIds.get(id) || []) {
-                    const partDeleted = await deleteSessionPart(ctx.client, ctx.serverUrl, sessionID, id, partId);
-                    if (!partDeleted)
-                        deleted = false;
-                }
-                const messageDeleted = await deleteSessionMessage(ctx.client, ctx.serverUrl, sessionID, id);
-                if (!messageDeleted)
-                    deleted = false;
-                if (!deleted)
-                    kept.add(id);
-            }
+          const skillLoadResult = await expandSkillLoads(part.text || "", skills, snippets, {
+            expandSkillTagsInContent: config.experimental.skillRendering,
+            extractInject: config.experimental.injectBlocks
+          });
+          part.text = skillLoadResult.text;
+          skillPayloads.push(...skillLoadResult.payloads);
+        };
+        if (config.experimental.skillLoading && skills.size > 0) {
+          const skillStart = performance.now();
+          await loadSkills2();
+          skillTimeTotal += performance.now() - skillStart;
         }
-        if (kept.size > 0) {
-            logger.debug("Skipping injection marker creation until stale markers delete", {
-                sessionID,
-                keptMarkerIds: [...kept],
-                nextMarkerIds: [...next],
-            });
-            injectionMarkerIdsBySession.set(sessionID, kept);
-            return;
+        const expandStart = performance.now();
+        if (await consumeSnippetReloadRequest(ctx.directory)) {
+          const fresh = await loadSnippets(ctx.directory);
+          snippets.clear();
+          for (const [key, value] of fresh) {
+            snippets.set(key, value);
+          }
         }
-        for (const marker of pending) {
-            current.add(marker.id);
-            if (!previous.has(marker.id)) {
-                await sendIgnoredMessage(ctx.client, sessionID, marker.text, marker.id);
+        await refreshPendingDraftsForText(part.text, snippets, ctx.directory, async () => {
+          await loadSnippets(ctx.directory).then((fresh) => {
+            snippets.clear();
+            for (const [key, value] of fresh) {
+              snippets.set(key, value);
             }
+          });
+        });
+        const expansionResult = expandHashtags(part.text, snippets, new Map, expandOptions);
+        part.text = assembleMessage(expansionResult);
+        expandTimeTotal += performance.now() - expandStart;
+        if (config.experimental.skillLoading && skills.size > 0) {
+          const skillStart = performance.now();
+          await loadSkills2();
+          part.skillLoads = skillPayloads;
+          skillTimeTotal += performance.now() - skillStart;
         }
-        injectionMarkerIdsBySession.set(sessionID, current);
-    };
-    const scheduleInjectionMarkerRender = (sessionID, messages, injections) => {
-        const previous = injectionMarkerRenderQueueBySession.get(sessionID) || Promise.resolve();
-        const next = previous
-            .catch(() => undefined)
-            .then(() => new Promise((resolve) => {
-            // User requirement: marker maintenance must not block the real prompt.
-            setTimeout(() => {
-                renderInjectionMarkers(sessionID, messages, injections).then(resolve, (error) => {
-                    logger.debug("Failed to render injection markers", {
-                        sessionID,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                    resolve();
-                });
-            }, 0);
-        }));
-        injectionMarkerRenderQueueBySession.set(sessionID, next);
-    };
-    const insertInjectionsIntoMessages = (messages, injections) => {
-        if (injections.length === 0)
-            return messages;
-        const totalRealMessages = countConversationMessages(messages);
-        const buckets = new Map();
-        for (const injection of injections) {
-            const position = Math.max(0, Math.min(totalRealMessages, injection.targetPosition));
-            const existing = buckets.get(position) || [];
-            existing.push(injection);
-            buckets.set(position, existing);
+        const shellStart = performance.now();
+        part.text = await executeShellCommands(part.text, { directory: ctx.directory });
+        shellTimeTotal += performance.now() - shellStart;
+        processedParts += 1;
+      }
+    }
+    if (processedParts > 0) {
+      const totalTime = performance.now() - messageStart;
+      logger.debug("Text parts processing complete", {
+        totalTimeMs: totalTime.toFixed(2),
+        skillTimeMs: skillTimeTotal.toFixed(2),
+        snippetExpandTimeMs: expandTimeTotal.toFixed(2),
+        shellTimeMs: shellTimeTotal.toFixed(2),
+        processedParts,
+        injectedCount: allInjected.length
+      });
+    }
+    return allInjected;
+  };
+  const isIgnoredMessage = (message) => message.parts.some((part) => part.ignored);
+  const isSkillContentMessage = (message) => message.parts.some((part) => part.type === "text" && (part.text || "").includes("<skill_content name="));
+  const isInjectionMarkerMessage = (message) => isIgnoredMessage(message) && message.parts.some((part) => part.type === "text" && part.text?.startsWith("↳ Injected "));
+  const injectionMarkerPartIdsByMessage = (messages) => {
+    const ids = new Map;
+    for (const message of messages) {
+      if (!message.info.id || !isInjectionMarkerMessage(message))
+        continue;
+      const partIds = message.parts.filter((part) => part.type === "text" && part.text?.startsWith("↳ Injected ")).map((part) => part.id).filter((id) => !!id);
+      if (partIds.length > 0)
+        ids.set(message.info.id, partIds);
+    }
+    return ids;
+  };
+  const countConversationMessages = (messages) => messages.filter((message) => !isIgnoredMessage(message)).length;
+  const messageIdPrefix = (messageId) => {
+    const match = /^msg_([0-9a-f]{12})/.exec(messageId);
+    return match?.[1];
+  };
+  const markerSuffix = (targetPosition, index) => {
+    const suffix = `000${(index + 1).toString(36)}`.slice(-3);
+    if (targetPosition === 0)
+      return `${MARKER_ID_RANDOM_FILL}${suffix}`;
+    return `zzzzzzzzzzz${suffix}`;
+  };
+  const buildMarkerMessageId = (messages, targetPosition, index) => {
+    const realMessages = messages.filter((message) => !isIgnoredMessage(message));
+    const pivot = realMessages[Math.max(0, Math.min(realMessages.length - 1, targetPosition - 1))];
+    if (!pivot?.info.id)
+      return;
+    const prefix = messageIdPrefix(pivot.info.id);
+    if (!prefix)
+      return;
+    return `msg_${prefix}${markerSuffix(targetPosition, index)}`;
+  };
+  const getPersistedMessages = async (sessionID) => {
+    try {
+      const response = await ctx.client.session.messages({ path: { id: sessionID } });
+      return (response.data || []).map((message) => ({
+        info: message.info,
+        parts: message.parts
+      }));
+    } catch (error) {
+      logger.debug("Failed to load session messages for injection markers", {
+        sessionID,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  };
+  const renderInjectionMarkers = async (sessionID, messages, injections) => {
+    if (injections.length === 0)
+      return;
+    const next = new Set;
+    const pending = [];
+    injections.forEach((injection, index) => {
+      const id = buildMarkerMessageId(messages, injection.targetPosition, index);
+      if (!id)
+        return;
+      next.add(id);
+      pending.push({ id, text: `↳ Injected ${injection.snippetName}` });
+    });
+    const persistedMarkerIds = messages.filter(isInjectionMarkerMessage).map((message) => message.info.id).filter((id) => !!id);
+    const persistedMarkerPartIds = injectionMarkerPartIdsByMessage(messages);
+    const previous = new Set([
+      ...persistedMarkerIds,
+      ...injectionMarkerIdsBySession.get(sessionID) || []
+    ]);
+    const kept = new Set;
+    const current = new Set;
+    logger.debug("Rendering injection markers", {
+      sessionID,
+      messageCount: countConversationMessages(messages),
+      injectionCount: injections.length,
+      nextMarkerIds: [...next],
+      persistedMarkerIds,
+      persistedMarkerPartIds: Object.fromEntries(persistedMarkerPartIds),
+      previousMarkerIds: [...previous]
+    });
+    for (const id of previous) {
+      if (!next.has(id)) {
+        let deleted = true;
+        for (const partId of persistedMarkerPartIds.get(id) || []) {
+          const partDeleted = await deleteSessionPart(ctx.client, ctx.serverUrl, sessionID, id, partId);
+          if (!partDeleted)
+            deleted = false;
         }
-        const result = [];
-        const prepend = buckets.get(0) || [];
-        for (const injection of prepend) {
-            result.push({
-                info: { role: "user" },
-                parts: [{ type: "text", text: injection.content }],
-            });
+        const messageDeleted = await deleteSessionMessage(ctx.client, ctx.serverUrl, sessionID, id);
+        if (!messageDeleted)
+          deleted = false;
+        if (!deleted)
+          kept.add(id);
+      }
+    }
+    if (kept.size > 0) {
+      logger.debug("Skipping injection marker creation until stale markers delete", {
+        sessionID,
+        keptMarkerIds: [...kept],
+        nextMarkerIds: [...next]
+      });
+      injectionMarkerIdsBySession.set(sessionID, kept);
+      return;
+    }
+    for (const marker of pending) {
+      current.add(marker.id);
+      if (!previous.has(marker.id)) {
+        await sendIgnoredMessage(ctx.client, sessionID, marker.text, marker.id);
+      }
+    }
+    injectionMarkerIdsBySession.set(sessionID, current);
+  };
+  const scheduleInjectionMarkerRender = (sessionID, messages, injections) => {
+    const previous = injectionMarkerRenderQueueBySession.get(sessionID) || Promise.resolve();
+    const next = previous.catch(() => {
+      return;
+    }).then(() => new Promise((resolve3) => {
+      setTimeout(() => {
+        renderInjectionMarkers(sessionID, messages, injections).then(resolve3, (error) => {
+          logger.debug("Failed to render injection markers", {
+            sessionID,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          resolve3();
+        });
+      }, 0);
+    }));
+    injectionMarkerRenderQueueBySession.set(sessionID, next);
+  };
+  const insertInjectionsIntoMessages = (messages, injections) => {
+    if (injections.length === 0)
+      return messages;
+    const totalRealMessages = countConversationMessages(messages);
+    const buckets = new Map;
+    for (const injection of injections) {
+      const position = Math.max(0, Math.min(totalRealMessages, injection.targetPosition));
+      const existing = buckets.get(position) || [];
+      existing.push(injection);
+      buckets.set(position, existing);
+    }
+    const result = [];
+    const prepend = buckets.get(0) || [];
+    for (const injection of prepend) {
+      result.push({
+        info: { role: "user" },
+        parts: [{ type: "text", text: injection.content }]
+      });
+    }
+    let seenRealMessages = 0;
+    messages.forEach((message) => {
+      result.push(message);
+      if (isIgnoredMessage(message))
+        return;
+      seenRealMessages += 1;
+      const positioned = buckets.get(seenRealMessages) || [];
+      for (const injection of positioned) {
+        result.push({
+          info: { role: "user", sessionID: message.info.sessionID },
+          parts: [{ type: "text", text: injection.content }]
+        });
+      }
+    });
+    return result;
+  };
+  const getPartSkillLoads = (parts) => parts.flatMap((part) => part.skillLoads || []);
+  const getMessageSkillLoads = async (sessionID, message) => {
+    if (isSkillContentMessage(message)) {
+      logger.debug("Skipping skill-content message during load resolution", {
+        sessionID,
+        messageID: message.info.id
+      });
+      return [];
+    }
+    const direct = getPartSkillLoads(message.parts);
+    if (direct.length > 0) {
+      logger.debug("Resolved skill loads from direct part metadata", {
+        sessionID,
+        messageID: message.info.id,
+        payloadCount: direct.length
+      });
+      return direct;
+    }
+    if (message.info.id) {
+      const stored = skillLoadManager.get(sessionID, message.info.id);
+      if (stored.length > 0) {
+        logger.debug("Resolved skill loads from message-id registry", {
+          sessionID,
+          messageID: message.info.id,
+          payloadCount: stored.length
+        });
+        return stored;
+      }
+    }
+    if (!config.experimental.skillLoading || skills.size === 0)
+      return [];
+    const text = message.parts.filter((part) => part.type === "text").map((part) => part.text || "").join(`
+
+`);
+    const recovered = await buildSkillPayloadsFromVisibleText(text, skills, snippets, {
+      expandSkillTagsInContent: config.experimental.skillRendering,
+      extractInject: config.experimental.injectBlocks
+    });
+    if (recovered.length > 0) {
+      logger.debug("Recovered hidden skill payloads from visible markers", {
+        sessionID,
+        messageID: message.info.id,
+        payloadCount: recovered.length
+      });
+    }
+    if (recovered.length === 0 && text.includes("↳ Loaded ")) {
+      logger.debug("Visible skill markers found but no hidden payloads recovered", {
+        sessionID,
+        messageID: message.info.id,
+        text
+      });
+    }
+    return recovered;
+  };
+  const insertSkillLoadsIntoMessages = async (sessionID, messages) => {
+    const pendingRaw = skillLoadManager.drainPending(sessionID);
+    const result = [];
+    const resolvedLoads = await Promise.all(messages.map(async (message) => {
+      if (message.info.role !== "user" || isIgnoredMessage(message)) {
+        return [];
+      }
+      return getMessageSkillLoads(sessionID, message);
+    }));
+    logger.debug("Resolved skill loads for transform messages", {
+      sessionID,
+      messages: messages.map((message, i) => ({
+        messageID: message.info.id,
+        role: message.info.role,
+        synthetic: message.parts.some((part) => part.synthetic),
+        snippetsProcessed: message.parts.some((part) => part.snippetsProcessed),
+        text: message.parts.filter((part) => part.type === "text").map((part) => (part.text || "").slice(0, 120)).join(" | "),
+        resolvedLoadCount: (resolvedLoads[i] || []).length
+      }))
+    });
+    const directPayloadStrings = new Set;
+    for (const [i, message] of messages.entries()) {
+      if (message.info.role !== "user" || isIgnoredMessage(message))
+        continue;
+      for (const payload of resolvedLoads[i] || []) {
+        directPayloadStrings.add(payload);
+      }
+    }
+    const pending = pendingRaw.filter((entry) => {
+      if (entry.payloads.length === 0)
+        return false;
+      return entry.payloads.some((p) => !directPayloadStrings.has(p));
+    });
+    if (pending.length !== pendingRaw.length) {
+      logger.debug("Dropped duplicate queued skill payloads", {
+        sessionID,
+        before: pendingRaw.length,
+        after: pending.length
+      });
+    }
+    const fallbackByIndex = new Map;
+    if (pending.length > 0) {
+      for (let i = messages.length - 1;i >= 0; i -= 1) {
+        const message = messages[i];
+        if (message.info.role !== "user" || isIgnoredMessage(message))
+          continue;
+        if ((resolvedLoads[i] || []).length > 0)
+          continue;
+        const next = pending.at(-1);
+        if (!next)
+          break;
+        if (next.messageID && message.info.id && next.messageID !== message.info.id) {
+          continue;
         }
-        let seenRealMessages = 0;
-        messages.forEach((message) => {
-            result.push(message);
-            if (isIgnoredMessage(message))
-                return;
-            seenRealMessages += 1;
-            const positioned = buckets.get(seenRealMessages) || [];
-            for (const injection of positioned) {
-                result.push({
-                    info: { role: "user", sessionID: message.info.sessionID },
-                    parts: [{ type: "text", text: injection.content }],
-                });
-            }
+        pending.pop();
+        fallbackByIndex.set(i, next.payloads);
+      }
+      while (pending.length > 0) {
+        const next = pending.pop();
+        if (!next)
+          break;
+        for (let i = messages.length - 1;i >= 0; i -= 1) {
+          const message = messages[i];
+          if (message.info.role !== "user" || isIgnoredMessage(message))
+            continue;
+          if ((resolvedLoads[i] || []).length > 0)
+            continue;
+          if (fallbackByIndex.has(i))
+            continue;
+          fallbackByIndex.set(i, next.payloads);
+          break;
+        }
+      }
+    }
+    for (const [i, message] of messages.entries()) {
+      if (message.info.role !== "user" || isIgnoredMessage(message)) {
+        result.push(message);
+        continue;
+      }
+      const direct = resolvedLoads[i] || [];
+      const payloads = direct.length > 0 ? direct : fallbackByIndex.get(i) || [];
+      if (payloads.length === 0) {
+        result.push(message);
+        continue;
+      }
+      skillLoadManager.rememberForSession(sessionID, payloads);
+      const hiddenText = payloads.join(`
+
+`);
+      if (message.parts.some((part) => part.type === "text" && part.synthetic && (part.text || "") === hiddenText)) {
+        logger.debug("Hidden skill payload already attached to user message", {
+          sessionID,
+          messageID: message.info.id,
+          hiddenLength: hiddenText.length
         });
-        return result;
-    };
-    const getPartSkillLoads = (parts) => parts.flatMap((part) => part.skillLoads || []);
-    const getMessageSkillLoads = async (sessionID, message) => {
-        if (isSkillContentMessage(message)) {
-            logger.debug("Skipping skill-content message during load resolution", {
-                sessionID,
-                messageID: message.info.id,
-            });
-            return [];
+        result.push(message);
+        continue;
+      }
+      logger.debug("Appended hidden skill payload to user message", {
+        sessionID,
+        messageID: message.info.id,
+        partCountBefore: message.parts.length,
+        partCountAfter: message.parts.length + 1,
+        hiddenLength: hiddenText.length
+      });
+      result.push({
+        ...message,
+        parts: [{ type: "text", text: hiddenText, synthetic: true }, ...message.parts]
+      });
+    }
+    return result;
+  };
+  return {
+    config: async (opencodeConfig) => {
+      const cfg = opencodeConfig;
+      cfg.skills ??= {};
+      cfg.skills.paths ??= [];
+      cfg.skills.paths.push(SKILL_DIR);
+      opencodeSkillDirs.length = 0;
+      opencodeSkillDirs.push(...cfg.skills.paths);
+      if (config.experimental.skillRendering || config.experimental.skillLoading) {
+        skills = await loadRuntimeSkills();
+      }
+      opencodeConfig.command ??= {};
+      opencodeConfig.command.snippets = {
+        template: "",
+        description: "Manage text snippets (add, delete, list, help)"
+      };
+      opencodeConfig.command["snippets:reload"] = {
+        template: "",
+        description: "Reload snippet files from disk"
+      };
+    },
+    "command.execute.before": commandHandler,
+    "chat.message": async (input, output) => {
+      if (output.message.role !== "user")
+        return;
+      if (output.parts.some((part) => part.ignored))
+        return;
+      const injected = await processTextParts(output.parts);
+      logger.debug("chat.message processed user parts", {
+        sessionID: input.sessionID,
+        messageID: input.messageID,
+        texts: output.parts.filter((part) => part.type === "text").map((part) => ({
+          text: (part.text || "").slice(0, 200),
+          skillLoads: part.skillLoads?.length || 0
+        }))
+      });
+      output.parts.forEach((part) => {
+        if (part.type === "text") {
+          part.snippetsProcessed = true;
         }
-        const direct = getPartSkillLoads(message.parts);
-        if (direct.length > 0) {
-            logger.debug("Resolved skill loads from direct part metadata", {
-                sessionID,
-                messageID: message.info.id,
-                payloadCount: direct.length,
-            });
-            return direct;
+      });
+      if (input.messageID) {
+        const payloads = getPartSkillLoads(output.parts);
+        if (payloads.length > 0) {
+          skillLoadManager.register(input.sessionID, input.messageID, payloads);
+        }
+      } else {
+        const payloads = getPartSkillLoads(output.parts);
+        if (payloads.length > 0) {
+          skillLoadManager.queue(input.sessionID, payloads, input.messageID);
         }
-        if (message.info.id) {
-            const stored = skillLoadManager.get(sessionID, message.info.id);
-            if (stored.length > 0) {
-                logger.debug("Resolved skill loads from message-id registry", {
-                    sessionID,
-                    messageID: message.info.id,
-                    payloadCount: stored.length,
-                });
-                return stored;
+      }
+      injectionManager.registerAndGetNew(input.sessionID, injected);
+      if (config.experimental.injectBlocks) {
+        const persisted = await getPersistedMessages(input.sessionID);
+        const current = {
+          info: {
+            id: output.message.id,
+            role: output.message.role,
+            sessionID: output.message.sessionID || input.sessionID
+          },
+          parts: output.parts
+        };
+        const messages = [...persisted, current];
+        const messageCount = countConversationMessages(messages);
+        const { injections } = injectionManager.getRenderableInjections(input.sessionID, messageCount, config.injectRecencyMessages);
+        scheduleInjectionMarkerRender(input.sessionID, messages, injections);
+      }
+    },
+    "experimental.chat.messages.transform": async (input, output) => {
+      const sessionID = input.sessionID || input.session?.id || output.messages[0]?.info?.sessionID;
+      logger.debug("Transform hook called", {
+        inputSessionID: input.sessionID,
+        extractedSessionID: sessionID,
+        messageCount: output.messages.length,
+        hasSessionID: !!sessionID
+      });
+      for (const message of output.messages) {
+        if (message.info.role === "user") {
+          if (message.parts.some((part) => part.snippetsProcessed))
+            continue;
+          if (message.parts.some((part) => part.ignored))
+            continue;
+          if (message.parts.some((part) => part.synthetic))
+            continue;
+          const injected = await processTextParts(message.parts);
+          if (injected.length > 0 && sessionID) {
+            injectionManager.registerAndGetNew(sessionID, injected);
+          }
+          if (sessionID && message.info.id) {
+            const payloads = getPartSkillLoads(message.parts);
+            if (payloads.length > 0) {
+              skillLoadManager.register(sessionID, message.info.id, payloads);
             }
+          }
         }
-        if (!config.experimental.skillLoading || skills.size === 0)
-            return [];
-        const text = message.parts
-            .filter((part) => part.type === "text")
-            .map((part) => part.text || "")
-            .join("\n\n");
-        const recovered = await buildSkillPayloadsFromVisibleText(text, skills, snippets, {
-            expandSkillTagsInContent: config.experimental.skillRendering,
-            extractInject: config.experimental.injectBlocks,
+      }
+      if (sessionID) {
+        const messageCount = countConversationMessages(output.messages);
+        const { injections } = injectionManager.getRenderableInjections(sessionID, messageCount, config.injectRecencyMessages);
+        logger.debug("Transform hook - checking for injections", {
+          sessionID,
+          hasInjections: injections.length > 0,
+          injectionCount: injections.length,
+          messageTexts: output.messages.map((m) => ({
+            role: m.info.role,
+            text: m.parts.filter((p) => p.type === "text").map((p) => (p.text || "").slice(0, 50)).join(" | "),
+            snippetsProcessed: m.parts.some((p) => p.snippetsProcessed)
+          }))
         });
-        if (recovered.length > 0) {
-            logger.debug("Recovered hidden skill payloads from visible markers", {
-                sessionID,
-                messageID: message.info.id,
-                payloadCount: recovered.length,
-            });
+        if (injections.length > 0) {
+          const beforeCount = output.messages.length;
+          output.messages = insertInjectionsIntoMessages(output.messages, injections);
+          logger.debug("Injected ephemeral user messages", {
+            sessionID,
+            injectionCount: injections.length,
+            messagesBefore: beforeCount,
+            messagesAfter: output.messages.length
+          });
         }
-        if (recovered.length === 0 && text.includes("↳ Loaded ")) {
-            logger.debug("Visible skill markers found but no hidden payloads recovered", {
-                sessionID,
-                messageID: message.info.id,
-                text,
+        if (config.experimental.skillLoading) {
+          const beforeSkillLoads = output.messages.length;
+          output.messages = await insertSkillLoadsIntoMessages(sessionID, output.messages);
+          if (output.messages.length > beforeSkillLoads) {
+            logger.debug("Injected skill load context messages", {
+              sessionID,
+              messagesBefore: beforeSkillLoads,
+              messagesAfter: output.messages.length
             });
+          }
         }
-        return recovered;
-    };
-    const insertSkillLoadsIntoMessages = async (sessionID, messages) => {
-        const pendingRaw = skillLoadManager.drainPending(sessionID);
-        const result = [];
-        const resolvedLoads = await Promise.all(messages.map(async (message) => {
-            if (message.info.role !== "user" || isIgnoredMessage(message)) {
-                return [];
-            }
-            return getMessageSkillLoads(sessionID, message);
-        }));
-        logger.debug("Resolved skill loads for transform messages", {
-            sessionID,
-            messages: messages.map((message, i) => ({
-                messageID: message.info.id,
-                role: message.info.role,
-                synthetic: message.parts.some((part) => part.synthetic),
-                snippetsProcessed: message.parts.some((part) => part.snippetsProcessed),
-                text: message.parts
-                    .filter((part) => part.type === "text")
-                    .map((part) => (part.text || "").slice(0, 120))
-                    .join(" | "),
-                resolvedLoadCount: (resolvedLoads[i] || []).length,
-            })),
+      }
+    },
+    "experimental.chat.system.transform": async (input, output) => {
+      if (!config.experimental.skillLoading)
+        return;
+      if (!input.sessionID)
+        return;
+      const payloads = skillLoadManager.getSessionPayloads(input.sessionID);
+      if (payloads.length === 0)
+        return;
+      const hiddenText = payloads.join(`
+
+`);
+      if (output.system.includes(hiddenText)) {
+        logger.debug("Hidden skill payloads already present in system prompt", {
+          sessionID: input.sessionID,
+          payloadCount: payloads.length,
+          hiddenLength: hiddenText.length
         });
-        // Dedup requirement: if a queued payload string already exists as a direct
-        // skillLoad on any user message (because chat.message attached it to part.skillLoads),
-        // a synthetic for that message will be pushed via the `direct` path below.
-        // We must NOT also push a fallback synthetic for the same payload, otherwise
-        // OpenCode's fresh-session flow (which seems to fire chat.message both with and
-        // without messageID) ends up with the skill_content duplicated and stuck onto
-        // an unrelated user message like beads-context.
-        const directPayloadStrings = new Set();
-        for (const [i, message] of messages.entries()) {
-            if (message.info.role !== "user" || isIgnoredMessage(message))
-                continue;
-            for (const payload of resolvedLoads[i] || []) {
-                directPayloadStrings.add(payload);
-            }
+        return;
+      }
+      output.system.push(hiddenText);
+      logger.debug("Mirrored hidden skill payloads into system prompt", {
+        sessionID: input.sessionID,
+        payloadCount: payloads.length,
+        hiddenLength: hiddenText.length,
+        systemEntryCount: output.system.length
+      });
+    },
+    "tool.execute.after": async (input, output) => {
+      if (input.tool !== "skill")
+        return;
+      if (typeof output.output === "string" && output.output.trim()) {
+        let processed = output.output;
+        if (config.experimental.skillRendering && skills.size > 0) {
+          processed = expandSkillTags(processed, skills);
         }
-        const pending = pendingRaw.filter((entry) => {
-            if (entry.payloads.length === 0)
-                return false;
-            // If every payload string in this entry is already attached directly to
-            // some user message, the synthetic will be emitted there. Drop the dup.
-            return entry.payloads.some((p) => !directPayloadStrings.has(p));
+        const expandOptions = {
+          extractInject: config.experimental.injectBlocks
+        };
+        const expansionResult = expandHashtags(processed, snippets, new Map, expandOptions);
+        output.output = assembleMessage(expansionResult);
+        logger.debug("Skill content expanded", {
+          tool: input.tool,
+          callID: input.callID
         });
-        if (pending.length !== pendingRaw.length) {
-            logger.debug("Dropped duplicate queued skill payloads", {
-                sessionID,
-                before: pendingRaw.length,
-                after: pending.length,
-            });
-        }
-        const fallbackByIndex = new Map();
-        if (pending.length > 0) {
-            for (let i = messages.length - 1; i >= 0; i -= 1) {
-                const message = messages[i];
-                if (message.info.role !== "user" || isIgnoredMessage(message))
-                    continue;
-                if ((resolvedLoads[i] || []).length > 0)
-                    continue;
-                const next = pending.at(-1);
-                if (!next)
-                    break;
-                if (next.messageID && message.info.id && next.messageID !== message.info.id) {
-                    continue;
-                }
-                pending.pop();
-                fallbackByIndex.set(i, next.payloads);
-            }
-            while (pending.length > 0) {
-                const next = pending.pop();
-                if (!next)
-                    break;
-                for (let i = messages.length - 1; i >= 0; i -= 1) {
-                    const message = messages[i];
-                    if (message.info.role !== "user" || isIgnoredMessage(message))
-                        continue;
-                    if ((resolvedLoads[i] || []).length > 0)
-                        continue;
-                    if (fallbackByIndex.has(i))
-                        continue;
-                    fallbackByIndex.set(i, next.payloads);
-                    break;
-                }
-            }
-        }
-        for (const [i, message] of messages.entries()) {
-            if (message.info.role !== "user" || isIgnoredMessage(message)) {
-                result.push(message);
-                continue;
-            }
-            const direct = resolvedLoads[i] || [];
-            const payloads = direct.length > 0 ? direct : fallbackByIndex.get(i) || [];
-            if (payloads.length === 0) {
-                result.push(message);
-                continue;
-            }
-            skillLoadManager.rememberForSession(sessionID, payloads);
-            const hiddenText = payloads.join("\n\n");
-            if (message.parts.some((part) => part.type === "text" && part.synthetic && (part.text || "") === hiddenText)) {
-                logger.debug("Hidden skill payload already attached to user message", {
-                    sessionID,
-                    messageID: message.info.id,
-                    hiddenLength: hiddenText.length,
-                });
-                result.push(message);
-                continue;
-            }
-            // Regression guard from the PTY repro:
-            // 1. skill content must stay hidden from the user,
-            // 2. skill content must be injected immediately below the visible user message and reach the LLM,
-            // 3. the agent must not call `skill` a second time for an already-loaded skill.
-            logger.debug("Appended hidden skill payload to user message", {
-                sessionID,
-                messageID: message.info.id,
-                partCountBefore: message.parts.length,
-                partCountAfter: message.parts.length + 1,
-                hiddenLength: hiddenText.length,
-            });
-            result.push({
-                ...message,
-                parts: [{ type: "text", text: hiddenText, synthetic: true }, ...message.parts],
-            });
-        }
-        return result;
-    };
-    return {
-        // Register /snippets commands and skill path
-        config: async (opencodeConfig) => {
-            // Register skill folder path for automatic discovery
-            const cfg = opencodeConfig;
-            cfg.skills ??= {};
-            cfg.skills.paths ??= [];
-            cfg.skills.paths.push(SKILL_DIR);
-            opencodeSkillDirs.length = 0;
-            opencodeSkillDirs.push(...cfg.skills.paths);
-            if (config.experimental.skillRendering || config.experimental.skillLoading) {
-                skills = await loadRuntimeSkills();
-            }
-            // Register /snippets commands
-            opencodeConfig.command ??= {};
-            opencodeConfig.command.snippets = {
-                template: "",
-                description: "Manage text snippets (add, delete, list, help)",
-            };
-            opencodeConfig.command["snippets:reload"] = {
-                template: "",
-                description: "Reload snippet files from disk",
-            };
-        },
-        "command.execute.before": commandHandler,
-        "chat.message": async (input, output) => {
-            if (output.message.role !== "user")
-                return;
-            if (output.parts.some((part) => part.ignored))
-                return;
-            const injected = await processTextParts(output.parts);
-            logger.debug("chat.message processed user parts", {
-                sessionID: input.sessionID,
-                messageID: input.messageID,
-                texts: output.parts
-                    .filter((part) => part.type === "text")
-                    .map((part) => ({
-                    text: (part.text || "").slice(0, 200),
-                    skillLoads: part.skillLoads?.length || 0,
-                })),
-            });
-            output.parts.forEach((part) => {
-                if (part.type === "text") {
-                    part.snippetsProcessed = true;
-                }
-            });
-            if (input.messageID) {
-                const payloads = getPartSkillLoads(output.parts);
-                if (payloads.length > 0) {
-                    skillLoadManager.register(input.sessionID, input.messageID, payloads);
-                }
-            }
-            else {
-                const payloads = getPartSkillLoads(output.parts);
-                if (payloads.length > 0) {
-                    skillLoadManager.queue(input.sessionID, payloads, input.messageID);
-                }
-            }
-            injectionManager.registerAndGetNew(input.sessionID, injected);
-            if (config.experimental.injectBlocks) {
-                const persisted = await getPersistedMessages(input.sessionID);
-                const current = {
-                    info: {
-                        id: output.message.id,
-                        role: output.message.role,
-                        sessionID: output.message.sessionID || input.sessionID,
-                    },
-                    parts: output.parts,
-                };
-                const messages = [...persisted, current];
-                const messageCount = countConversationMessages(messages);
-                const { injections } = injectionManager.getRenderableInjections(input.sessionID, messageCount, config.injectRecencyMessages);
-                scheduleInjectionMarkerRender(input.sessionID, messages, injections);
-            }
-        },
-        "experimental.chat.messages.transform": async (input, output) => {
-            const sessionID = input.sessionID || input.session?.id || output.messages[0]?.info?.sessionID;
-            logger.debug("Transform hook called", {
-                inputSessionID: input.sessionID,
-                extractedSessionID: sessionID,
-                messageCount: output.messages.length,
-                hasSessionID: !!sessionID,
-            });
-            for (const message of output.messages) {
-                if (message.info.role === "user") {
-                    if (message.parts.some((part) => part.snippetsProcessed))
-                        continue;
-                    if (message.parts.some((part) => part.ignored))
-                        continue;
-                    if (message.parts.some((part) => part.synthetic))
-                        continue;
-                    const injected = await processTextParts(message.parts);
-                    if (injected.length > 0 && sessionID) {
-                        injectionManager.registerAndGetNew(sessionID, injected);
-                    }
-                    if (sessionID && message.info.id) {
-                        const payloads = getPartSkillLoads(message.parts);
-                        if (payloads.length > 0) {
-                            skillLoadManager.register(sessionID, message.info.id, payloads);
-                        }
-                    }
-                }
-            }
-            if (sessionID) {
-                const messageCount = countConversationMessages(output.messages);
-                const { injections } = injectionManager.getRenderableInjections(sessionID, messageCount, config.injectRecencyMessages);
-                logger.debug("Transform hook - checking for injections", {
-                    sessionID,
-                    hasInjections: injections.length > 0,
-                    injectionCount: injections.length,
-                    messageTexts: output.messages.map((m) => ({
-                        role: m.info.role,
-                        text: m.parts
-                            .filter((p) => p.type === "text")
-                            .map((p) => (p.text || "").slice(0, 50))
-                            .join(" | "),
-                        snippetsProcessed: m.parts.some((p) => p.snippetsProcessed),
-                    })),
-                });
-                if (injections.length > 0) {
-                    const beforeCount = output.messages.length;
-                    output.messages = insertInjectionsIntoMessages(output.messages, injections);
-                    logger.debug("Injected ephemeral user messages", {
-                        sessionID,
-                        injectionCount: injections.length,
-                        messagesBefore: beforeCount,
-                        messagesAfter: output.messages.length,
-                    });
-                }
-                if (config.experimental.skillLoading) {
-                    const beforeSkillLoads = output.messages.length;
-                    output.messages = await insertSkillLoadsIntoMessages(sessionID, output.messages);
-                    if (output.messages.length > beforeSkillLoads) {
-                        logger.debug("Injected skill load context messages", {
-                            sessionID,
-                            messagesBefore: beforeSkillLoads,
-                            messagesAfter: output.messages.length,
-                        });
-                    }
-                }
-            }
-        },
-        "experimental.chat.system.transform": async (input, output) => {
-            if (!config.experimental.skillLoading)
-                return;
-            if (!input.sessionID)
-                return;
-            const payloads = skillLoadManager.getSessionPayloads(input.sessionID);
-            if (payloads.length === 0)
-                return;
-            const hiddenText = payloads.join("\n\n");
-            if (output.system.includes(hiddenText)) {
-                logger.debug("Hidden skill payloads already present in system prompt", {
-                    sessionID: input.sessionID,
-                    payloadCount: payloads.length,
-                    hiddenLength: hiddenText.length,
-                });
-                return;
-            }
-            output.system.push(hiddenText);
-            logger.debug("Mirrored hidden skill payloads into system prompt", {
-                sessionID: input.sessionID,
-                payloadCount: payloads.length,
-                hiddenLength: hiddenText.length,
-                systemEntryCount: output.system.length,
-            });
-        },
-        // Process skill tool output to expand snippets and skill tags in skill content
-        "tool.execute.after": async (input, output) => {
-            if (input.tool !== "skill")
-                return;
-            // The skill tool returns markdown content in its output
-            // Expand skill tags and hashtags in the skill content
-            if (typeof output.output === "string" && output.output.trim()) {
-                let processed = output.output;
-                // First expand skill tags if enabled
-                if (config.experimental.skillRendering && skills.size > 0) {
-                    processed = expandSkillTags(processed, skills);
-                }
-                // Then expand hashtag snippets
-                const expandOptions = {
-                    extractInject: config.experimental.injectBlocks,
-                };
-                const expansionResult = expandHashtags(processed, snippets, new Map(), expandOptions);
-                output.output = assembleMessage(expansionResult);
-                logger.debug("Skill content expanded", {
-                    tool: input.tool,
-                    callID: input.callID,
-                });
-            }
-        },
-    };
+      }
+    }
+  };
+};
+var plugin = {
+  id: "opencode-snippets",
+  server: SnippetsPlugin
 };
-const plugin = {
-    id: "opencode-snippets",
-    server: SnippetsPlugin,
+var server = SnippetsPlugin;
+var opencode_snippets_default = plugin;
+export {
+  server,
+  opencode_snippets_default as default,
+  SnippetsPlugin
 };
-export const server = SnippetsPlugin;
-export default plugin;
-//# sourceMappingURL=index.js.map