thoth-agents 0.1.4 → 0.1.6

package/dist/cli/index.js

@@ -215,7 +215,7 @@ Push back when context, risk, or assumptions are weak. Avoid verbosity.
 - Load \`thoth-mem-agents\` and \`requirements-interview\`.
 - You MUST NOT read or write any file in the workspace except \`openspec/\` coordination artifacts for the SDD pipeline.
 - Delegate all inspection, writing, searching, debugging, and verification.
-- Own the thinking: analyze the request, choose the approach, synthesize facts, make decisions, ask \`{{userQuestionTool}}\`, manage progress, and own root-session memory.
+- Own the thinking: analyze, choose approach, handle task sequencing, synthesize facts, decide, ask \`{{userQuestionTool}}\` for blocking user input, manage progress, own root-session memory, and write the final report.
 - Use sub-agents for evidence and action, not to outsource architecture or planning.
 - Never request raw file dumps from sub-agents; ask for findings, paths, line anchors, diffs, verification, and blockers.
 - Use openspec/ for coordination artifacts, especially
@@ -223,6 +223,7 @@ Push back when context, risk, or assumptions are weak. Avoid verbosity.
 - Visual or UX work and screenshots always go to {{role.designer}}.
 - Verify through delegation, not inline.
 - Verification should follow the user's project instructions and use the smallest sufficient delegated checks: typecheck, lint, focused tests, or build when appropriate.
+- When a harness cannot enforce a rule directly, preserve the rule as instruction-only guidance and disclose the enforcement gap instead of weakening the contract.
 </core-rules>
 
 <session-bootstrap>
@@ -255,18 +256,11 @@ Tiebreakers:
 <internal-handoff>
 Before dispatching {{role.designer}}, {{role.quick}}, or {{role.deep}} after discovery, synthesize a compact internal handoff. This is an implementation detail between you and sub-agents, not a user-facing step or artifact.
 
-Internal handoff fields:
-- Goal: the specific outcome for this task.
-- Decision: the chosen approach and why it is the right next move.
-- Evidence: relevant files, symbols, line anchors, docs, constraints, and known invariants from {{role.explorer}}/{{role.librarian}}.
-- Scope: exact files/areas to change and non-goals to avoid.
-- Steps: ordered implementation instructions, including what to preserve.
-- Verification: smallest sufficient checks or visual QA required.
-- Uncertainty: remaining unknowns the implementer may resolve locally, plus what should be escalated instead of guessed.
+Internal handoff fields: Goal, Decision, Evidence, Scope, Steps, Verification, and Uncertainty. Include relevant files, symbols, anchors, constraints, non-goals, and what to escalate instead of guessing.
 
 Never mention the internal handoff to the user, ask the user to prepare it, or present handoff preparation as the recommended next step. To the user, describe the actual work: discovery, design, implementation, verification, or the concrete decision needed.
 
-For {{role.explorer}}/{{role.librarian}}, ask narrow fact-finding questions that will fill missing internal handoff fields: likely files, symbols, call sites, constraints, examples, versioned API facts, and verification targets. Require decision-ready findings, not raw context.
+For {{role.explorer}}/{{role.librarian}}, ask narrow fact-finding questions for likely files, symbols, call sites, constraints, examples, versioned API facts, and verification targets. Require decision-ready findings, not raw context.
 </internal-handoff>
 
 <dispatch>
@@ -342,10 +336,11 @@ function createReadOnlySpecialistPromptSections(role) {
       mode: "read-only",
       dispatch: "task",
       scope: "local repository discovery",
-      responsibility: "Find workspace facts fast. Return decision-ready evidence for internal handoffs: paths, lines, symbols, constraints, edit targets, and conclusions.",
+      responsibility: "Find workspace facts fast. Return decision-ready evidence for internal handoffs: paths, lines, symbols, candidate files, constraints, edit targets, verification targets, and conclusions.",
       rules: [
         "- Questions should be rare; exhaust local evidence first.",
         "- Prefer paths, lines, symbols, and concise summaries over dumps.",
+        "- Do not implement, edit files, mutate the repository, or own durable session memory.",
         "- When full content is explicitly requested, reproduce it faithfully."
       ],
       memoryAccess: "readonly",
@@ -361,11 +356,11 @@ FINDINGS: bullets with claim, evidence type [direct|inferred|assumed], confidenc
 
 ALTERNATIVES CONSIDERED: ranked candidates when more than one plausible match exists. Omit if only one candidate.
 
-UNRESOLVED QUESTIONS: what remains ambiguous. State what additional context would unblock the search.
+UNRESOLVED QUESTIONS: ambiguity and what context would unblock it.
 
 UNCHECKED AREAS: what you did not inspect that could change the answer. Omit if nothing notable.
 
-SHORT EVIDENCE: at most one short excerpt per key finding, max 2 lines each. Skip if citations are self-explanatory.
+SHORT EVIDENCE: at most one 2-line excerpt per key finding.
 
 Lead with STATUS. Stay under 40 lines total when possible. If the schema forces more lines, exceed the budget rather than drop required fields.`
     });
@@ -375,12 +370,13 @@ Lead with STATUS. Stay under 40 lines total when possible. If the schema forces
       role,
       mode: "read-only",
       dispatch: "task",
-      scope: "external research plus local confirmation when needed",
-      responsibility: "Gather authoritative external evidence that helps the orchestrator make implementation decisions. Prefer official docs first, then high-signal public examples. Every substantive claim must carry a source URL.",
+      scope: "external docs and research plus local confirmation when needed",
+      responsibility: "Gather authoritative external evidence that helps the orchestrator make implementation decisions. Prefer official docs first, include version sensitivity, then high-signal public examples. Every substantive claim must carry a source URL.",
       rules: [
         "- Questions should be rare; exhaust available sources first.",
         "- Prefer official documentation over commentary when both answer the same point.",
-        "- Distinguish clearly between official guidance and community examples."
+        "- Distinguish clearly between official guidance and community examples.",
+        "- Do not mutate the repository, invent undocumented APIs, or perform broad implementation work."
       ],
       memoryAccess: "readonly",
       output: `- Organize by finding. Include a source URL for every claim.
@@ -394,11 +390,12 @@ Lead with STATUS. Stay under 40 lines total when possible. If the schema forces
     mode: "read-only",
     dispatch: "synchronous task only",
     scope: "advice, diagnosis, architecture, code review, and plan review",
-    responsibility: "Provide strategic technical guidance anchored to evidence. Use systematic-debugging for bugs, plan-reviewer for SDD plans, and web-assisted research when deeper diagnosis needs it.",
+    responsibility: "Provide read-only review and strategic technical guidance anchored to evidence, including findings, risks, assumptions, and decision-ready conclusions. Use systematic-debugging for bugs, plan-reviewer for SDD plans, and web-assisted research when deeper diagnosis needs it.",
     rules: [
       "- Cite exact files and lines for local claims.",
       "- Separate observations, risks, and recommendations.",
-      "- Ask only when tradeoffs, risk tolerance, or approval materially change the recommendation."
+      "- Ask only when tradeoffs, risk tolerance, or approval materially change the recommendation.",
+      "- Do not produce SDD artifacts, implement edits, or mutate the workspace."
     ],
     memoryAccess: "readonly",
     output: `- Cite exact files and lines \u2014 do not quote large code blocks.
@@ -414,13 +411,14 @@ function createWriteCapableSpecialistPromptSections(role) {
       mode: "write-capable",
       dispatch: "synchronous task only",
       scope: "UI/UX decisions, implementation, and visual verification",
-      responsibility: "Own the user-facing solution end to end: choose the UX approach, implement it, and verify it visually. Use playwright-cli only in non-interactive, single-run mode (for example `playwright test`), never with persistent UI or watcher flags.\nWhen dispatched for QA-only tasks (no implementation), take screenshots, inspect the UI, and return a structured visual QA report: what looks correct, what has issues, and recommended fixes.",
+      responsibility: "Own the user-facing solution: choose the UX approach, implement it, and verify it visually across responsive states when screens change. Use the harness-available visual verification surface in a non-blocking, single-run mode and capture evidence that supports your findings.\nFor visual QA-only tasks, inspect the UI, summarize what looks correct, note issues, and recommend fixes.",
       rules: [
         "- Treat the orchestrator's internal handoff as the handoff; do not rediscover settled scope or constraints.",
         "- Own UX decisions instead of bouncing them back unless a real user preference is required.",
-        "- Verify visually when feasible; do not stop at code that merely compiles.",
+        "- Verify visually and check responsive behavior when feasible; do not stop at code that merely compiles.",
         "- Keep changes focused on the user-facing outcome.",
-        "- NEVER run blocking or long-running commands: no `playwright test --ui`, `playwright show-report`, `--headed --debug`, dev servers, or watchers. Use single-run variants and capture screenshots/traces as artifacts."
+        "- Preserve unrelated working-tree changes.",
+        "- Avoid interactive, blocking, or persistent visual verification modes unless explicitly requested; keep verification single-run and evidence-driven."
       ],
       memoryAccess: "writable",
       output: `For SDD tasks: use the Task Result envelope (Status, Task, What was done, Files changed, Verification, Issues).
@@ -435,10 +433,11 @@ For non-SDD work: state what was implemented, verification status, and remaining
       mode: "write-capable",
       dispatch: "synchronous task only",
       scope: "fast bounded implementation",
-      responsibility: "Implement well-defined changes quickly. Favor speed over exhaustive analysis when the task is narrow and the path is clear.",
+      responsibility: "Implement well-defined changes quickly. Favor speed over exhaustive analysis when the task is narrow, low-risk, mechanical, and the path is clear.",
       rules: [
         "- Optimize for fast execution on narrow, clear tasks.",
         "- Treat the orchestrator's internal handoff as the starting point; follow its file anchors, scope, non-goals, and verification target.",
+        "- Preserve unrelated working-tree changes.",
         "- Read only the context you need.",
         "- Do not redo broad discovery. If the handoff lacks essential anchors, surface the missing context instead of turning the task into open-ended exploration.",
         "- Avoid multi-step planning; if the task stops being bounded, surface it.",
@@ -461,6 +460,7 @@ For non-SDD work: status + summary + files changed + issues. Nothing more.
       "- Treat the orchestrator's internal handoff as the architecture handoff; validate it against nearby code, but do not restart upstream discovery unless evidence contradicts it.",
       "- Do not skip verification \u2014 thoroughness is your value proposition.",
       "- Investigate related files, types, and call sites before changing shared behavior, prioritizing the anchors and constraints in the handoff.",
+      "- Preserve unrelated working-tree changes.",
       "- Ask when a real architecture or implementation tradeoff blocks correct execution."
     ],
     memoryAccess: "writable",
@@ -1549,7 +1549,7 @@ var BUNDLED_SKILL_REGISTRY = [
   },
   {
     name: "sdd-design",
-    description: "Create technical design artifacts for changes",
+    description: "Create technical solution design artifacts for changes",
     allowedRoles: ORCHESTRATOR_ONLY,
     sourcePath: "src/skills/sdd-design",
     kind: "skill",
@@ -2462,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({
@@ -2478,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}`;
@@ -2670,7 +2671,7 @@ function codexRoleInstructions(role) {
     `- Responsibility: ${role.responsibility}`,
     "- Use request_user_input for local blocking decisions.",
     "- Permissions, memory governance, runtime hooks, and provider-per-agent controls are instruction-level unless the active Codex runtime documents stronger enforcement.",
-    `- ${role.name} runs as a Codex custom agent TOML; there is no selectable orchestrator TOML.`,
+    `- ${role.name} runs as a Codex custom-agent TOML entry; the orchestrator remains the ambient Codex root session, not a generated role TOML.`,
     ...role.toolGovernance.map((rule) => `- ${rule}`),
     ...role.verification.map((rule) => `- ${rule}`),
     "</role-operational-contract>"
@@ -2703,7 +2704,7 @@ function renderCodexRootInstructions(config) {
     "- After receiving a delegated subagent response, close that subagent session unless you will retry or intentionally keep using that exact same session; explorer and librarian sessions must always be closed immediately after their response, and retry sessions must be closed after the retry result unless explicit same-session reuse is still required.",
     "- Use packaged thoth-agents plugin capabilities through Codex plugin, skill, MCP, and hook review surfaces after enabling them with /plugins and /hooks.",
     "- For blocking user decisions in Codex Default mode, use request_user_input after features.default_mode_request_user_input is enabled; do not ask those questions in plain prose.",
-    "- Permissions, memory policy, provider-per-agent controls, and hooks are instruction-only unless the active Codex runtime documents stronger enforcement.",
+    "- Memory governance, role permissions, provider-per-agent controls, and hooks are instruction-level unless the active Codex runtime documents stronger enforcement.",
     "</codex-runtime>",
     CODEX_ROOT_END,
     ""
@@ -2854,6 +2855,7 @@ 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
@@ -2910,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";
@@ -3118,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);
@@ -3263,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/")
   );
@@ -3285,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),
@@ -3301,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(
@@ -3319,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
     },
     {
@@ -3383,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;
     }
@@ -3408,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;
@@ -3426,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))
@@ -3436,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))
@@ -3464,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 {
@@ -3579,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;
@@ -3628,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 as fileURLToPath2 } 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 = fileURLToPath2(new URL(".", import.meta.url));
-  return findPackageRoot(moduleDir) ?? fileURLToPath2(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 = [