@fro.bot/systematic 3.6.1 → 3.7.0

package/dist/index.js

@@ -3,24 +3,23 @@ import {
   AgentOverlaySchema,
   CategoryOverlaySchema,
   __require,
+  discoverSkills,
   exports_external,
   extractAgentFrontmatter,
   extractCommandFrontmatter,
-  extractFrontmatterFromContent,
   findAgentsInDir,
   findCommandsInDir,
   findSkillsInDir,
   isRecord,
   loadConfig,
   loadConfigWithSources,
-  parseFrontmatter,
-  walkDir
-} from "./index-1mb4baxr.js";
+  parseFrontmatter
+} from "./index-hjbt4p5s.js";
 
 // src/index.ts
 import { createHash as createHash5 } from "crypto";
-import fs12 from "fs";
-import path11 from "path";
+import fs11 from "fs";
+import path10 from "path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL3 } from "url";
 
 // src/lib/bootstrap.ts
@@ -251,9 +250,9 @@ ${skillUsage}${profileSection}${catalogSection}
 }
 
 // src/lib/config-handler.ts
-import fs7 from "fs";
+import fs6 from "fs";
 import os3 from "os";
-import path7 from "path";
+import path6 from "path";
 
 // src/lib/agent-overlays.ts
 import fs4 from "fs";
@@ -605,136 +604,11 @@ function throwConfigError(sourcePath, keyPath, message) {
   throw new Error(`Invalid Systematic config in ${sourcePath}: ${keyPath} ${message}`);
 }
 
-// src/lib/discovered-skills.ts
-import fs5 from "fs";
-import path5 from "path";
-var SKILL_NAME_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
-function isValidSkillName(name2) {
-  return name2.length >= 1 && name2.length <= 64 && SKILL_NAME_REGEX.test(name2);
-}
-function findGitWorktreeRoot(startDir) {
-  let current = path5.resolve(startDir);
-  while (true) {
-    try {
-      if (fs5.existsSync(path5.join(current, ".git"))) {
-        return current;
-      }
-    } catch {
-      return null;
-    }
-    const parent = path5.dirname(current);
-    if (parent === current)
-      return null;
-    current = parent;
-  }
-}
-function upWalk(targets, start2, stop2) {
-  const results = [];
-  let current = path5.resolve(start2);
-  const resolvedStop = stop2 === undefined ? undefined : path5.resolve(stop2);
-  while (true) {
-    for (const target of targets) {
-      const candidate = path5.join(current, target);
-      try {
-        if (fs5.existsSync(candidate)) {
-          results.push(candidate);
-        }
-      } catch {}
-    }
-    if (resolvedStop !== undefined && current === resolvedStop)
-      break;
-    const parent = path5.dirname(current);
-    if (parent === current)
-      break;
-    current = parent;
-  }
-  return results;
-}
-function uniqueStrings(values) {
-  return Array.from(new Set(values));
-}
-function buildOpencodeConfigDirs(startDir, homeDir, gitRoot, globalConfigDir, opencodeConfigDirOverride) {
-  const dirs = [globalConfigDir];
-  dirs.push(...upWalk([".opencode"], startDir, gitRoot ?? startDir));
-  dirs.push(...upWalk([".opencode"], homeDir, homeDir));
-  if (opencodeConfigDirOverride !== undefined) {
-    dirs.push(opencodeConfigDirOverride);
-  }
-  return uniqueStrings(dirs);
-}
-function globSkillFiles(rootDir, subdirNames) {
-  const results = [];
-  for (const subdirName of subdirNames) {
-    const scanRoot = path5.join(rootDir, subdirName);
-    try {
-      if (!fs5.existsSync(scanRoot))
-        continue;
-      const entries = walkDir(scanRoot, {
-        maxDepth: 10,
-        filter: (entry) => !entry.isDirectory && entry.name === "SKILL.md"
-      });
-      for (const entry of entries) {
-        results.push(entry.path);
-      }
-    } catch {}
-  }
-  return results;
-}
-function toDiscoveredSkill(skillPath, rootId) {
-  let content;
-  try {
-    content = fs5.readFileSync(skillPath, "utf8");
-  } catch {
-    return;
-  }
-  const frontmatter = extractFrontmatterFromContent(content);
-  const name2 = frontmatter.name;
-  if (!name2 || !isValidSkillName(name2))
-    return;
-  return {
-    name: name2,
-    description: frontmatter.description,
-    frontmatter,
-    body: parseFrontmatter(content).body,
-    skillPath,
-    root: rootId
-  };
-}
-function discoverSkills(options) {
-  const { startDir, homeDir, configDir, opencodeConfigDirOverride } = options;
-  const globalConfigDir = configDir ?? path5.join(homeDir, ".config/opencode");
-  const gitRoot = findGitWorktreeRoot(startDir);
-  const byName = new Map;
-  function upsertAll(skillPaths, rootId) {
-    for (const skillPath of skillPaths) {
-      const skill = toDiscoveredSkill(skillPath, rootId);
-      if (skill)
-        byName.set(skill.name, skill);
-    }
-  }
-  upsertAll(globSkillFiles(homeDir, [".claude/skills"]), "global-claude");
-  upsertAll(globSkillFiles(homeDir, [".agents/skills"]), "global-agents");
-  const externalLevels = upWalk([".claude", ".agents"], startDir, gitRoot ?? startDir);
-  for (const levelDir of externalLevels) {
-    const isClaudeDir = path5.basename(levelDir) === ".claude";
-    const parentDir = path5.dirname(levelDir);
-    const subdirGlob = isClaudeDir ? ".claude/skills" : ".agents/skills";
-    const rootId = isClaudeDir ? "project-claude" : "project-agents";
-    upsertAll(globSkillFiles(parentDir, [subdirGlob]), rootId);
-  }
-  const configDirs = buildOpencodeConfigDirs(startDir, homeDir, gitRoot, globalConfigDir, opencodeConfigDirOverride);
-  for (const dir of configDirs) {
-    const rootId = dir === globalConfigDir ? "global-opencode-config" : "project-opencode";
-    upsertAll(globSkillFiles(dir, ["skill", "skills"]), rootId);
-  }
-  return Array.from(byName.values());
-}
-
 // src/lib/model-availability.ts
 import { createHash } from "crypto";
-import fs6 from "fs";
+import fs5 from "fs";
 import os2 from "os";
-import path6 from "path";
+import path5 from "path";
 function emptyAvailability() {
   return { status: "unknown", models: new Set };
 }
@@ -744,8 +618,8 @@ var MODELS_JSON_FILENAME = "models.json";
 var availabilityCache = new WeakMap;
 function resolveCacheDir() {
   const xdgCacheHome = process.env.XDG_CACHE_HOME?.trim();
-  const cacheBase = xdgCacheHome && path6.isAbsolute(xdgCacheHome) ? xdgCacheHome : path6.join(os2.homedir(), ".cache");
-  return path6.join(cacheBase, "opencode");
+  const cacheBase = xdgCacheHome && path5.isAbsolute(xdgCacheHome) ? xdgCacheHome : path5.join(os2.homedir(), ".cache");
+  return path5.join(cacheBase, "opencode");
 }
 function fastHash(input) {
   return createHash("sha1").update(input).digest("hex");
@@ -764,7 +638,7 @@ function isProviderRecord(value) {
 function readModelsFromCache(filePath) {
   let fd;
   try {
-    fd = fs6.openSync(filePath, "r");
+    fd = fs5.openSync(filePath, "r");
   } catch {
     return null;
   }
@@ -772,7 +646,7 @@ function readModelsFromCache(filePath) {
   try {
     let stat;
     try {
-      stat = fs6.fstatSync(fd);
+      stat = fs5.fstatSync(fd);
     } catch {
       return null;
     }
@@ -787,7 +661,7 @@ function readModelsFromCache(filePath) {
     const buffer = Buffer.alloc(stat.size);
     let bytesRead;
     try {
-      bytesRead = fs6.readSync(fd, buffer, 0, stat.size, 0);
+      bytesRead = fs5.readSync(fd, buffer, 0, stat.size, 0);
     } catch {
       return null;
     }
@@ -796,7 +670,7 @@ function readModelsFromCache(filePath) {
     raw = buffer.toString("utf8");
   } finally {
     try {
-      fs6.closeSync(fd);
+      fs5.closeSync(fd);
     } catch {}
   }
   if (raw.trim().length === 0)
@@ -823,14 +697,14 @@ function readFallbackCache() {
   const cacheDir = resolveCacheDir();
   const openCodeModelsUrl = process.env.OPENCODE_MODELS_URL?.trim();
   if (openCodeModelsUrl) {
-    const urlDerivedPath = path6.join(cacheDir, `models-${fastHash(openCodeModelsUrl)}.json`);
+    const urlDerivedPath = path5.join(cacheDir, `models-${fastHash(openCodeModelsUrl)}.json`);
     const urlResult = readModelsFromCache(urlDerivedPath);
     if (urlResult !== null && urlResult.size > 0) {
       return { status: "cache", models: urlResult };
     }
     return emptyAvailability();
   }
-  const defaultPath = path6.join(cacheDir, MODELS_JSON_FILENAME);
+  const defaultPath = path5.join(cacheDir, MODELS_JSON_FILENAME);
   const defaultResult = readModelsFromCache(defaultPath);
   if (defaultResult !== null && defaultResult.size > 0) {
     return { status: "cache", models: defaultResult };
@@ -931,7 +805,7 @@ function formatAgentDescription(name2, description) {
 }
 function loadAgentAsConfig(agentInfo) {
   try {
-    const content = fs7.readFileSync(agentInfo.file, "utf8");
+    const content = fs6.readFileSync(agentInfo.file, "utf8");
     const {
       description,
       prompt,
@@ -980,7 +854,7 @@ function loadAgentAsConfig(agentInfo) {
 }
 function loadCommandAsConfig(commandInfo) {
   try {
-    const content = fs7.readFileSync(commandInfo.file, "utf8");
+    const content = fs6.readFileSync(commandInfo.file, "utf8");
     const { name: name2, description, agent, model, subtask } = extractCommandFrontmatter(content);
     const { body: body2 } = parseFrontmatter(content);
     const cleanName = commandInfo.name.replace(/^\//, "");
@@ -1241,7 +1115,7 @@ function collectEnabledSkillNames(dir, disabledSkills) {
 function createConfigHandler(deps) {
   const { directory, bundledSkillsDir, bundledAgentsDir: bundledAgentsDir2, bundledCommandsDir } = deps;
   const homeDir = deps.homeDir ?? os3.homedir();
-  const opencodeConfigDir = deps.opencodeConfigDir ?? path7.join(homeDir, ".config/opencode");
+  const opencodeConfigDir = deps.opencodeConfigDir ?? path6.join(homeDir, ".config/opencode");
   const opencodeConfigDirOverride = process.env.OPENCODE_CONFIG_DIR?.trim() ? process.env.OPENCODE_CONFIG_DIR : undefined;
   return async (config) => {
     const { config: systematicConfig, overlays } = loadConfigWithSources(directory);
@@ -1287,21 +1161,21 @@ function registerSkillsPaths(config, skillsDir) {
   };
 }
 function removeSystematicSkillPaths(paths) {
-  return paths.filter((path8) => !isSystematicSkillPath(path8));
+  return paths.filter((path7) => !isSystematicSkillPath(path7));
 }
-function isSystematicSkillPath(path8) {
-  const normalizedPath = normalizePath(path8);
+function isSystematicSkillPath(path7) {
+  const normalizedPath = normalizePath(path7);
   return normalizedPath.endsWith("/.config/opencode/systematic/skills") || normalizedPath.endsWith("/.cache/opencode/systematic/skills") || normalizedPath.endsWith("/.local/share/opencode/systematic/skills") || normalizedPath.endsWith("/.opencode/systematic/skills") || /(?:^|\/)\.cache\/opencode\/packages\/@fro\.bot\/systematic@[^/]+\/node_modules\/@fro\.bot\/systematic\/skills(?:$|\/)/u.test(normalizedPath);
 }
-function normalizePath(path8) {
-  return path8.replaceAll("\\", "/").replace(/\/+$/u, "");
+function normalizePath(path7) {
+  return path7.replaceAll("\\", "/").replace(/\/+$/u, "");
 }
 
 // src/lib/opencode-operation-observer.ts
 import { spawnSync } from "child_process";
 import { createHash as createHash2 } from "crypto";
-import fs8 from "fs";
-import path8 from "path";
+import fs7 from "fs";
+import path7 from "path";
 var DEFAULT_LIMITS = {
   maxCommandOutputBytes: 1048576,
   maxCommandTimeoutMs: 5000,
@@ -1413,11 +1287,11 @@ function parseStageEntries(output, maxPathBytes) {
   return entries.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
 }
 function safePath(root, relativePath) {
-  if (path8.isAbsolute(relativePath))
+  if (path7.isAbsolute(relativePath))
     return;
-  const absolutePath = path8.resolve(root, relativePath);
-  const relative = path8.relative(root, absolutePath);
-  if (relative === "" || relative === ".." || relative.startsWith(`..${path8.sep}`)) {
+  const absolutePath = path7.resolve(root, relativePath);
+  const relative = path7.relative(root, absolutePath);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path7.sep}`)) {
     return;
   }
   return absolutePath;
@@ -1440,25 +1314,25 @@ function runCommand(runner, args2, cwd, limits) {
   }
   return { status: "ok", output: { stdout: result.stdout } };
 }
-function canonicalPath(filePath, realPath = fs8.realpathSync) {
+function canonicalPath(filePath, realPath = fs7.realpathSync) {
   try {
     return realPath(filePath);
   } catch {
     return;
   }
 }
-function requiredGitPath(runner, args2, cwd, limits, realPath = fs8.realpathSync) {
+function requiredGitPath(runner, args2, cwd, limits, realPath = fs7.realpathSync) {
   const result = runCommand(runner, args2, cwd, limits);
   if (result.status === "error")
     return result;
   const rawValue = result.output.stdout.trim();
-  if (!path8.isAbsolute(rawValue)) {
+  if (!path7.isAbsolute(rawValue)) {
     return { status: "error", reasonCode: "target-unavailable" };
   }
   const value = canonicalPath(rawValue, realPath);
   return value === undefined ? { status: "error", reasonCode: "target-unavailable" } : { status: "ok", value };
 }
-function captureParentIdentity(targetDirectory, runner, limits, realPath = fs8.realpathSync) {
+function captureParentIdentity(targetDirectory, runner, limits, realPath = fs7.realpathSync) {
   const targetRoot = requiredGitPath(runner, ["rev-parse", "--show-toplevel"], targetDirectory, limits, realPath);
   if (targetRoot.status === "error")
     return targetRoot;
@@ -1486,53 +1360,53 @@ function captureParentIdentity(targetDirectory, runner, limits, realPath = fs8.r
     }
   } : { status: "error", reasonCode: "target-unavailable" };
 }
-function readGitfileTarget(gitfilePath, realPath = fs8.realpathSync) {
+function readGitfileTarget(gitfilePath, realPath = fs7.realpathSync) {
   let contents;
   try {
-    contents = fs8.readFileSync(gitfilePath, "utf8");
+    contents = fs7.readFileSync(gitfilePath, "utf8");
   } catch {
     return;
   }
   const match = /^gitdir:\s*(.+?)\s*$/im.exec(contents);
   if (!match)
     return;
-  const target = path8.isAbsolute(match[1]) ? match[1] : path8.resolve(path8.dirname(gitfilePath), match[1]);
+  const target = path7.isAbsolute(match[1]) ? match[1] : path7.resolve(path7.dirname(gitfilePath), match[1]);
   return canonicalPath(target, realPath);
 }
 function readGitdirBacklink(backlinkPath, realPath) {
   let contents;
   try {
-    contents = fs8.readFileSync(backlinkPath, "utf8").trim();
+    contents = fs7.readFileSync(backlinkPath, "utf8").trim();
   } catch {
     return;
   }
   if (contents.length === 0)
     return;
-  const target = path8.isAbsolute(contents) ? contents : path8.resolve(path8.dirname(backlinkPath), contents);
+  const target = path7.isAbsolute(contents) ? contents : path7.resolve(path7.dirname(backlinkPath), contents);
   return canonicalPath(target, realPath);
 }
 function isPathWithin(root, candidate) {
-  const relative = path8.relative(root, candidate);
-  return relative !== "" && relative !== ".." && !relative.startsWith(`..${path8.sep}`) && !path8.isAbsolute(relative);
+  const relative = path7.relative(root, candidate);
+  return relative !== "" && relative !== ".." && !relative.startsWith(`..${path7.sep}`) && !path7.isAbsolute(relative);
 }
 function validateDotGitLinkage(targetRoot, gitDir, commonDir, realPath) {
-  const dotGit = path8.join(targetRoot, ".git");
+  const dotGit = path7.join(targetRoot, ".git");
   let dotGitStat;
   try {
-    dotGitStat = fs8.lstatSync(dotGit);
+    dotGitStat = fs7.lstatSync(dotGit);
   } catch {
     return false;
   }
   if (dotGitStat.isDirectory()) {
     return gitDir === commonDir && canonicalPath(dotGit, realPath) === commonDir;
   }
-  if (!dotGitStat.isFile() || dotGitStat.isSymbolicLink() || !isPathWithin(path8.join(commonDir, "worktrees"), gitDir) || readGitfileTarget(dotGit, realPath) !== gitDir) {
+  if (!dotGitStat.isFile() || dotGitStat.isSymbolicLink() || !isPathWithin(path7.join(commonDir, "worktrees"), gitDir) || readGitfileTarget(dotGit, realPath) !== gitDir) {
     return false;
   }
-  const backlinkPath = path8.join(gitDir, "gitdir");
+  const backlinkPath = path7.join(gitDir, "gitdir");
   let backlinkStat;
   try {
-    backlinkStat = fs8.lstatSync(backlinkPath);
+    backlinkStat = fs7.lstatSync(backlinkPath);
   } catch {
     return false;
   }
@@ -1541,7 +1415,7 @@ function validateDotGitLinkage(targetRoot, gitDir, commonDir, realPath) {
 function validateRegisteredWorktree(candidateDirectory, parentIdentity, options = {}) {
   const runner = options.commandRunner ?? defaultCommandRunner;
   const limits = mergeLimits(options.limits);
-  const realPath = options.realPath ?? fs8.realpathSync;
+  const realPath = options.realPath ?? fs7.realpathSync;
   const candidateRoot = canonicalPath(candidateDirectory, realPath);
   if (candidateRoot === undefined) {
     return { status: "error", reasonCode: "target-unavailable" };
@@ -1926,19 +1800,19 @@ function createOpencodeOperationObserver(options) {
   const limits = mergeLimits(options.limits);
   let targetDirectory;
   try {
-    targetDirectory = (options.realPath ?? fs8.realpathSync)(options.targetDirectory);
+    targetDirectory = (options.realPath ?? fs7.realpathSync)(options.targetDirectory);
   } catch {
-    targetDirectory = path8.resolve(options.targetDirectory);
+    targetDirectory = path7.resolve(options.targetDirectory);
   }
   const runner = options.commandRunner ?? defaultCommandRunner;
   const remoteRunner = options.remoteCommandRunner ?? defaultRemoteCommandRunner;
-  const realPath = options.realPath ?? fs8.realpathSync;
+  const realPath = options.realPath ?? fs7.realpathSync;
   const parentIdentityResult = captureParentIdentity(targetDirectory, runner, limits, realPath);
   const targetDigest = digest("target", [targetDirectory]);
-  const fileReader = options.fileReader ?? fs8.readFileSync;
-  const symlinkReader = options.symlinkReader ?? fs8.readlinkSync;
+  const fileReader = options.fileReader ?? fs7.readFileSync;
+  const symlinkReader = options.symlinkReader ?? fs7.readlinkSync;
   const statReader = options.statReader ?? ((filePath) => {
-    const stat = fs8.lstatSync(filePath);
+    const stat = fs7.lstatSync(filePath);
     return {
       isFile: stat.isFile(),
       isSymbolicLink: stat.isSymbolicLink(),
@@ -2001,8 +1875,8 @@ function createOpencodeOperationObserver(options) {
 
 // src/lib/opencode-workflow-guard.ts
 import { randomBytes as randomBytes4 } from "crypto";
-import fs10 from "fs";
-import path9 from "path";
+import fs9 from "fs";
+import path8 from "path";
 
 // src/lib/question-attestation.ts
 import { createHash as createHash3, randomBytes } from "crypto";
@@ -4542,7 +4416,7 @@ function normalizeCapabilities(input) {
 import { randomBytes as randomBytes3 } from "crypto";
 
 // src/lib/receipt-classifier.ts
-import fs9 from "fs";
+import fs8 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // node_modules/.bun/web-tree-sitter@0.25.10/node_modules/web-tree-sitter/tree-sitter.js
@@ -6002,11 +5876,11 @@ var Module2 = (() => {
       throw toThrow;
     }, "quit_");
     var scriptDirectory = "";
-    function locateFile(path9) {
+    function locateFile(path8) {
       if (Module["locateFile"]) {
-        return Module["locateFile"](path9, scriptDirectory);
+        return Module["locateFile"](path8, scriptDirectory);
       }
-      return scriptDirectory + path9;
+      return scriptDirectory + path8;
     }
     __name(locateFile, "locateFile");
     var readAsync, readBinary;
@@ -8080,7 +7954,7 @@ function matchesToolIdentity(tool, executable) {
 async function initializeParserAssets(options) {
   const treeSitterWasmPath = options.treeSitterWasmPath ?? resolveAsset("web-tree-sitter/tree-sitter.wasm");
   const bashWasmPath = options.bashWasmPath ?? resolveAsset("tree-sitter-bash/tree-sitter-bash.wasm");
-  if (!fs9.existsSync(treeSitterWasmPath) || !fs9.existsSync(bashWasmPath)) {
+  if (!fs8.existsSync(treeSitterWasmPath) || !fs8.existsSync(bashWasmPath)) {
     throw new Error("parser-asset-unavailable");
   }
   try {
@@ -10734,6 +10608,7 @@ function createWorkflowGuard(options) {
 var MARKER_OPEN = "<SYSTEMATIC_WORKFLOW_GUARD>";
 var MARKER_CLOSE = "</SYSTEMATIC_WORKFLOW_GUARD>";
 var MARKER_PROTOCOL_VERSION = 2;
+var LEGACY_MARKER_PROTOCOL_VERSION = 1;
 var MAX_MARKER_LENGTH = 4096;
 var MAX_MARKER_SOURCES = 8;
 var MAX_CALL_ID_LENGTH = 256;
@@ -10957,16 +10832,16 @@ function canonicalFileTarget(filePath, realPath) {
   const existing = canonicalExistingPath(filePath, realPath);
   if (existing)
     return existing;
-  const parent = canonicalExistingPath(path9.dirname(filePath), realPath);
-  const basename = path9.basename(filePath);
-  return parent && basename && basename !== "." && basename !== ".." ? path9.join(parent, basename) : undefined;
+  const parent = canonicalExistingPath(path8.dirname(filePath), realPath);
+  const basename = path8.basename(filePath);
+  return parent && basename && basename !== "." && basename !== ".." ? path8.join(parent, basename) : undefined;
 }
 function pathWithinOrEqual(root, candidate) {
-  const relative = path9.relative(root, candidate);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path9.sep}`) && !path9.isAbsolute(relative);
+  const relative = path8.relative(root, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path8.sep}`) && !path8.isAbsolute(relative);
 }
 function targetIsGitAdminStorage(targetPath, validation) {
-  return pathWithinOrEqual(path9.join(validation.targetRoot, ".git"), targetPath) || pathWithinOrEqual(validation.gitDir, targetPath) || pathWithinOrEqual(validation.commonDir, targetPath);
+  return pathWithinOrEqual(path8.join(validation.targetRoot, ".git"), targetPath) || pathWithinOrEqual(validation.gitDir, targetPath) || pathWithinOrEqual(validation.commonDir, targetPath);
 }
 function targetResultFromValidation(candidatePath, validation) {
   if (validation.status === "error")
@@ -10982,7 +10857,7 @@ function targetResultFromValidation(candidatePath, validation) {
 function trustedParentTarget(parentTargetRoot, candidatePath) {
   if (!pathWithinOrEqual(parentTargetRoot, candidatePath))
     return;
-  if (pathWithinOrEqual(path9.join(parentTargetRoot, ".git"), candidatePath)) {
+  if (pathWithinOrEqual(path8.join(parentTargetRoot, ".git"), candidatePath)) {
     return unavailableOperationTarget();
   }
   return { status: "available", targetRoot: parentTargetRoot };
@@ -10995,14 +10870,14 @@ function validationForCandidate(candidatePath, options, targetPath = candidatePa
   }
 }
 function deriveFileTarget(rawPath, baseDirectory, parentTargetRoot, options, realPath, allowParentFastPath = true) {
-  const resolvedPath = path9.resolve(baseDirectory, rawPath);
+  const resolvedPath = path8.resolve(baseDirectory, rawPath);
   const canonicalPath2 = canonicalFileTarget(resolvedPath, realPath);
   if (!canonicalPath2)
     return unavailableOperationTarget();
-  const parentResult = allowParentFastPath && !path9.isAbsolute(rawPath) ? trustedParentTarget(parentTargetRoot, canonicalPath2) : undefined;
+  const parentResult = allowParentFastPath && !path8.isAbsolute(rawPath) ? trustedParentTarget(parentTargetRoot, canonicalPath2) : undefined;
   if (parentResult)
     return parentResult;
-  return validationForCandidate(path9.dirname(canonicalPath2), options, canonicalPath2);
+  return validationForCandidate(path8.dirname(canonicalPath2), options, canonicalPath2);
 }
 function sharedTargetRoot(targets, extraRoots = []) {
   const roots = [...extraRoots];
@@ -11015,10 +10890,10 @@ function sharedTargetRoot(targets, extraRoots = []) {
   return targetRoot && roots.every((root) => root === targetRoot) ? targetRoot : undefined;
 }
 function deriveDirectoryTarget(rawPath, baseDirectory, parentTargetRoot, options, realPath) {
-  const resolvedPath = canonicalExistingPath(path9.resolve(baseDirectory, rawPath), realPath);
+  const resolvedPath = canonicalExistingPath(path8.resolve(baseDirectory, rawPath), realPath);
   if (!resolvedPath)
     return { status: "unavailable" };
-  const parentResult = path9.isAbsolute(rawPath) ? undefined : trustedParentTarget(parentTargetRoot, resolvedPath);
+  const parentResult = path8.isAbsolute(rawPath) ? undefined : trustedParentTarget(parentTargetRoot, resolvedPath);
   if (parentResult?.status === "unavailable") {
     return { status: "unavailable" };
   }
@@ -11126,14 +11001,14 @@ function deriveBashTarget(args2, sessionLocation, parentTargetRoot, options, rea
   if (typeof args2.workdir !== "string" || args2.workdir.length === 0) {
     return unavailableOperationTarget();
   }
-  const candidatePath = canonicalExistingPath(path9.resolve(sessionLocation, args2.workdir), realPath);
+  const candidatePath = canonicalExistingPath(path8.resolve(sessionLocation, args2.workdir), realPath);
   if (!candidatePath)
     return unavailableOperationTarget();
-  const parentResult = path9.isAbsolute(args2.workdir) ? undefined : trustedParentTarget(parentTargetRoot, candidatePath);
+  const parentResult = path8.isAbsolute(args2.workdir) ? undefined : trustedParentTarget(parentTargetRoot, candidatePath);
   return parentResult ?? validationForCandidate(candidatePath, options);
 }
 function deriveOpencodeOperationTarget(tool, args2, options) {
-  const realPath = options.realPath ?? fs10.realpathSync;
+  const realPath = options.realPath ?? fs9.realpathSync;
   const parentTargetRoot = canonicalExistingPath(options.parentTargetRoot, realPath);
   if (!parentTargetRoot)
     return unavailableOperationTarget();
@@ -11210,7 +11085,7 @@ function canonicalPatchText(patchText, sessionLocation) {
     const filePath = line.slice(prefix.length).trim();
     if (!filePath)
       return;
-    segments[index] = `${prefix}${path9.resolve(sessionLocation, filePath)}`;
+    segments[index] = `${prefix}${path8.resolve(sessionLocation, filePath)}`;
   }
   return segments.join("");
 }
@@ -11224,13 +11099,13 @@ function canonicalHunks(value, sessionLocation) {
     }
     const canonical = {
       ...hunk,
-      path: path9.resolve(sessionLocation, hunk.path)
+      path: path8.resolve(sessionLocation, hunk.path)
     };
     if (hunk.move_path !== undefined) {
       if (typeof hunk.move_path !== "string" || !hunk.move_path) {
         return;
       }
-      canonical.move_path = path9.resolve(sessionLocation, hunk.move_path);
+      canonical.move_path = path8.resolve(sessionLocation, hunk.move_path);
     }
     hunks.push(canonical);
   }
@@ -11384,8 +11259,9 @@ function parseMarkerBody(body2) {
     return;
   try {
     const parsed = JSON.parse(body2);
-    if (parsed.protocolVersion !== MARKER_PROTOCOL_VERSION)
+    if (parsed.protocolVersion !== MARKER_PROTOCOL_VERSION && parsed.protocolVersion !== LEGACY_MARKER_PROTOCOL_VERSION) {
       return;
+    }
     if (!Array.isArray(parsed.sources) || parsed.sources.length > MAX_MARKER_SOURCES) {
       return;
     }
@@ -11518,7 +11394,7 @@ function createSessionRuntime(options, operationObservers, recoveredOperationCon
   function parentObserverRegistration() {
     if (!options.observer)
       return;
-    const targetRoot = canonicalExistingPath(options.targetDirectory ?? process.cwd(), fs10.realpathSync);
+    const targetRoot = canonicalExistingPath(options.targetDirectory ?? process.cwd(), fs9.realpathSync);
     if (!targetRoot)
       return;
     let validation;
@@ -12467,7 +12343,7 @@ function createSessionRuntime(options, operationObservers, recoveredOperationCon
       markUnavailable();
       return;
     }
-    const canonicalParentTargetRoot = canonicalExistingPath(parentTargetRoot, fs10.realpathSync);
+    const canonicalParentTargetRoot = canonicalExistingPath(parentTargetRoot, fs9.realpathSync);
     if (!canonicalParentTargetRoot) {
       markUnavailable();
       return;
@@ -13503,8 +13379,8 @@ function createOpencodeWorkflowGuard(options) {
 }
 
 // src/lib/skill-resolver.ts
-import fs11 from "fs";
-import path10 from "path";
+import fs10 from "fs";
+import path9 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 function getAllSkills(options) {
   const { bundledSkillsDir, disabledSkills } = options;
@@ -13540,7 +13416,7 @@ function buildSkillToolParameterHint(options) {
 }
 function buildSkillContentOutput(matchedSkill) {
   const body2 = extractSkillBody(matchedSkill.wrappedTemplate);
-  const dir = path10.dirname(matchedSkill.skillFile);
+  const dir = path9.dirname(matchedSkill.skillFile);
   const base = pathToFileURL2(dir).href;
   const files = discoverSkillFiles(dir);
   const lines = [
@@ -13571,17 +13447,17 @@ function discoverSkillFiles(dir, limit = 10) {
   function handleEntry(entry, currentDir) {
     if (entry.isDirectory()) {
       if (!shouldSkipDirectory(entry.name)) {
-        recurse(path10.resolve(currentDir, entry.name));
+        recurse(path9.resolve(currentDir, entry.name));
       }
     } else if (shouldIncludeFile(entry.name)) {
-      files.push(path10.resolve(currentDir, entry.name));
+      files.push(path9.resolve(currentDir, entry.name));
     }
   }
   function recurse(currentDir) {
     if (files.length >= limit)
       return;
     try {
-      const entries = fs11.readdirSync(currentDir, { withFileTypes: true });
+      const entries = fs10.readdirSync(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         if (files.length >= limit)
           break;
@@ -13638,19 +13514,19 @@ function createSkillTool(options) {
 }
 
 // src/index.ts
-var __dirname3 = path11.dirname(fileURLToPath3(import.meta.url));
-var packageRoot2 = path11.resolve(__dirname3, "..");
-var bundledSkillsDir = path11.join(packageRoot2, "skills");
-var bundledAgentsDir2 = path11.join(packageRoot2, "agents");
-var bundledCommandsDir = path11.join(packageRoot2, "commands");
-var packageJsonPath = path11.join(packageRoot2, "package.json");
-var canonicalPackageSource = pathToFileURL3(fs12.realpathSync(packageRoot2)).href;
+var __dirname3 = path10.dirname(fileURLToPath3(import.meta.url));
+var packageRoot2 = path10.resolve(__dirname3, "..");
+var bundledSkillsDir = path10.join(packageRoot2, "skills");
+var bundledAgentsDir2 = path10.join(packageRoot2, "agents");
+var bundledCommandsDir = path10.join(packageRoot2, "commands");
+var packageJsonPath = path10.join(packageRoot2, "package.json");
+var canonicalPackageSource = pathToFileURL3(fs11.realpathSync(packageRoot2)).href;
 var registrationSourceIdentity = createHash5("sha256").update(`systematic/opencode-registration-source/v1/${canonicalPackageSource}`).digest("hex");
 var getPackageVersion = () => {
   try {
-    if (!fs12.existsSync(packageJsonPath))
+    if (!fs11.existsSync(packageJsonPath))
       return "unknown";
-    const content = fs12.readFileSync(packageJsonPath, "utf8");
+    const content = fs11.readFileSync(packageJsonPath, "utf8");
     const parsed = JSON.parse(content);
     return parsed.version ?? "unknown";
   } catch {