@fro.bot/systematic 2.33.3 → 3.0.1

package/dist/{index-vyzhzvap.js → index-yskzf7vh.js}

@@ -14,8 +14,9 @@ var __export = (target, all) => {
     });
 };
 
-// src/lib/converter.ts
-import fs from "fs";
+// src/lib/skills.ts
+import fs2 from "fs";
+import path2 from "path";
 
 // src/lib/frontmatter.ts
 import yaml from "js-yaml";
@@ -40,19 +41,6 @@ function parseFrontmatter(content) {
     return { data: {}, body, hadFrontmatter: true, parseError: true };
   }
 }
-function formatFrontmatter(data) {
-  if (Object.keys(data).length === 0) {
-    return ["---", "---"].join(`
-`);
-  }
-  const yamlContent = yaml.dump(data, {
-    schema: yaml.JSON_SCHEMA,
-    lineWidth: -1,
-    noRefs: true
-  }).trimEnd();
-  return ["---", yamlContent, "---"].join(`
-`);
-}
 
 // src/lib/validation.ts
 function isRecord(value) {
@@ -162,307 +150,18 @@ function extractBoolean(data, key) {
   return;
 }
 
-// src/lib/converter.ts
-var CONVERTER_VERSION = 2;
-var cache = new Map;
-var TOOL_MAPPINGS = [
-  [/\bTask\s+tool\b/gi, "task tool"],
-  [/\bTask\s+([\w-]+)\s*:/g, "task $1:"],
-  [/\bTask\s+([\w-]+)\s*\(/g, "task $1("],
-  [/\bTask\s*\(/g, "task("],
-  [/\bTask\b(?=\s+to\s+\w)/g, "task"],
-  [/\bTodoWrite\b/g, "todowrite"],
-  [/\bAskUserQuestion\b/g, "question"],
-  [/\bWebSearch\b/g, "google_search"],
-  [/\bRead\b(?=\s+tool|\s+to\s+|\()/g, "read"],
-  [/\bWrite\b(?=\s+tool|\s+to\s+|\()/g, "write"],
-  [/\bEdit\b(?=\s+tool|\s+to\s+|\()/g, "edit"],
-  [/\bBash\b(?=\s+tool|\s+to\s+|\()/g, "bash"],
-  [/\bGrep\b(?=\s+tool|\s+to\s+|\()/g, "grep"],
-  [/\bGlob\b(?=\s+tool|\s+to\s+|\()/g, "glob"],
-  [/\bWebFetch\b/g, "webfetch"],
-  [/\bSkill\b(?=\s+tool|\s*\()/g, "skill"]
-];
-var PATH_REPLACEMENTS = [
-  [/\.claude\/skills\//g, ".opencode/skills/"],
-  [/\.claude\/commands\//g, ".opencode/commands/"],
-  [/\.claude\/agents\//g, ".opencode/agents/"],
-  [/~\/\.claude\//g, "~/.config/opencode/"],
-  [/CLAUDE\.md/g, "AGENTS.md"],
-  [/\/compound-engineering:/g, "/systematic:"],
-  [/compound-engineering:/g, "systematic:"]
-];
-var TOOL_NAME_MAP = {
-  task: "task",
-  todowrite: "todowrite",
-  askuserquestion: "question",
-  websearch: "google_search",
-  webfetch: "webfetch",
-  skill: "skill",
-  read: "read",
-  write: "write",
-  edit: "edit",
-  bash: "bash",
-  grep: "grep",
-  glob: "glob"
-};
-var PERMISSION_MODE_MAP = {
-  full: {
-    edit: "allow",
-    bash: "allow",
-    webfetch: "allow"
-  },
-  default: {
-    edit: "ask",
-    bash: "ask",
-    webfetch: "ask"
-  },
-  plan: {
-    edit: "deny",
-    bash: "deny",
-    webfetch: "ask"
-  },
-  bypassPermissions: {
-    edit: "allow",
-    bash: "allow",
-    webfetch: "allow"
-  }
-};
-function inferTemperature(name, description) {
-  const sample = `${name} ${description ?? ""}`.toLowerCase();
-  if (/(review|audit|security|sentinel|oracle|lint|verification|guardian)/.test(sample)) {
-    return 0.1;
-  }
-  if (/(plan|planning|architecture|strategist|analysis|research)/.test(sample)) {
-    return 0.2;
-  }
-  if (/(doc|readme|changelog|editor|writer)/.test(sample)) {
-    return 0.3;
-  }
-  if (/(brainstorm|creative|ideate|design|concept)/.test(sample)) {
-    return 0.6;
-  }
-  return 0.3;
-}
-var CODE_BLOCK_PATTERN = /```[\s\S]*?```|`[^`\n]+`/g;
-function transformBody(body) {
-  const codeBlocks = [];
-  let placeholderIndex = 0;
-  const withPlaceholders = body.replace(CODE_BLOCK_PATTERN, (match) => {
-    codeBlocks.push(match);
-    return `__CODE_BLOCK_${placeholderIndex++}__`;
-  });
-  let result = withPlaceholders;
-  for (const [pattern, replacement] of TOOL_MAPPINGS) {
-    result = result.replace(pattern, replacement);
-  }
-  for (const [pattern, replacement] of PATH_REPLACEMENTS) {
-    result = result.replace(pattern, replacement);
-  }
-  for (let i = 0;i < codeBlocks.length; i++) {
-    result = result.replace(`__CODE_BLOCK_${i}__`, codeBlocks[i]);
-  }
-  return result;
-}
-function normalizeModel(model) {
-  if (model.includes("/"))
-    return model;
-  if (model === "inherit")
-    return model;
-  if (/^claude-/.test(model))
-    return `anthropic/${model}`;
-  if (/^(gpt-|o1-|o3-)/.test(model))
-    return `openai/${model}`;
-  if (/^gemini-/.test(model))
-    return `google/${model}`;
-  return `anthropic/${model}`;
-}
-function canonicalizeToolName(name) {
-  const lower = name.trim().toLowerCase();
-  return TOOL_NAME_MAP[lower] ?? lower;
-}
-function isValidSteps(value) {
-  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value > 0;
-}
-function mapStepsField(data) {
-  if (data.steps !== undefined) {
-    if (isValidSteps(data.steps)) {
-      delete data.maxTurns;
-      delete data.maxSteps;
-    }
-    return;
-  }
-  const candidates = [];
-  if (isValidSteps(data.maxTurns))
-    candidates.push(data.maxTurns);
-  if (isValidSteps(data.maxSteps))
-    candidates.push(data.maxSteps);
-  if (candidates.length > 0) {
-    data.steps = Math.min(...candidates);
-    delete data.maxTurns;
-    delete data.maxSteps;
-  }
-}
-function mapToolsField(data) {
-  if (data.tools !== undefined && !Array.isArray(data.tools)) {
-    if (isToolsMap(data.tools)) {
-      mergeDisallowedTools(data);
-    }
-    return;
-  }
-  if (Array.isArray(data.tools)) {
-    const toolsMap = {};
-    for (const tool of data.tools) {
-      if (typeof tool === "string") {
-        toolsMap[canonicalizeToolName(tool)] = true;
-      }
-    }
-    if (Object.keys(toolsMap).length > 0) {
-      data.tools = toolsMap;
-    } else {
-      delete data.tools;
-    }
-  }
-  mergeDisallowedTools(data);
-}
-function mergeDisallowedTools(data) {
-  if (!Array.isArray(data.disallowedTools))
-    return;
-  const existing = isToolsMap(data.tools) ? data.tools : {};
-  for (const tool of data.disallowedTools) {
-    if (typeof tool === "string") {
-      existing[canonicalizeToolName(tool)] = false;
-    }
-  }
-  if (Object.keys(existing).length > 0) {
-    data.tools = existing;
-  }
-  delete data.disallowedTools;
-}
-function mapPermissionMode(data) {
-  if (data.permission !== undefined) {
-    const normalized = normalizePermission(data.permission);
-    if (normalized) {
-      data.permission = normalized;
-      delete data.permissionMode;
-      return;
-    }
-  }
-  if (typeof data.permissionMode !== "string")
-    return;
-  const mapped = PERMISSION_MODE_MAP[data.permissionMode];
-  data.permission = mapped ?? { edit: "ask", bash: "ask", webfetch: "ask" };
-  delete data.permissionMode;
-}
-function mapHiddenField(data) {
-  if (data["disable-model-invocation"] === true || data.disableModelInvocation === true) {
-    data.hidden = true;
-    delete data["disable-model-invocation"];
-    delete data.disableModelInvocation;
-  }
-}
-function normalizeModelField(data) {
-  if (typeof data.model === "string" && data.model !== "inherit") {
-    data.model = normalizeModel(data.model);
-  } else if (data.model === "inherit") {
-    delete data.model;
-  }
-}
-function transformAgentFrontmatter(data, agentMode) {
-  const result = { ...data };
-  result.mode = isAgentMode(data.mode) ? data.mode : agentMode;
-  const name = typeof data.name === "string" ? data.name : "";
-  const description = typeof data.description === "string" ? data.description : "";
-  if (description) {
-    result.description = description;
-  } else if (name) {
-    result.description = `${name} agent`;
-  }
-  normalizeModelField(result);
-  result.temperature = typeof data.temperature === "number" ? data.temperature : inferTemperature(name, description);
-  mapStepsField(result);
-  mapToolsField(result);
-  mapPermissionMode(result);
-  mapHiddenField(result);
-  return result;
-}
-function transformSkillFrontmatter(data) {
-  const result = { ...data };
-  normalizeModelField(result);
-  if (result.context === "fork") {
-    result.subtask = true;
-  }
-  return result;
-}
-function transformCommandFrontmatter(data) {
-  const result = { ...data };
-  normalizeModelField(result);
-  return result;
-}
-function convertContent(content, type, options = {}) {
-  if (content === "")
-    return "";
-  const { data, body, hadFrontmatter, parseError } = parseFrontmatter(content);
-  if (!hadFrontmatter) {
-    return options.skipBodyTransform ? content : transformBody(content);
-  }
-  if (parseError) {
-    return options.skipBodyTransform ? content : transformBody(content);
-  }
-  const shouldTransformBody = !options.skipBodyTransform;
-  const transformedBody = shouldTransformBody ? transformBody(body) : body;
-  if (type === "agent") {
-    const agentMode = options.agentMode ?? "subagent";
-    const transformedData = transformAgentFrontmatter(data, agentMode);
-    return `${formatFrontmatter(transformedData)}
-${transformedBody}`;
-  }
-  if (type === "skill") {
-    const transformedData = transformSkillFrontmatter(data);
-    return `${formatFrontmatter(transformedData)}
-${transformedBody}`;
-  }
-  if (type === "command") {
-    const transformedData = transformCommandFrontmatter(data);
-    return `${formatFrontmatter(transformedData)}
-${transformedBody}`;
-  }
-  return content;
-}
-function convertFileWithCache(filePath, type, options = {}) {
-  const fd = fs.openSync(filePath, "r");
-  try {
-    const stats = fs.fstatSync(fd);
-    const cacheKey = `${CONVERTER_VERSION}:${filePath}:${type}:${options.source ?? "bundled"}:${options.agentMode ?? "subagent"}:${options.skipBodyTransform ?? false}`;
-    const cached = cache.get(cacheKey);
-    if (cached != null && cached.mtimeMs === stats.mtimeMs) {
-      return cached.converted;
-    }
-    const content = fs.readFileSync(fd, "utf8");
-    const converted = convertContent(content, type, options);
-    cache.set(cacheKey, { mtimeMs: stats.mtimeMs, converted });
-    return converted;
-  } finally {
-    fs.closeSync(fd);
-  }
-}
-
-// src/lib/skills.ts
-import fs3 from "fs";
-import path2 from "path";
-
 // src/lib/walk-dir.ts
-import fs2 from "fs";
+import fs from "fs";
 import path from "path";
 function walkDir(rootDir, options = {}) {
   const { maxDepth = 3, filter } = options;
   const results = [];
-  if (!fs2.existsSync(rootDir))
+  if (!fs.existsSync(rootDir))
     return results;
   function recurse(currentDir, depth, category) {
     if (depth > maxDepth)
       return;
-    const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path.join(currentDir, entry.name);
       const walkEntry = {
@@ -496,32 +195,12 @@ function parseMetadata(data) {
   }
   return Object.fromEntries(entries);
 }
-function parseDeprecated(data) {
-  const deprecatedRaw = data.deprecated;
-  if (!isRecord(deprecatedRaw)) {
-    return;
-  }
-  const since = typeof deprecatedRaw.since === "string" && deprecatedRaw.since !== "" ? deprecatedRaw.since : undefined;
-  const removal = typeof deprecatedRaw.removal === "string" && deprecatedRaw.removal !== "" ? deprecatedRaw.removal : undefined;
-  if (since === undefined || removal === undefined) {
-    return;
-  }
-  const deprecated = { since, removal };
-  if (typeof deprecatedRaw.replacement === "string") {
-    deprecated.replacement = deprecatedRaw.replacement;
-  }
-  if (typeof deprecatedRaw.reason === "string") {
-    deprecated.reason = deprecatedRaw.reason;
-  }
-  return deprecated;
-}
 function extractFrontmatterFromContent(content) {
   const { data, parseError } = parseFrontmatter(content);
   if (parseError) {
     return { name: "", description: "" };
   }
   const metadata = parseMetadata(data);
-  const deprecated = parseDeprecated(data);
   const argumentHintRaw = extractNonEmptyString(data, "argument-hint");
   const argumentHint = argumentHintRaw?.replace(/^["']|["']$/g, "") || undefined;
   return {
@@ -530,7 +209,6 @@ function extractFrontmatterFromContent(content) {
     license: extractNonEmptyString(data, "license"),
     compatibility: extractNonEmptyString(data, "compatibility"),
     metadata,
-    deprecated,
     disableModelInvocation: extractBoolean(data, "disable-model-invocation"),
     userInvocable: extractBoolean(data, "user-invocable"),
     subtask: data.context === "fork" ? true : extractBoolean(data, "subtask") ?? undefined,
@@ -542,7 +220,7 @@ function extractFrontmatterFromContent(content) {
 }
 function extractFrontmatter(filePath) {
   try {
-    const content = fs3.readFileSync(filePath, "utf8");
+    const content = fs2.readFileSync(filePath, "utf8");
     return extractFrontmatterFromContent(content);
   } catch {
     return { name: "", description: "" };
@@ -556,7 +234,7 @@ function findSkillsInDir(dir, maxDepth = 3) {
   });
   for (const entry of entries) {
     const skillFile = path2.join(entry.path, "SKILL.md");
-    if (fs3.existsSync(skillFile)) {
+    if (fs2.existsSync(skillFile)) {
       const frontmatter = extractFrontmatter(skillFile);
       skills.push({
         path: entry.path,
@@ -566,7 +244,6 @@ function findSkillsInDir(dir, maxDepth = 3) {
         license: frontmatter.license,
         compatibility: frontmatter.compatibility,
         metadata: frontmatter.metadata,
-        deprecated: frontmatter.deprecated,
         disableModelInvocation: frontmatter.disableModelInvocation,
         userInvocable: frontmatter.userInvocable,
         subtask: frontmatter.subtask,
@@ -581,7 +258,7 @@ function findSkillsInDir(dir, maxDepth = 3) {
 }
 
 // src/lib/config.ts
-import fs4 from "fs";
+import fs3 from "fs";
 import os from "os";
 import path3 from "path";
 
@@ -1033,6 +710,249 @@ var cachedBreakLinesWithSpaces = {
     })
   }
 };
+var supportedEols = [`
+`, "\r", `\r
+`];
+
+// node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/format.js
+function format(documentText, range, options) {
+  let initialIndentLevel;
+  let formatText;
+  let formatTextStart;
+  let rangeStart;
+  let rangeEnd;
+  if (range) {
+    rangeStart = range.offset;
+    rangeEnd = rangeStart + range.length;
+    formatTextStart = rangeStart;
+    while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
+      formatTextStart--;
+    }
+    let endOffset = rangeEnd;
+    while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
+      endOffset++;
+    }
+    formatText = documentText.substring(formatTextStart, endOffset);
+    initialIndentLevel = computeIndentLevel(formatText, options);
+  } else {
+    formatText = documentText;
+    initialIndentLevel = 0;
+    formatTextStart = 0;
+    rangeStart = 0;
+    rangeEnd = documentText.length;
+  }
+  const eol = getEOL(options, documentText);
+  const eolFastPathSupported = supportedEols.includes(eol);
+  let numberLineBreaks = 0;
+  let indentLevel = 0;
+  let indentValue;
+  if (options.insertSpaces) {
+    indentValue = cachedSpaces[options.tabSize || 4] ?? repeat(cachedSpaces[1], options.tabSize || 4);
+  } else {
+    indentValue = "\t";
+  }
+  const indentType = indentValue === "\t" ? "\t" : " ";
+  let scanner = createScanner(formatText, false);
+  let hasError = false;
+  function newLinesAndIndent() {
+    if (numberLineBreaks > 1) {
+      return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel);
+    if (!eolFastPathSupported || amountOfSpaces > cachedBreakLinesWithSpaces[indentType][eol].length) {
+      return eol + repeat(indentValue, initialIndentLevel + indentLevel);
+    }
+    if (amountOfSpaces <= 0) {
+      return eol;
+    }
+    return cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces];
+  }
+  function scanNext() {
+    let token = scanner.scan();
+    numberLineBreaks = 0;
+    while (token === 15 || token === 14) {
+      if (token === 14 && options.keepLines) {
+        numberLineBreaks += 1;
+      } else if (token === 14) {
+        numberLineBreaks = 1;
+      }
+      token = scanner.scan();
+    }
+    hasError = token === 16 || scanner.getTokenError() !== 0;
+    return token;
+  }
+  const editOperations = [];
+  function addEdit(text, startOffset, endOffset) {
+    if (!hasError && (!range || startOffset < rangeEnd && endOffset > rangeStart) && documentText.substring(startOffset, endOffset) !== text) {
+      editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
+    }
+  }
+  let firstToken = scanNext();
+  if (options.keepLines && numberLineBreaks > 0) {
+    addEdit(repeat(eol, numberLineBreaks), 0, 0);
+  }
+  if (firstToken !== 17) {
+    let firstTokenStart = scanner.getTokenOffset() + formatTextStart;
+    let initialIndent = indentValue.length * initialIndentLevel < 20 && options.insertSpaces ? cachedSpaces[indentValue.length * initialIndentLevel] : repeat(indentValue, initialIndentLevel);
+    addEdit(initialIndent, formatTextStart, firstTokenStart);
+  }
+  while (firstToken !== 17) {
+    let firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+    let secondToken = scanNext();
+    let replaceContent = "";
+    let needsLineBreak = false;
+    while (numberLineBreaks === 0 && (secondToken === 12 || secondToken === 13)) {
+      let commentTokenStart = scanner.getTokenOffset() + formatTextStart;
+      addEdit(cachedSpaces[1], firstTokenEnd, commentTokenStart);
+      firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
+      needsLineBreak = secondToken === 12;
+      replaceContent = needsLineBreak ? newLinesAndIndent() : "";
+      secondToken = scanNext();
+    }
+    if (secondToken === 2) {
+      if (firstToken !== 1) {
+        indentLevel--;
+      }
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 1) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else if (secondToken === 4) {
+      if (firstToken !== 3) {
+        indentLevel--;
+      }
+      if (options.keepLines && numberLineBreaks > 0 || !options.keepLines && firstToken !== 3) {
+        replaceContent = newLinesAndIndent();
+      } else if (options.keepLines) {
+        replaceContent = cachedSpaces[1];
+      }
+    } else {
+      switch (firstToken) {
+        case 3:
+        case 1:
+          indentLevel++;
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 5:
+          if (options.keepLines && numberLineBreaks > 0 || !options.keepLines) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 12:
+          replaceContent = newLinesAndIndent();
+          break;
+        case 13:
+          if (numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 6:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (!needsLineBreak) {
+            replaceContent = cachedSpaces[1];
+          }
+          break;
+        case 10:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else if (secondToken === 6 && !needsLineBreak) {
+            replaceContent = "";
+          }
+          break;
+        case 7:
+        case 8:
+        case 9:
+        case 11:
+        case 2:
+        case 4:
+          if (options.keepLines && numberLineBreaks > 0) {
+            replaceContent = newLinesAndIndent();
+          } else {
+            if ((secondToken === 12 || secondToken === 13) && !needsLineBreak) {
+              replaceContent = cachedSpaces[1];
+            } else if (secondToken !== 5 && secondToken !== 17) {
+              hasError = true;
+            }
+          }
+          break;
+        case 16:
+          hasError = true;
+          break;
+      }
+      if (numberLineBreaks > 0 && (secondToken === 12 || secondToken === 13)) {
+        replaceContent = newLinesAndIndent();
+      }
+    }
+    if (secondToken === 17) {
+      if (options.keepLines && numberLineBreaks > 0) {
+        replaceContent = newLinesAndIndent();
+      } else {
+        replaceContent = options.insertFinalNewline ? eol : "";
+      }
+    }
+    const secondTokenStart = scanner.getTokenOffset() + formatTextStart;
+    addEdit(replaceContent, firstTokenEnd, secondTokenStart);
+    firstToken = secondToken;
+  }
+  return editOperations;
+}
+function repeat(s, count) {
+  let result = "";
+  for (let i = 0;i < count; i++) {
+    result += s;
+  }
+  return result;
+}
+function computeIndentLevel(content, options) {
+  let i = 0;
+  let nChars = 0;
+  const tabSize = options.tabSize || 4;
+  while (i < content.length) {
+    let ch = content.charAt(i);
+    if (ch === cachedSpaces[1]) {
+      nChars++;
+    } else if (ch === "\t") {
+      nChars += tabSize;
+    } else {
+      break;
+    }
+    i++;
+  }
+  return Math.floor(nChars / tabSize);
+}
+function getEOL(options, text) {
+  for (let i = 0;i < text.length; i++) {
+    const ch = text.charAt(i);
+    if (ch === "\r") {
+      if (i + 1 < text.length && text.charAt(i + 1) === `
+`) {
+        return `\r
+`;
+      }
+      return "\r";
+    } else if (ch === `
+`) {
+      return `
+`;
+    }
+  }
+  return options && options.eol || `
+`;
+}
+function isEOL(text, offset) {
+  return `\r
+`.indexOf(text.charAt(offset)) !== -1;
+}
 
 // node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/parser.js
 var ParseOptions;
@@ -1084,6 +1004,95 @@ function parse(text, errors = [], options = ParseOptions.DEFAULT) {
   visit(text, visitor, options);
   return currentParent[0];
 }
+function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentParent = { type: "array", offset: -1, length: -1, children: [], parent: undefined };
+  function ensurePropertyComplete(endOffset) {
+    if (currentParent.type === "property") {
+      currentParent.length = endOffset - currentParent.offset;
+      currentParent = currentParent.parent;
+    }
+  }
+  function onValue(valueNode) {
+    currentParent.children.push(valueNode);
+    return valueNode;
+  }
+  const visitor = {
+    onObjectBegin: (offset) => {
+      currentParent = onValue({ type: "object", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onObjectProperty: (name, offset, length) => {
+      currentParent = onValue({ type: "property", offset, length: -1, parent: currentParent, children: [] });
+      currentParent.children.push({ type: "string", value: name, offset, length, parent: currentParent });
+    },
+    onObjectEnd: (offset, length) => {
+      ensurePropertyComplete(offset + length);
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onArrayBegin: (offset, length) => {
+      currentParent = onValue({ type: "array", offset, length: -1, parent: currentParent, children: [] });
+    },
+    onArrayEnd: (offset, length) => {
+      currentParent.length = offset + length - currentParent.offset;
+      currentParent = currentParent.parent;
+      ensurePropertyComplete(offset + length);
+    },
+    onLiteralValue: (value, offset, length) => {
+      onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
+      ensurePropertyComplete(offset + length);
+    },
+    onSeparator: (sep, offset, length) => {
+      if (currentParent.type === "property") {
+        if (sep === ":") {
+          currentParent.colonOffset = offset;
+        } else if (sep === ",") {
+          ensurePropertyComplete(offset);
+        }
+      }
+    },
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  const result = currentParent.children[0];
+  if (result) {
+    delete result.parent;
+  }
+  return result;
+}
+function findNodeAtLocation(root, path3) {
+  if (!root) {
+    return;
+  }
+  let node = root;
+  for (let segment of path3) {
+    if (typeof segment === "string") {
+      if (node.type !== "object" || !Array.isArray(node.children)) {
+        return;
+      }
+      let found = false;
+      for (const propertyNode of node.children) {
+        if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment && propertyNode.children.length === 2) {
+          node = propertyNode.children[1];
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return;
+      }
+    } else {
+      const index = segment;
+      if (node.type !== "array" || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
+        return;
+      }
+      node = node.children[index];
+    }
+  }
+  return node;
+}
 function visit(text, visitor, options = ParseOptions.DEFAULT) {
   const _scanner = createScanner(text, false);
   const _jsonPath = [];
@@ -1336,6 +1345,170 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
   }
   return true;
 }
+function getNodeType(value) {
+  switch (typeof value) {
+    case "boolean":
+      return "boolean";
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "object": {
+      if (!value) {
+        return "null";
+      } else if (Array.isArray(value)) {
+        return "array";
+      }
+      return "object";
+    }
+    default:
+      return "null";
+  }
+}
+
+// node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/edit.js
+function setProperty(text, originalPath, value, options) {
+  const path3 = originalPath.slice();
+  const errors = [];
+  const root = parseTree(text, errors);
+  let parent = undefined;
+  let lastSegment = undefined;
+  while (path3.length > 0) {
+    lastSegment = path3.pop();
+    parent = findNodeAtLocation(root, path3);
+    if (parent === undefined && value !== undefined) {
+      if (typeof lastSegment === "string") {
+        value = { [lastSegment]: value };
+      } else {
+        value = [value];
+      }
+    } else {
+      break;
+    }
+  }
+  if (!parent) {
+    if (value === undefined) {
+      throw new Error("Can not delete in empty document");
+    }
+    return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
+  } else if (parent.type === "object" && typeof lastSegment === "string" && Array.isArray(parent.children)) {
+    const existing = findNodeAtLocation(parent, [lastSegment]);
+    if (existing !== undefined) {
+      if (value === undefined) {
+        if (!existing.parent) {
+          throw new Error("Malformed AST");
+        }
+        const propertyIndex = parent.children.indexOf(existing.parent);
+        let removeBegin;
+        let removeEnd = existing.parent.offset + existing.parent.length;
+        if (propertyIndex > 0) {
+          let previous = parent.children[propertyIndex - 1];
+          removeBegin = previous.offset + previous.length;
+        } else {
+          removeBegin = parent.offset + 1;
+          if (parent.children.length > 1) {
+            let next = parent.children[1];
+            removeEnd = next.offset;
+          }
+        }
+        return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: "" }, options);
+      } else {
+        return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
+      }
+    } else {
+      if (value === undefined) {
+        return [];
+      }
+      const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
+      const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map((p) => p.children[0].value)) : parent.children.length;
+      let edit;
+      if (index > 0) {
+        let previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      } else if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty + "," };
+      }
+      return withFormatting(text, edit, options);
+    }
+  } else if (parent.type === "array" && typeof lastSegment === "number" && Array.isArray(parent.children)) {
+    const insertIndex = lastSegment;
+    if (insertIndex === -1) {
+      const newProperty = `${JSON.stringify(value)}`;
+      let edit;
+      if (parent.children.length === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: newProperty };
+      } else {
+        const previous = parent.children[parent.children.length - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value === undefined && parent.children.length >= 0) {
+      const removalIndex = lastSegment;
+      const toRemove = parent.children[removalIndex];
+      let edit;
+      if (parent.children.length === 1) {
+        edit = { offset: parent.offset + 1, length: parent.length - 2, content: "" };
+      } else if (parent.children.length - 1 === removalIndex) {
+        let previous = parent.children[removalIndex - 1];
+        let offset = previous.offset + previous.length;
+        let parentEndOffset = parent.offset + parent.length;
+        edit = { offset, length: parentEndOffset - 2 - offset, content: "" };
+      } else {
+        edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: "" };
+      }
+      return withFormatting(text, edit, options);
+    } else if (value !== undefined) {
+      let edit;
+      const newProperty = `${JSON.stringify(value)}`;
+      if (!options.isArrayInsertion && parent.children.length > lastSegment) {
+        const toModify = parent.children[lastSegment];
+        edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
+      } else if (parent.children.length === 0 || lastSegment === 0) {
+        edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + "," };
+      } else {
+        const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
+        const previous = parent.children[index - 1];
+        edit = { offset: previous.offset + previous.length, length: 0, content: "," + newProperty };
+      }
+      return withFormatting(text, edit, options);
+    } else {
+      throw new Error(`Can not ${value === undefined ? "remove" : options.isArrayInsertion ? "insert" : "modify"} Array index ${insertIndex} as length is not sufficient`);
+    }
+  } else {
+    throw new Error(`Can not add ${typeof lastSegment !== "number" ? "index" : "property"} to parent of type ${parent.type}`);
+  }
+}
+function withFormatting(text, edit, options) {
+  if (!options.formattingOptions) {
+    return [edit];
+  }
+  let newText = applyEdit(text, edit);
+  let begin = edit.offset;
+  let end = edit.offset + edit.content.length;
+  if (edit.length === 0 || edit.content.length === 0) {
+    while (begin > 0 && !isEOL(newText, begin - 1)) {
+      begin--;
+    }
+    while (end < newText.length && !isEOL(newText, end)) {
+      end++;
+    }
+  }
+  const edits = format(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
+  for (let i = edits.length - 1;i >= 0; i--) {
+    const edit2 = edits[i];
+    newText = applyEdit(newText, edit2);
+    begin = Math.min(begin, edit2.offset);
+    end = Math.max(end, edit2.offset + edit2.length);
+    end += edit2.content.length - edit2.length;
+  }
+  const editLength = text.length - (newText.length - end) - begin;
+  return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
+}
+function applyEdit(text, edit) {
+  return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
+}
 
 // node_modules/.bun/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/main.js
 var ScanError;
@@ -1369,6 +1542,7 @@ var SyntaxKind;
   SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
 })(SyntaxKind || (SyntaxKind = {}));
 var parse2 = parse;
+var parseTree2 = parseTree;
 var ParseErrorCode;
 (function(ParseErrorCode2) {
   ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
@@ -1425,44 +1599,55 @@ function printParseErrorCode(code) {
   }
   return "<unknown ParseErrorCode>";
 }
+function modify(text, path3, value, options) {
+  return setProperty(text, path3, value, options);
+}
+function applyEdits(text, edits) {
+  let sortedEdits = edits.slice(0).sort((a, b) => {
+    const diff = a.offset - b.offset;
+    if (diff === 0) {
+      return a.length - b.length;
+    }
+    return diff;
+  });
+  let lastModifiedOffset = text.length;
+  for (let i = sortedEdits.length - 1;i >= 0; i--) {
+    let e = sortedEdits[i];
+    if (e.offset + e.length <= lastModifiedOffset) {
+      text = applyEdit(text, e);
+    } else {
+      throw new Error("Overlapping edit");
+    }
+    lastModifiedOffset = e.offset;
+  }
+  return text;
+}
 
 // src/lib/bundled-names.ts
 var BUNDLED_AGENT_NAMES = [
   "adversarial-document-reviewer",
   "adversarial-reviewer",
   "agent-native-reviewer",
-  "ankane-readme-writer",
   "api-contract-reviewer",
   "architecture-strategist",
   "best-practices-researcher",
   "bug-reproduction-validator",
-  "cli-agent-readiness-reviewer",
   "cli-readiness-reviewer",
   "code-simplicity-reviewer",
   "coherence-reviewer",
   "correctness-reviewer",
-  "data-integrity-guardian",
-  "data-migration-expert",
   "data-migrations-reviewer",
   "deployment-verification-agent",
-  "design-implementation-reviewer",
   "design-iterator",
   "design-lens-reviewer",
-  "dhh-rails-reviewer",
   "feasibility-reviewer",
-  "figma-design-sync",
   "framework-docs-researcher",
   "git-history-analyzer",
   "issue-intelligence-analyst",
-  "julik-frontend-races-reviewer",
-  "kieran-python-reviewer",
-  "kieran-rails-reviewer",
   "kieran-typescript-reviewer",
   "learnings-researcher",
-  "lint",
   "maintainability-reviewer",
   "pattern-recognition-specialist",
-  "performance-oracle",
   "performance-reviewer",
   "pr-comment-resolver",
   "previous-comments-reviewer",
@@ -1470,21 +1655,16 @@ var BUNDLED_AGENT_NAMES = [
   "project-standards-reviewer",
   "reliability-reviewer",
   "repo-research-analyst",
-  "schema-drift-detector",
   "scope-guardian-reviewer",
   "security-lens-reviewer",
   "security-reviewer",
-  "security-sentinel",
   "slack-researcher",
   "spec-flow-analyzer",
   "systematic-implementer",
   "testing-reviewer"
 ];
 var BUNDLED_AGENT_QUALIFIED_IDS = [
-  "design/design-implementation-reviewer",
   "design/design-iterator",
-  "design/figma-design-sync",
-  "docs/ankane-readme-writer",
   "document-review/adversarial-document-reviewer",
   "document-review/coherence-reviewer",
   "document-review/design-lens-reviewer",
@@ -1503,32 +1683,21 @@ var BUNDLED_AGENT_QUALIFIED_IDS = [
   "review/agent-native-reviewer",
   "review/api-contract-reviewer",
   "review/architecture-strategist",
-  "review/cli-agent-readiness-reviewer",
   "review/cli-readiness-reviewer",
   "review/code-simplicity-reviewer",
   "review/correctness-reviewer",
-  "review/data-integrity-guardian",
-  "review/data-migration-expert",
   "review/data-migrations-reviewer",
   "review/deployment-verification-agent",
-  "review/dhh-rails-reviewer",
-  "review/julik-frontend-races-reviewer",
-  "review/kieran-python-reviewer",
-  "review/kieran-rails-reviewer",
   "review/kieran-typescript-reviewer",
   "review/maintainability-reviewer",
   "review/pattern-recognition-specialist",
-  "review/performance-oracle",
   "review/performance-reviewer",
   "review/previous-comments-reviewer",
   "review/project-standards-reviewer",
   "review/reliability-reviewer",
-  "review/schema-drift-detector",
   "review/security-reviewer",
-  "review/security-sentinel",
   "review/testing-reviewer",
   "workflow/bug-reproduction-validator",
-  "workflow/lint",
   "workflow/pr-comment-resolver",
   "workflow/spec-flow-analyzer",
   "workflow/systematic-implementer"
@@ -1537,7 +1706,6 @@ var BUNDLED_SKILL_NAMES = [
   "agent-browser",
   "agent-native-architecture",
   "agent-native-audit",
-  "andrew-kane-gem-writer",
   "ce:brainstorm",
   "ce:compound",
   "ce:compound-refresh",
@@ -1545,19 +1713,11 @@ var BUNDLED_SKILL_NAMES = [
   "ce:plan",
   "ce:review",
   "ce:work",
-  "changelog",
-  "claude-permissions-optimizer",
   "compound-docs",
   "deepen-plan",
   "deploy-docs",
-  "dhh-rails-style",
   "document-review",
-  "dspy-ruby",
-  "every-style-editor",
-  "feature-video",
   "frontend-design",
-  "gemini-imagegen",
-  "generate_command",
   "git-clean-gone-branches",
   "git-commit",
   "git-commit-push-pr",
@@ -1565,23 +1725,15 @@ var BUNDLED_SKILL_NAMES = [
   "lfg",
   "onboarding",
   "orchestrating-subagents",
-  "orchestrating-swarms",
-  "proof",
-  "rclone",
   "report-bug-ce",
   "reproduce-bug",
   "resolve-pr-feedback",
-  "setup",
   "slfg",
   "test-browser",
   "test-driven-development",
-  "test-xcode",
-  "todo-create",
-  "todo-resolve",
-  "todo-triage",
+  "todos",
   "using-systematic",
-  "writing-skills",
-  "writing-systematic-skills"
+  "writing-skills"
 ];
 
 // node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
@@ -15872,8 +16024,56 @@ var OPENCODE_AGENT_COLOR_TOKENS = [
 ];
 
 // src/lib/removed-names.ts
-var REMOVED_BUNDLED_SKILL_NAMES = [];
-var REMOVED_BUNDLED_AGENT_NAMES = [];
+var REMOVED_BUNDLED_SKILL_NAMES = [
+  "andrew-kane-gem-writer",
+  "changelog",
+  "claude-permissions-optimizer",
+  "dhh-rails-style",
+  "dspy-ruby",
+  "every-style-editor",
+  "feature-video",
+  "gemini-imagegen",
+  "generate_command",
+  "orchestrating-swarms",
+  "proof",
+  "rclone",
+  "setup",
+  "test-xcode",
+  "todo-create",
+  "todo-resolve",
+  "todo-triage",
+  "writing-systematic-skills"
+];
+var REMOVED_BUNDLED_AGENT_NAMES = [
+  "ankane-readme-writer",
+  "cli-agent-readiness-reviewer",
+  "data-integrity-guardian",
+  "data-migration-expert",
+  "design-implementation-reviewer",
+  "design/design-implementation-reviewer",
+  "design/figma-design-sync",
+  "dhh-rails-reviewer",
+  "docs/ankane-readme-writer",
+  "figma-design-sync",
+  "julik-frontend-races-reviewer",
+  "kieran-python-reviewer",
+  "kieran-rails-reviewer",
+  "lint",
+  "performance-oracle",
+  "review/cli-agent-readiness-reviewer",
+  "review/data-integrity-guardian",
+  "review/data-migration-expert",
+  "review/dhh-rails-reviewer",
+  "review/julik-frontend-races-reviewer",
+  "review/kieran-python-reviewer",
+  "review/kieran-rails-reviewer",
+  "review/performance-oracle",
+  "review/schema-drift-detector",
+  "review/security-sentinel",
+  "schema-drift-detector",
+  "security-sentinel",
+  "workflow/lint"
+];
 
 // src/lib/config-schema.ts
 var permissionSettingSchema = exports_external.enum(["ask", "allow", "deny"]);
@@ -16009,7 +16209,7 @@ function createSystematicConfigSchema(opts) {
     $schema: exports_external.string().url().optional().meta({
       description: "JSON Schema URL for IDE autocomplete. The value is informational only \u2014 the loader does not fetch or validate against it. Add this to enable IDE schema activation and field-level autocomplete in editors that support JSON Schema (VSCode, Zed, IntelliJ).",
       examples: [
-        "https://fro.bot/systematic/schemas/v2/systematic-config.schema.json"
+        "https://fro.bot/systematic/schemas/latest/systematic-config.schema.json"
       ]
     }),
     agents: exports_external.object(Object.fromEntries([...agentNames, ...qualifiedAgentIds].map((name) => [
@@ -16099,17 +16299,18 @@ var CURRENT_AGENT_NAMES_SET = new Set([
 function computeDroppedNames(names, allowedSet) {
   return names.filter((n) => !allowedSet.has(n));
 }
+var MIGRATION_DOCS_URL = "https://fro.bot/systematic/guides/v3-migration/";
 function warnDroppedNames(dropped, field, warned) {
   for (const name of dropped) {
     if (warned.has(name))
       continue;
     warned.add(name);
-    console.warn(`[systematic] "${name}" in \`${field}\` is no longer a bundled name and will be ignored. Remove it from your config to silence this warning.`);
+    console.warn(`[systematic] "${name}" in \`${field}\` is no longer a bundled name and will be ignored. Remove it from your config to silence this warning. See ${MIGRATION_DOCS_URL} for migration guidance.`);
   }
 }
 function resolveConfigPath(dir, basename) {
   const jsoncPath = path3.join(dir, `${basename}.jsonc`);
-  if (fs4.existsSync(jsoncPath))
+  if (fs3.existsSync(jsoncPath))
     return jsoncPath;
   return path3.join(dir, `${basename}.json`);
 }
@@ -16119,7 +16320,7 @@ function isErrorWithCode(error51) {
 function loadJsoncFile(filePath) {
   let content;
   try {
-    content = fs4.readFileSync(filePath, "utf-8");
+    content = fs3.readFileSync(filePath, "utf-8");
   } catch (error51) {
     if (isErrorWithCode(error51) && error51.code === "ENOENT")
       return null;
@@ -16425,4 +16626,4 @@ function extractCommandFrontmatter(content) {
   };
 }
 
-export { parseFrontmatter, isRecord, convertContent, convertFileWithCache, walkDir, extractFrontmatterFromContent, findSkillsInDir, exports_external, AgentOverlaySchema, CategoryOverlaySchema, loadConfig, loadConfigWithSources, getConfigPaths, findAgentsInDir, extractAgentFrontmatter, findCommandsInDir, extractCommandFrontmatter };
+export { parseFrontmatter, isRecord, walkDir, extractFrontmatterFromContent, findSkillsInDir, parse2 as parse, parseTree2 as parseTree, modify, applyEdits, exports_external, AgentOverlaySchema, CategoryOverlaySchema, loadConfig, loadConfigWithSources, getConfigPaths, findAgentsInDir, extractAgentFrontmatter, findCommandsInDir, extractCommandFrontmatter };