thoth-agents 0.1.2 → 0.1.5

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cli/index.js

@@ -6,6 +6,7 @@ import { pathToFileURL } from "url";
 // src/harness/adapters/codex.ts
 import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
 import { dirname as dirname2, resolve } from "path";
+import { fileURLToPath } from "url";
 
 // src/agents/prompt-dialects.ts
 var OPENCODE_CAPABILITIES = {
@@ -2461,7 +2462,8 @@ function renderCodexSkillLayout(input) {
   for (const skill of [...input.skills].sort(
     (left, right) => left.name.localeCompare(right.name)
   )) {
-    const sourceRoot = path2.join(input.projectRoot, skill.sourcePath);
+    const sourceBaseRoot = input.packageRoot ?? input.projectRoot;
+    const sourceRoot = path2.join(sourceBaseRoot, skill.sourcePath);
     const files = collectFiles(sourceRoot);
     if (files.length === 0) {
       diagnostics.push({
@@ -2477,7 +2479,7 @@ function renderCodexSkillLayout(input) {
     for (const file of files) {
       const relative4 = normalizePath2(path2.relative(sourceRoot, file));
       const content = fs2.readFileSync(file, "utf8");
-      const sourcePath = normalizePath2(path2.relative(input.projectRoot, file));
+      const sourcePath = normalizePath2(path2.relative(sourceBaseRoot, file));
       for (const mode of outputModes) {
         const config = OUTPUT_MODE_CONFIG[mode];
         const outputPath = `${config.basePath}/${skill.name}/${relative4}`;
@@ -2512,14 +2514,19 @@ function renderCodexSkillLayout(input) {
 }
 
 // src/harness/adapters/codex.ts
-function readRootPackageVersion(startDir) {
-  const packageJsonPath = findRootPackageJsonPath([startDir, process.cwd()]);
+function readRootPackageVersion(context) {
+  const packageJsonPath = findRootPackageJsonPath([
+    ...hasCodexPackageRoot(context) ? [context.packageRoot] : [],
+    context.projectRoot,
+    process.cwd(),
+    fileURLToPath(new URL(".", import.meta.url))
+  ]);
   return readPackageJsonVersion(packageJsonPath);
 }
-function createCodexPluginPackageManifest(projectRoot) {
+function createCodexPluginPackageManifest(context) {
   return {
     name: "thoth-agents",
-    version: readRootPackageVersion(projectRoot),
+    version: readRootPackageVersion(context),
     description: "Delegate-first OpenCode plugin with seven agents, thoth-mem persistence, and bundled SDD skills."
   };
 }
@@ -2726,6 +2733,9 @@ function codexSurfaceHasField(surfaceId, field) {
 function hasCodexConfig(context) {
   return "config" in context;
 }
+function hasCodexPackageRoot(context) {
+  return "packageRoot" in context && typeof context.packageRoot === "string" && context.packageRoot.length > 0;
+}
 function renderAgentArtifacts({ config }) {
   const artifacts = [];
   const diagnostics = [];
@@ -2845,12 +2855,13 @@ var codexAdapter = {
     const skillOutputModes = resolveSkillOutputModes(context);
     const skillLayout = renderCodexSkillLayout({
       projectRoot: context.projectRoot,
+      ...hasCodexPackageRoot(context) ? { packageRoot: context.packageRoot } : {},
       skills: getSkillRegistry(),
       surfaceId: "plugin-skills-directory",
       outputModes: skillOutputModes
     });
     const pluginPackage = renderCodexPluginPackage({
-      manifest: createCodexPluginPackageManifest(context.projectRoot),
+      manifest: createCodexPluginPackageManifest(context),
       assets: [
         {
           surfaceId: "plugin-skills-directory",
@@ -2901,14 +2912,15 @@ import { cwd } from "process";
 
 // src/cli/codex-install.ts
 import {
-  copyFileSync as copyFileSync3,
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync6,
-  rmSync,
-  writeFileSync as writeFileSync3
+  copyFileSync as copyFileSync4,
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync7,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync4
 } from "fs";
-import { basename, dirname as dirname4, isAbsolute, join as join6, relative as relative2 } from "path";
+import { basename, dirname as dirname5, isAbsolute, join as join8, relative as relative3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/harness/codex-plugin-paths.ts
 import { join as join4 } from "path";
@@ -3109,116 +3121,496 @@ function resolveCodexTargets(options) {
   };
 }
 
-// src/cli/codex-install.ts
-var ROOT_START = "<!-- thoth-agents:codex-root:start -->";
-var ROOT_END = "<!-- thoth-agents:codex-root:end -->";
-var MANAGED_MODEL_STATE_VERSION = 1;
-function mergeManagedBlock(existing, managedBlock) {
-  const start = existing.indexOf(ROOT_START);
-  const end = existing.indexOf(ROOT_END);
-  if (start !== -1 && end !== -1 && end > start) {
-    return `${existing.slice(0, start)}${managedBlock}${existing.slice(end + ROOT_END.length).replace(/^\s*\n/, "")}`;
+// src/cli/custom-skills.ts
+import {
+  copyFileSync as copyFileSync3,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync3,
+  rmSync,
+  statSync as statSync3
+} from "fs";
+import { dirname as dirname4, join as join7, parse } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/cli/skill-manifest.ts
+import { createHash as createHash3 } from "crypto";
+import {
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync6,
+  statSync as statSync2,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { join as join6, relative as relative2 } from "path";
+var SHARED_SKILL_DIRECTORY = "_shared";
+var SKILLS_SOURCE_ROOT = join6("src", "skills");
+var MANIFEST_FILE_NAME = ".skill-manifest.json";
+function getManifestPath() {
+  return join6(getCustomSkillsDir(), MANIFEST_FILE_NAME);
+}
+function listFilesRecursive(dirPath) {
+  if (!existsSync7(dirPath)) {
+    return [];
   }
-  return `${existing}${existing.endsWith("\n") || existing.length === 0 ? "" : "\n"}
-${managedBlock}`;
+  const files = [];
+  const entries = readdirSync2(dirPath).sort(
+    (left, right) => left.localeCompare(right)
+  );
+  for (const entry of entries) {
+    const entryPath = join6(dirPath, entry);
+    const stat = statSync2(entryPath);
+    if (stat.isDirectory()) {
+      files.push(...listFilesRecursive(entryPath));
+      continue;
+    }
+    files.push(entryPath);
+  }
+  return files;
 }
-function writeTextWithBackup(path3, content) {
-  mkdirSync3(dirname4(path3), { recursive: true });
-  if (existsSync7(path3) && readFileSync6(path3, "utf8") === content) return false;
-  if (existsSync7(path3)) copyFileSync3(path3, `${path3}.bak`);
-  writeFileSync3(path3, content);
-  return true;
+function readPackageVersion(packageRoot) {
+  const packageJsonPath = join6(packageRoot, "package.json");
+  const packageJson = JSON.parse(readFileSync6(packageJsonPath, "utf-8"));
+  if (typeof packageJson.version !== "string" || packageJson.version.length === 0) {
+    throw new Error(`Invalid package version in ${packageJsonPath}`);
+  }
+  return packageJson.version;
 }
-function packageArtifactTarget(packageRoot, artifact) {
-  return join6(packageRoot, codexPluginRootArtifactPath(artifact.path));
+function readManifest() {
+  const manifestPath = getManifestPath();
+  if (!existsSync7(manifestPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync6(manifestPath, "utf-8"));
+  } catch (error) {
+    console.warn(`Failed to read skill manifest: ${manifestPath}`, error);
+    return null;
+  }
 }
-function normalizeRelativeMarketplacePath(path3) {
-  const normalized = path3.replaceAll("\\", "/");
-  if (isAbsolute(path3) || /^[A-Za-z]:\//.test(normalized)) return normalized;
-  if (normalized.startsWith("./")) return normalized;
-  return `./${normalized}`;
+function writeManifest(manifest) {
+  const manifestPath = getManifestPath();
+  mkdirSync3(getCustomSkillsDir(), { recursive: true });
+  writeFileSync3(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
 }
-function marketplaceSourcePath(homeDir, personalPluginRoot) {
-  return normalizeRelativeMarketplacePath(
-    relative2(homeDir, personalPluginRoot)
+function computeSkillHash(skillDirPath) {
+  const hash = createHash3("sha256");
+  for (const filePath of listFilesRecursive(skillDirPath)) {
+    hash.update(`${relative2(skillDirPath, filePath)}
+`);
+    hash.update(readFileSync6(filePath));
+    hash.update("\n");
+  }
+  return hash.digest("hex");
+}
+function findRemovedSkills(manifest) {
+  const currentSkillNames = new Set(CUSTOM_SKILLS.map((skill) => skill.name));
+  return Object.keys(manifest.skills).filter(
+    (skillName) => !currentSkillNames.has(skillName)
   );
 }
-function managedMarketplaceEntry(homeDir, personalPluginRoot) {
+function checkSkillsNeedUpdate(packageRoot) {
+  const manifest = readManifest();
+  const pluginVersion = readPackageVersion(packageRoot);
+  const sharedHash = computeSkillHash(
+    join6(packageRoot, SKILLS_SOURCE_ROOT, SHARED_SKILL_DIRECTORY)
+  );
+  const versionChanged = manifest !== null && manifest.pluginVersion !== pluginVersion;
+  const sharedChanged = manifest !== null && manifest.sharedHash !== sharedHash;
+  const removedSkills = manifest ? findRemovedSkills(manifest) : [];
+  const skillsNeedingUpdate = CUSTOM_SKILLS.flatMap((skill) => {
+    const sourcePath = join6(packageRoot, skill.sourcePath);
+    const targetPath = join6(getCustomSkillsDir(), skill.name);
+    const sourceHash = computeSkillHash(sourcePath);
+    const manifestEntry = manifest?.skills[skill.name];
+    const reasons = [];
+    if (!manifest) {
+      reasons.push("manifest-missing");
+    }
+    if (versionChanged) {
+      reasons.push("version-change");
+    }
+    if (sharedChanged) {
+      reasons.push("shared-hash-mismatch");
+    }
+    if (!manifestEntry) {
+      reasons.push("new-skill");
+    } else if (manifestEntry.hash !== sourceHash) {
+      reasons.push("hash-mismatch");
+    }
+    if (!existsSync7(targetPath)) {
+      reasons.push("missing-install");
+    }
+    if (reasons.length === 0) {
+      return [];
+    }
+    return [
+      {
+        skill,
+        sourceHash,
+        targetPath,
+        reasons
+      }
+    ];
+  });
   return {
-    name: "thoth-agents",
-    source: {
-      source: "local",
-      path: marketplaceSourcePath(homeDir, personalPluginRoot)
-    },
-    policy: {
-      installation: "AVAILABLE",
-      authentication: "ON_INSTALL"
-    },
-    category: "Productivity"
+    pluginVersion,
+    sharedHash,
+    manifest,
+    versionChanged,
+    sharedChanged,
+    needsUpdate: skillsNeedingUpdate.length > 0 || removedSkills.length > 0,
+    skillsNeedingUpdate,
+    removedSkills
   };
 }
-function stableJson3(value) {
-  return `${JSON.stringify(value, null, 2)}
-`;
-}
-function emptyManagedModelState() {
-  return {
-    version: MANAGED_MODEL_STATE_VERSION,
-    models: {}
-  };
+
+// src/cli/custom-skills.ts
+var SHARED_SKILL_DIRECTORY2 = "_shared";
+var SHARED_SKILL_SOURCE_PATH = `src/skills/${SHARED_SKILL_DIRECTORY2}`;
+var CUSTOM_SKILLS = BUNDLED_SKILL_REGISTRY.map(
+  (skill) => ({
+    name: skill.name,
+    description: skill.description,
+    allowedAgents: [...skill.allowedRoles],
+    sourcePath: skill.sourcePath
+  })
+);
+function getCustomSkillsDir() {
+  return join7(getConfigDir(), "skills");
 }
-function readManagedModelState(path3) {
-  if (!existsSync7(path3)) return emptyManagedModelState();
-  try {
-    const parsed = JSON.parse(readFileSync6(path3, "utf8"));
-    if (parsed.version !== MANAGED_MODEL_STATE_VERSION || !parsed.models || typeof parsed.models !== "object" || Array.isArray(parsed.models)) {
-      return emptyManagedModelState();
+function copyDirRecursive(src, dest) {
+  if (!existsSync8(dest)) {
+    mkdirSync4(dest, { recursive: true });
+  }
+  const entries = readdirSync3(src);
+  for (const entry of entries) {
+    const srcPath = join7(src, entry);
+    const destPath = join7(dest, entry);
+    const stat = statSync3(srcPath);
+    if (stat.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      const destDir = dirname4(destPath);
+      if (!existsSync8(destDir)) {
+        mkdirSync4(destDir, { recursive: true });
+      }
+      copyFileSync3(srcPath, destPath);
     }
-    return {
-      version: MANAGED_MODEL_STATE_VERSION,
-      models: Object.fromEntries(
-        Object.entries(parsed.models).filter(
-          (entry) => typeof entry[0] === "string" && typeof entry[1] === "string"
-        )
-      )
-    };
-  } catch {
-    return emptyManagedModelState();
   }
 }
-function parseRoleTomlModel(content) {
-  const match = /^model\s*=\s*"((?:\\.|[^"\\])*)"\s*$/m.exec(content);
-  if (!match) return void 0;
-  return match[1].replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
-}
-function escapeTomlString2(value) {
-  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\f/g, "\\f").replace(/\r/g, "\\r");
+function installSharedSkillAssets(packageRoot) {
+  const sharedSourcePath = join7(packageRoot, SHARED_SKILL_SOURCE_PATH);
+  const sharedTargetPath = join7(getCustomSkillsDir(), SHARED_SKILL_DIRECTORY2);
+  if (!existsSync8(sharedSourcePath)) {
+    console.error(`Custom skill shared assets not found: ${sharedSourcePath}`);
+    return false;
+  }
+  rmSync(sharedTargetPath, { recursive: true, force: true });
+  copyDirRecursive(sharedSourcePath, sharedTargetPath);
+  return true;
 }
-function replaceRoleTomlModel(content, model) {
-  const rendered = `model = "${escapeTomlString2(model)}"`;
-  if (/^model\s*=\s*"(?:\\.|[^"\\])*"\s*$/m.test(content)) {
-    return content.replace(/^model\s*=\s*"(?:\\.|[^"\\])*"\s*$/m, rendered);
+function findPackageRoot(startDir) {
+  let currentDir = startDir;
+  const filesystemRoot = parse(startDir).root;
+  while (true) {
+    if (existsSync8(join7(currentDir, "package.json")) && existsSync8(join7(currentDir, "src", "skills"))) {
+      return currentDir;
+    }
+    if (currentDir === filesystemRoot) {
+      return null;
+    }
+    const parentDir = dirname4(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
   }
-  return `${rendered}
-${content}`;
 }
-function roleManagedModelStateKey(path3) {
-  return basename(path3);
+function resolvePackageRoot(packageRoot) {
+  if (packageRoot) {
+    return packageRoot;
+  }
+  const moduleDir = fileURLToPath2(new URL(".", import.meta.url));
+  return findPackageRoot(moduleDir) ?? fileURLToPath2(new URL("../..", import.meta.url));
 }
-function resolveRoleTomlContent(options) {
-  const renderedModel = parseRoleTomlModel(options.renderedContent);
-  const key = roleManagedModelStateKey(options.targetPath);
-  if (!renderedModel) return options.renderedContent;
-  if (options.reset || !existsSync7(options.targetPath)) {
-    options.nextState.models[key] = renderedModel;
-    return options.renderedContent;
+function installCustomSkillFiles(skill, packageRoot) {
+  const sourcePath = join7(packageRoot, skill.sourcePath);
+  const targetPath = join7(getCustomSkillsDir(), skill.name);
+  if (!existsSync8(sourcePath)) {
+    console.error(`Custom skill source not found: ${sourcePath}`);
+    return false;
   }
-  const currentModel = parseRoleTomlModel(
-    readFileSync6(options.targetPath, "utf8")
-  );
-  const trackedModel = options.state.models[key];
-  const isUserOwned = currentModel !== void 0 && (trackedModel === void 0 ? currentModel !== renderedModel : currentModel !== trackedModel);
-  if (isUserOwned) {
+  rmSync(targetPath, { recursive: true, force: true });
+  copyDirRecursive(sourcePath, targetPath);
+  return true;
+}
+function removeObsoleteSkills(removedSkillNames) {
+  const removedSkills = [];
+  for (const skillName of removedSkillNames) {
+    const targetPath = join7(getCustomSkillsDir(), skillName);
+    try {
+      console.log(`Removing obsolete bundled skill: ${skillName}`);
+      rmSync(targetPath, { recursive: true, force: true });
+      removedSkills.push(skillName);
+    } catch (error) {
+      console.warn(`Failed to remove obsolete bundled skill: ${skillName}`);
+      console.warn(error);
+    }
+  }
+  return removedSkills;
+}
+function buildManifest(packageRoot, updatedSkills, previousManifest, pluginVersion, sharedHash) {
+  const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedSkillNames = new Set(
+    updatedSkills.map(({ skill }) => skill.name)
+  );
+  const skills = Object.fromEntries(
+    CUSTOM_SKILLS.map((skill) => {
+      const previousEntry = previousManifest?.skills[skill.name];
+      const nextInstalledAt = updatedSkillNames.has(skill.name) ? installedAt : previousEntry?.installedAt ?? installedAt;
+      return [
+        skill.name,
+        {
+          hash: computeSkillHash(join7(packageRoot, skill.sourcePath)),
+          installedAt: nextInstalledAt
+        }
+      ];
+    })
+  );
+  return {
+    pluginVersion,
+    sharedHash,
+    skills
+  };
+}
+function pruneRemovedSkillsFromManifest(manifest, removedSkills) {
+  const removedSkillNames = new Set(removedSkills);
+  return {
+    ...manifest,
+    skills: Object.fromEntries(
+      Object.entries(manifest.skills).filter(
+        ([skillName]) => !removedSkillNames.has(skillName)
+      )
+    )
+  };
+}
+function installCustomSkills(packageRoot = resolvePackageRoot()) {
+  const updateCheck = checkSkillsNeedUpdate(packageRoot);
+  if (!updateCheck.needsUpdate) {
+    return {
+      success: true,
+      updatedSkills: [],
+      skippedSkills: [...CUSTOM_SKILLS],
+      failedSkills: [],
+      removedSkills: []
+    };
+  }
+  const removedSkills = removeObsoleteSkills(updateCheck.removedSkills);
+  if (removedSkills.length > 0 && updateCheck.manifest) {
+    writeManifest(
+      pruneRemovedSkillsFromManifest(updateCheck.manifest, removedSkills)
+    );
+  }
+  if (updateCheck.skillsNeedingUpdate.length === 0) {
+    writeManifest(
+      buildManifest(
+        packageRoot,
+        [],
+        updateCheck.manifest,
+        updateCheck.pluginVersion,
+        updateCheck.sharedHash
+      )
+    );
+    return {
+      success: true,
+      updatedSkills: [],
+      skippedSkills: [...CUSTOM_SKILLS],
+      failedSkills: [],
+      removedSkills
+    };
+  }
+  if (!installSharedSkillAssets(packageRoot)) {
+    return {
+      success: false,
+      updatedSkills: [],
+      skippedSkills: [],
+      failedSkills: updateCheck.skillsNeedingUpdate.map(
+        ({ skill, reasons }) => ({
+          skill,
+          reasons
+        })
+      ),
+      removedSkills
+    };
+  }
+  const updatesBySkillName = new Map(
+    updateCheck.skillsNeedingUpdate.map((entry) => [entry.skill.name, entry])
+  );
+  const updatedSkills = [];
+  const skippedSkills = [];
+  const failedSkills = [];
+  for (const skill of CUSTOM_SKILLS) {
+    const pendingUpdate = updatesBySkillName.get(skill.name);
+    if (!pendingUpdate) {
+      skippedSkills.push(skill);
+      continue;
+    }
+    if (installCustomSkillFiles(skill, packageRoot)) {
+      updatedSkills.push({
+        skill,
+        reasons: pendingUpdate.reasons
+      });
+      continue;
+    }
+    failedSkills.push({
+      skill,
+      reasons: pendingUpdate.reasons
+    });
+  }
+  if (failedSkills.length > 0) {
+    return {
+      success: false,
+      updatedSkills,
+      skippedSkills,
+      failedSkills,
+      removedSkills
+    };
+  }
+  writeManifest(
+    buildManifest(
+      packageRoot,
+      updatedSkills,
+      updateCheck.manifest,
+      updateCheck.pluginVersion,
+      updateCheck.sharedHash
+    )
+  );
+  return {
+    success: true,
+    updatedSkills,
+    skippedSkills,
+    failedSkills,
+    removedSkills
+  };
+}
+
+// src/cli/codex-install.ts
+var ROOT_START = "<!-- thoth-agents:codex-root:start -->";
+var ROOT_END = "<!-- thoth-agents:codex-root:end -->";
+var MANAGED_MODEL_STATE_VERSION = 1;
+function mergeManagedBlock(existing, managedBlock) {
+  const start = existing.indexOf(ROOT_START);
+  const end = existing.indexOf(ROOT_END);
+  if (start !== -1 && end !== -1 && end > start) {
+    return `${existing.slice(0, start)}${managedBlock}${existing.slice(end + ROOT_END.length).replace(/^\s*\n/, "")}`;
+  }
+  return `${existing}${existing.endsWith("\n") || existing.length === 0 ? "" : "\n"}
+${managedBlock}`;
+}
+function writeTextWithBackup(path3, content) {
+  mkdirSync5(dirname5(path3), { recursive: true });
+  if (existsSync9(path3) && readFileSync7(path3, "utf8") === content) return false;
+  if (existsSync9(path3)) copyFileSync4(path3, `${path3}.bak`);
+  writeFileSync4(path3, content);
+  return true;
+}
+function packageArtifactTarget(packageRoot, artifact) {
+  return join8(packageRoot, codexPluginRootArtifactPath(artifact.path));
+}
+function resolvePackageRoot2(packageRoot) {
+  if (packageRoot) return packageRoot;
+  return findPackageRoot(fileURLToPath3(new URL(".", import.meta.url))) ?? void 0;
+}
+function normalizeRelativeMarketplacePath(path3) {
+  const normalized = path3.replaceAll("\\", "/");
+  if (isAbsolute(path3) || /^[A-Za-z]:\//.test(normalized)) return normalized;
+  if (normalized.startsWith("./")) return normalized;
+  return `./${normalized}`;
+}
+function marketplaceSourcePath(homeDir, personalPluginRoot) {
+  return normalizeRelativeMarketplacePath(
+    relative3(homeDir, personalPluginRoot)
+  );
+}
+function managedMarketplaceEntry(homeDir, personalPluginRoot) {
+  return {
+    name: "thoth-agents",
+    source: {
+      source: "local",
+      path: marketplaceSourcePath(homeDir, personalPluginRoot)
+    },
+    policy: {
+      installation: "AVAILABLE",
+      authentication: "ON_INSTALL"
+    },
+    category: "Productivity"
+  };
+}
+function stableJson3(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function emptyManagedModelState() {
+  return {
+    version: MANAGED_MODEL_STATE_VERSION,
+    models: {}
+  };
+}
+function readManagedModelState(path3) {
+  if (!existsSync9(path3)) return emptyManagedModelState();
+  try {
+    const parsed = JSON.parse(readFileSync7(path3, "utf8"));
+    if (parsed.version !== MANAGED_MODEL_STATE_VERSION || !parsed.models || typeof parsed.models !== "object" || Array.isArray(parsed.models)) {
+      return emptyManagedModelState();
+    }
+    return {
+      version: MANAGED_MODEL_STATE_VERSION,
+      models: Object.fromEntries(
+        Object.entries(parsed.models).filter(
+          (entry) => typeof entry[0] === "string" && typeof entry[1] === "string"
+        )
+      )
+    };
+  } catch {
+    return emptyManagedModelState();
+  }
+}
+function parseRoleTomlModel(content) {
+  const match = /^model\s*=\s*"((?:\\.|[^"\\])*)"\s*$/m.exec(content);
+  if (!match) return void 0;
+  return match[1].replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+}
+function escapeTomlString2(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\f/g, "\\f").replace(/\r/g, "\\r");
+}
+function replaceRoleTomlModel(content, model) {
+  const rendered = `model = "${escapeTomlString2(model)}"`;
+  if (/^model\s*=\s*"(?:\\.|[^"\\])*"\s*$/m.test(content)) {
+    return content.replace(/^model\s*=\s*"(?:\\.|[^"\\])*"\s*$/m, rendered);
+  }
+  return `${rendered}
+${content}`;
+}
+function roleManagedModelStateKey(path3) {
+  return basename(path3);
+}
+function resolveRoleTomlContent(options) {
+  const renderedModel = parseRoleTomlModel(options.renderedContent);
+  const key = roleManagedModelStateKey(options.targetPath);
+  if (!renderedModel) return options.renderedContent;
+  if (options.reset || !existsSync9(options.targetPath)) {
+    options.nextState.models[key] = renderedModel;
+    return options.renderedContent;
+  }
+  const currentModel = parseRoleTomlModel(
+    readFileSync7(options.targetPath, "utf8")
+  );
+  const trackedModel = options.state.models[key];
+  const isUserOwned = currentModel !== void 0 && (trackedModel === void 0 ? currentModel !== renderedModel : currentModel !== trackedModel);
+  if (isUserOwned) {
     if (trackedModel !== void 0)
       options.nextState.models[key] = trackedModel;
     return replaceRoleTomlModel(options.renderedContent, currentModel);
@@ -3254,7 +3646,11 @@ function buildCodexSetupPlan(config) {
     homeDir: config.homeDir,
     codexHome: config.codexHome
   });
-  const render = codexAdapter.render({ projectRoot: config.projectRoot });
+  const packageRoot = resolvePackageRoot2(config.packageRoot);
+  const render = codexAdapter.render({
+    projectRoot: config.projectRoot,
+    ...packageRoot ? { packageRoot } : {}
+  });
   const packageArtifacts = render.artifacts.filter(
     (artifact) => artifact.path.startsWith(".codex-plugin/")
   );
@@ -3276,7 +3672,7 @@ function buildCodexSetupPlan(config) {
         action: "write-role-toml",
         targetPath: target.path,
         description: `Materialize Codex role subagent ${target.role}.`,
-        requiresBackup: existsSync7(target.path),
+        requiresBackup: existsSync9(target.path),
         role: target.role,
         content: resolveRoleTomlContent({
           renderedContent: roleArtifactContent(target.role, render.artifacts),
@@ -3292,7 +3688,7 @@ function buildCodexSetupPlan(config) {
       action: "write-managed-model-state",
       targetPath: targets.managedModelsPath,
       description: "Record thoth-agents-managed Codex role model ownership state.",
-      requiresBackup: existsSync7(targets.managedModelsPath),
+      requiresBackup: existsSync9(targets.managedModelsPath),
       content: stableJson3(nextManagedModelState)
     },
     ...packageArtifacts.map(
@@ -3310,7 +3706,7 @@ function buildCodexSetupPlan(config) {
       action: "merge-marketplace",
       targetPath: targets.personalMarketplacePath,
       description: "Register Personal Codex marketplace entry for the local thoth-agents plugin source.",
-      requiresBackup: existsSync7(targets.personalMarketplacePath),
+      requiresBackup: existsSync9(targets.personalMarketplacePath),
       content: targets.personalPluginRoot
     },
     {
@@ -3374,10 +3770,10 @@ function formatRefreshPackageGroup(kind, groups) {
 }
 function commonTargetDirectory(items) {
   if (items.length === 0) return "";
-  let common = dirname4(items[0]?.targetPath ?? "");
+  let common = dirname5(items[0]?.targetPath ?? "");
   for (const item of items.slice(1)) {
     while (!isSameOrChildPath(item.targetPath, common)) {
-      const parent = dirname4(common);
+      const parent = dirname5(common);
       if (parent === common) return common;
       common = parent;
     }
@@ -3399,7 +3795,7 @@ function applyCodexSetup(plan) {
   if (plan.dryRun) return { success: true, changed, diagnostics };
   try {
     for (const targetPath of managedRefreshRoots(plan)) {
-      rmSync(targetPath, { recursive: true, force: true });
+      rmSync2(targetPath, { recursive: true, force: true });
     }
     for (const item of plan.items) {
       if (item.action === "diagnose-only") continue;
@@ -3417,8 +3813,8 @@ function applyCodexSetup(plan) {
       if (item.action === "merge-marketplace") {
         if (item.content === void 0) continue;
         const content2 = mergePersonalMarketplace(
-          existsSync7(item.targetPath) ? readFileSync6(item.targetPath, "utf8") : "",
-          dirname4(dirname4(dirname4(item.targetPath))),
+          existsSync9(item.targetPath) ? readFileSync7(item.targetPath, "utf8") : "",
+          dirname5(dirname5(dirname5(item.targetPath))),
           item.content
         );
         if (writeTextWithBackup(item.targetPath, content2))
@@ -3427,7 +3823,7 @@ function applyCodexSetup(plan) {
       }
       if (item.content === void 0) continue;
       const content = item.action === "merge-managed-block" ? mergeManagedBlock(
-        existsSync7(item.targetPath) ? readFileSync6(item.targetPath, "utf8") : "",
+        existsSync9(item.targetPath) ? readFileSync7(item.targetPath, "utf8") : "",
         item.content
       ) : item.content;
       if (writeTextWithBackup(item.targetPath, content))
@@ -3455,7 +3851,7 @@ function managedRefreshRoots(plan) {
 }
 
 // src/cli/system.ts
-import { statSync as statSync2 } from "fs";
+import { statSync as statSync4 } from "fs";
 
 // src/utils/subprocess.ts
 import {
@@ -3570,7 +3966,7 @@ function resolveOpenCodePath() {
   for (const opencodePath of paths) {
     if (opencodePath === "opencode") continue;
     try {
-      const stat = statSync2(opencodePath);
+      const stat = statSync4(opencodePath);
       if (stat.isFile()) {
         cachedOpenCodePath = opencodePath;
         return opencodePath;
@@ -3619,382 +4015,6 @@ function getOpenCodePath() {
   return path3 === "opencode" ? null : path3;
 }
 
-// src/cli/custom-skills.ts
-import {
-  copyFileSync as copyFileSync4,
-  existsSync as existsSync9,
-  mkdirSync as mkdirSync5,
-  readdirSync as readdirSync3,
-  rmSync as rmSync2,
-  statSync as statSync4
-} from "fs";
-import { dirname as dirname5, join as join8, parse } from "path";
-import { fileURLToPath } from "url";
-
-// src/cli/skill-manifest.ts
-import { createHash as createHash3 } from "crypto";
-import {
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync4,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync7,
-  statSync as statSync3,
-  writeFileSync as writeFileSync4
-} from "fs";
-import { join as join7, relative as relative3 } from "path";
-var SHARED_SKILL_DIRECTORY = "_shared";
-var SKILLS_SOURCE_ROOT = join7("src", "skills");
-var MANIFEST_FILE_NAME = ".skill-manifest.json";
-function getManifestPath() {
-  return join7(getCustomSkillsDir(), MANIFEST_FILE_NAME);
-}
-function listFilesRecursive(dirPath) {
-  if (!existsSync8(dirPath)) {
-    return [];
-  }
-  const files = [];
-  const entries = readdirSync2(dirPath).sort(
-    (left, right) => left.localeCompare(right)
-  );
-  for (const entry of entries) {
-    const entryPath = join7(dirPath, entry);
-    const stat = statSync3(entryPath);
-    if (stat.isDirectory()) {
-      files.push(...listFilesRecursive(entryPath));
-      continue;
-    }
-    files.push(entryPath);
-  }
-  return files;
-}
-function readPackageVersion(packageRoot) {
-  const packageJsonPath = join7(packageRoot, "package.json");
-  const packageJson = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
-  if (typeof packageJson.version !== "string" || packageJson.version.length === 0) {
-    throw new Error(`Invalid package version in ${packageJsonPath}`);
-  }
-  return packageJson.version;
-}
-function readManifest() {
-  const manifestPath = getManifestPath();
-  if (!existsSync8(manifestPath)) {
-    return null;
-  }
-  try {
-    return JSON.parse(readFileSync7(manifestPath, "utf-8"));
-  } catch (error) {
-    console.warn(`Failed to read skill manifest: ${manifestPath}`, error);
-    return null;
-  }
-}
-function writeManifest(manifest) {
-  const manifestPath = getManifestPath();
-  mkdirSync4(getCustomSkillsDir(), { recursive: true });
-  writeFileSync4(manifestPath, `${JSON.stringify(manifest, null, 2)}
-`);
-}
-function computeSkillHash(skillDirPath) {
-  const hash = createHash3("sha256");
-  for (const filePath of listFilesRecursive(skillDirPath)) {
-    hash.update(`${relative3(skillDirPath, filePath)}
-`);
-    hash.update(readFileSync7(filePath));
-    hash.update("\n");
-  }
-  return hash.digest("hex");
-}
-function findRemovedSkills(manifest) {
-  const currentSkillNames = new Set(CUSTOM_SKILLS.map((skill) => skill.name));
-  return Object.keys(manifest.skills).filter(
-    (skillName) => !currentSkillNames.has(skillName)
-  );
-}
-function checkSkillsNeedUpdate(packageRoot) {
-  const manifest = readManifest();
-  const pluginVersion = readPackageVersion(packageRoot);
-  const sharedHash = computeSkillHash(
-    join7(packageRoot, SKILLS_SOURCE_ROOT, SHARED_SKILL_DIRECTORY)
-  );
-  const versionChanged = manifest !== null && manifest.pluginVersion !== pluginVersion;
-  const sharedChanged = manifest !== null && manifest.sharedHash !== sharedHash;
-  const removedSkills = manifest ? findRemovedSkills(manifest) : [];
-  const skillsNeedingUpdate = CUSTOM_SKILLS.flatMap((skill) => {
-    const sourcePath = join7(packageRoot, skill.sourcePath);
-    const targetPath = join7(getCustomSkillsDir(), skill.name);
-    const sourceHash = computeSkillHash(sourcePath);
-    const manifestEntry = manifest?.skills[skill.name];
-    const reasons = [];
-    if (!manifest) {
-      reasons.push("manifest-missing");
-    }
-    if (versionChanged) {
-      reasons.push("version-change");
-    }
-    if (sharedChanged) {
-      reasons.push("shared-hash-mismatch");
-    }
-    if (!manifestEntry) {
-      reasons.push("new-skill");
-    } else if (manifestEntry.hash !== sourceHash) {
-      reasons.push("hash-mismatch");
-    }
-    if (!existsSync8(targetPath)) {
-      reasons.push("missing-install");
-    }
-    if (reasons.length === 0) {
-      return [];
-    }
-    return [
-      {
-        skill,
-        sourceHash,
-        targetPath,
-        reasons
-      }
-    ];
-  });
-  return {
-    pluginVersion,
-    sharedHash,
-    manifest,
-    versionChanged,
-    sharedChanged,
-    needsUpdate: skillsNeedingUpdate.length > 0 || removedSkills.length > 0,
-    skillsNeedingUpdate,
-    removedSkills
-  };
-}
-
-// src/cli/custom-skills.ts
-var SHARED_SKILL_DIRECTORY2 = "_shared";
-var SHARED_SKILL_SOURCE_PATH = `src/skills/${SHARED_SKILL_DIRECTORY2}`;
-var CUSTOM_SKILLS = BUNDLED_SKILL_REGISTRY.map(
-  (skill) => ({
-    name: skill.name,
-    description: skill.description,
-    allowedAgents: [...skill.allowedRoles],
-    sourcePath: skill.sourcePath
-  })
-);
-function getCustomSkillsDir() {
-  return join8(getConfigDir(), "skills");
-}
-function copyDirRecursive(src, dest) {
-  if (!existsSync9(dest)) {
-    mkdirSync5(dest, { recursive: true });
-  }
-  const entries = readdirSync3(src);
-  for (const entry of entries) {
-    const srcPath = join8(src, entry);
-    const destPath = join8(dest, entry);
-    const stat = statSync4(srcPath);
-    if (stat.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      const destDir = dirname5(destPath);
-      if (!existsSync9(destDir)) {
-        mkdirSync5(destDir, { recursive: true });
-      }
-      copyFileSync4(srcPath, destPath);
-    }
-  }
-}
-function installSharedSkillAssets(packageRoot) {
-  const sharedSourcePath = join8(packageRoot, SHARED_SKILL_SOURCE_PATH);
-  const sharedTargetPath = join8(getCustomSkillsDir(), SHARED_SKILL_DIRECTORY2);
-  if (!existsSync9(sharedSourcePath)) {
-    console.error(`Custom skill shared assets not found: ${sharedSourcePath}`);
-    return false;
-  }
-  rmSync2(sharedTargetPath, { recursive: true, force: true });
-  copyDirRecursive(sharedSourcePath, sharedTargetPath);
-  return true;
-}
-function findPackageRoot(startDir) {
-  let currentDir = startDir;
-  const filesystemRoot = parse(startDir).root;
-  while (true) {
-    if (existsSync9(join8(currentDir, "package.json")) && existsSync9(join8(currentDir, "src", "skills"))) {
-      return currentDir;
-    }
-    if (currentDir === filesystemRoot) {
-      return null;
-    }
-    const parentDir = dirname5(currentDir);
-    if (parentDir === currentDir) {
-      return null;
-    }
-    currentDir = parentDir;
-  }
-}
-function resolvePackageRoot(packageRoot) {
-  if (packageRoot) {
-    return packageRoot;
-  }
-  const moduleDir = fileURLToPath(new URL(".", import.meta.url));
-  return findPackageRoot(moduleDir) ?? fileURLToPath(new URL("../..", import.meta.url));
-}
-function installCustomSkillFiles(skill, packageRoot) {
-  const sourcePath = join8(packageRoot, skill.sourcePath);
-  const targetPath = join8(getCustomSkillsDir(), skill.name);
-  if (!existsSync9(sourcePath)) {
-    console.error(`Custom skill source not found: ${sourcePath}`);
-    return false;
-  }
-  rmSync2(targetPath, { recursive: true, force: true });
-  copyDirRecursive(sourcePath, targetPath);
-  return true;
-}
-function removeObsoleteSkills(removedSkillNames) {
-  const removedSkills = [];
-  for (const skillName of removedSkillNames) {
-    const targetPath = join8(getCustomSkillsDir(), skillName);
-    try {
-      console.log(`Removing obsolete bundled skill: ${skillName}`);
-      rmSync2(targetPath, { recursive: true, force: true });
-      removedSkills.push(skillName);
-    } catch (error) {
-      console.warn(`Failed to remove obsolete bundled skill: ${skillName}`);
-      console.warn(error);
-    }
-  }
-  return removedSkills;
-}
-function buildManifest(packageRoot, updatedSkills, previousManifest, pluginVersion, sharedHash) {
-  const installedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const updatedSkillNames = new Set(
-    updatedSkills.map(({ skill }) => skill.name)
-  );
-  const skills = Object.fromEntries(
-    CUSTOM_SKILLS.map((skill) => {
-      const previousEntry = previousManifest?.skills[skill.name];
-      const nextInstalledAt = updatedSkillNames.has(skill.name) ? installedAt : previousEntry?.installedAt ?? installedAt;
-      return [
-        skill.name,
-        {
-          hash: computeSkillHash(join8(packageRoot, skill.sourcePath)),
-          installedAt: nextInstalledAt
-        }
-      ];
-    })
-  );
-  return {
-    pluginVersion,
-    sharedHash,
-    skills
-  };
-}
-function pruneRemovedSkillsFromManifest(manifest, removedSkills) {
-  const removedSkillNames = new Set(removedSkills);
-  return {
-    ...manifest,
-    skills: Object.fromEntries(
-      Object.entries(manifest.skills).filter(
-        ([skillName]) => !removedSkillNames.has(skillName)
-      )
-    )
-  };
-}
-function installCustomSkills(packageRoot = resolvePackageRoot()) {
-  const updateCheck = checkSkillsNeedUpdate(packageRoot);
-  if (!updateCheck.needsUpdate) {
-    return {
-      success: true,
-      updatedSkills: [],
-      skippedSkills: [...CUSTOM_SKILLS],
-      failedSkills: [],
-      removedSkills: []
-    };
-  }
-  const removedSkills = removeObsoleteSkills(updateCheck.removedSkills);
-  if (removedSkills.length > 0 && updateCheck.manifest) {
-    writeManifest(
-      pruneRemovedSkillsFromManifest(updateCheck.manifest, removedSkills)
-    );
-  }
-  if (updateCheck.skillsNeedingUpdate.length === 0) {
-    writeManifest(
-      buildManifest(
-        packageRoot,
-        [],
-        updateCheck.manifest,
-        updateCheck.pluginVersion,
-        updateCheck.sharedHash
-      )
-    );
-    return {
-      success: true,
-      updatedSkills: [],
-      skippedSkills: [...CUSTOM_SKILLS],
-      failedSkills: [],
-      removedSkills
-    };
-  }
-  if (!installSharedSkillAssets(packageRoot)) {
-    return {
-      success: false,
-      updatedSkills: [],
-      skippedSkills: [],
-      failedSkills: updateCheck.skillsNeedingUpdate.map(
-        ({ skill, reasons }) => ({
-          skill,
-          reasons
-        })
-      ),
-      removedSkills
-    };
-  }
-  const updatesBySkillName = new Map(
-    updateCheck.skillsNeedingUpdate.map((entry) => [entry.skill.name, entry])
-  );
-  const updatedSkills = [];
-  const skippedSkills = [];
-  const failedSkills = [];
-  for (const skill of CUSTOM_SKILLS) {
-    const pendingUpdate = updatesBySkillName.get(skill.name);
-    if (!pendingUpdate) {
-      skippedSkills.push(skill);
-      continue;
-    }
-    if (installCustomSkillFiles(skill, packageRoot)) {
-      updatedSkills.push({
-        skill,
-        reasons: pendingUpdate.reasons
-      });
-      continue;
-    }
-    failedSkills.push({
-      skill,
-      reasons: pendingUpdate.reasons
-    });
-  }
-  if (failedSkills.length > 0) {
-    return {
-      success: false,
-      updatedSkills,
-      skippedSkills,
-      failedSkills,
-      removedSkills
-    };
-  }
-  writeManifest(
-    buildManifest(
-      packageRoot,
-      updatedSkills,
-      updateCheck.manifest,
-      updateCheck.pluginVersion,
-      updateCheck.sharedHash
-    )
-  );
-  return {
-    success: true,
-    updatedSkills,
-    skippedSkills,
-    failedSkills,
-    removedSkills
-  };
-}
-
 // src/cli/skills.ts
 import { spawnSync } from "child_process";
 var RECOMMENDED_SKILLS = [

package/dist/harness/adapters/codex.d.ts

@@ -2,6 +2,7 @@ import { type PluginConfig } from '../../config';
 import type { HarnessAdapter, HarnessCapabilities, HarnessRenderContext } from '../types';
 export interface CodexRenderContext extends HarnessRenderContext {
     config?: PluginConfig;
+    packageRoot?: string;
 }
 export declare const CODEX_CAPABILITIES: HarnessCapabilities;
 export declare function renderCodexRootInstructions(config?: PluginConfig): string;

package/dist/harness/types.d.ts

@@ -51,6 +51,7 @@ export interface CapabilityGapDiagnostic extends HarnessDiagnostic {
 }
 export interface HarnessRenderContext {
     projectRoot: string;
+    packageRoot?: string;
     options?: HarnessRenderOptions;
 }
 export interface HarnessRenderResult {

package/dist/harness/writers/skill-layout.d.ts

@@ -2,6 +2,7 @@ import type { SkillRegistryEntry } from '../core/skills';
 import type { HarnessArtifact, HarnessDiagnostic } from '../types';
 export interface CodexSkillLayoutInput {
     projectRoot: string;
+    packageRoot?: string;
     skills: SkillRegistryEntry[];
     surfaceId: string;
     outputMode?: CodexSkillOutputMode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thoth-agents",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "description": "Delegate-first OpenCode plugin with seven agents, thoth-mem persistence, and bundled SDD skills.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,6 +9,7 @@
   },
   "type": "module",
   "license": "MIT",
+  "packageManager": "pnpm@11.2.2",
   "engines": {
     "node": ">=22.13"
   },
@@ -39,6 +40,22 @@
     "README.md",
     "LICENSE"
   ],
+  "scripts": {
+    "build": "tsup && tsc --emitDeclarationOnly && pnpm run generate-schema",
+    "generate-schema": "tsx scripts/generate-schema.ts",
+    "release:notes": "tsx scripts/generate-release-notes.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "biome lint .",
+    "format": "biome format . --write",
+    "check": "biome check --write .",
+    "check:ci": "biome check .",
+    "dev": "pnpm run build && opencode",
+    "prepublishOnly": "pnpm run build",
+    "release:patch": "npm version patch && git push --follow-tags",
+    "release:minor": "npm version minor && git push --follow-tags",
+    "release:major": "npm version major && git push --follow-tags"
+  },
   "dependencies": {
     "@ast-grep/cli": "^0.40.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
@@ -63,19 +80,5 @@
     "hono": "4.12.19",
     "postcss": "8.5.14",
     "tsx": "4.22.2"
-  },
-  "scripts": {
-    "build": "tsup && tsc --emitDeclarationOnly && pnpm run generate-schema",
-    "generate-schema": "tsx scripts/generate-schema.ts",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "lint": "biome lint .",
-    "format": "biome format . --write",
-    "check": "biome check --write .",
-    "check:ci": "biome check .",
-    "dev": "pnpm run build && opencode",
-    "release:patch": "npm version patch && git push --follow-tags && npm publish",
-    "release:minor": "npm version minor && git push --follow-tags && npm publish",
-    "release:major": "npm version major && git push --follow-tags && npm publish"
   }
-}
+}