cherry-works 0.7.4 → 0.8.0

package/dist/main.js

@@ -21898,7 +21898,7 @@ import { pathToFileURL as pathToFileURL2 } from "url";
 // package.json
 var package_default = {
   name: "cherry-works",
-  version: "0.7.4",
+  version: "0.8.0",
   description: "The charter engine: resolves a charter and compiles it into what a coding agent reads.",
   keywords: [
     "claude-code",
@@ -57394,6 +57394,15 @@ var ServedToolsSchema = dto(
   })
 );
 var ToolAnswerSchema = dto("ToolAnswer", external_exports.record(external_exports.string(), external_exports.unknown()));
+var VendorPrimitiveSchema = dto(
+  "VendorPrimitive",
+  external_exports.object({
+    kind: external_exports.string(),
+    id: external_exports.string(),
+    description: external_exports.string(),
+    leftOutHeaders: StringsSchema
+  })
+);
 var WorkspaceSettingsSchema = dto(
   "WorkspaceSettings",
   external_exports.object({
@@ -57474,6 +57483,7 @@ var DataDTOs = byType(
   TestSuiteSchema,
   TestSuitesSchema,
   ToolAnswerSchema,
+  VendorPrimitiveSchema,
   WorkspaceSettingsSchema
 );
 
@@ -57523,7 +57533,20 @@ var SensorRunOutcomeSchema = dto(
     problem: external_exports.string()
   })
 );
-var OutcomeDTOs = byType(DoctorOutcomeSchema, ExplanationOutcomeSchema, SensorRunOutcomeSchema, SessionReviewOutcomeSchema);
+var VendorAddOutcomeSchema = dto(
+  "VendorAddOutcome",
+  external_exports.object({
+    folder: external_exports.string(),
+    primitives: external_exports.array(DataDTOs.VendorPrimitive).readonly()
+  })
+);
+var OutcomeDTOs = byType(
+  DoctorOutcomeSchema,
+  ExplanationOutcomeSchema,
+  SensorRunOutcomeSchema,
+  SessionReviewOutcomeSchema,
+  VendorAddOutcomeSchema
+);
 
 // src/hexagon/domain/models/helper.ts
 function formatFrontmatterValue(value) {
@@ -58086,6 +58109,13 @@ function sessionReviewOutcomeDTO(sessionAnalysis, sessionAnalysisSummary, sessio
 function sensorRunOutcomeDTO(signalAnswer) {
   return { type: "SensorRunOutcome", data: { exitCode: signalAnswer.exitCode, answer: signalAnswer.stdout, problem: signalAnswer.stderr } };
 }
+function vendorPrimitiveDTO(vendorPrimitive) {
+  const { kind, id, description, leftOutHeaders } = vendorPrimitive;
+  return { type: "VendorPrimitive", data: { kind, id, description, leftOutHeaders } };
+}
+function vendorAddOutcomeDTO(vendorInstall) {
+  return { type: "VendorAddOutcome", data: { folder: vendorInstall.folder, primitives: vendorInstall.vendorPrimitives.map(vendorPrimitiveDTO) } };
+}
 
 // src/driver/portal/routes.ts
 var json3 = (schema, description) => ({
@@ -58388,8 +58418,8 @@ function api(charterAuthoringApp2, charterVendoringApp2, testAuthoringApp2) {
         )
       },
       responses: {
-        204: { description: "The source is installed, and committed" },
-        422: json3(DataDTOs.Fault, "No repository, work in hand, or what git refused")
+        204: { description: "The source is installed \u2014 a charter whole, or every skill of a skills repository \u2014 left unstaged" },
+        422: json3(DataDTOs.Fault, "No repository, a source holding neither a charter nor a skill, or what git refused")
       }
     }),
     async (c) => {
@@ -58702,23 +58732,31 @@ function lines2(one) {
 var OPTIONS16 = {
   source: {
     type: "string",
-    describe: "What git clones the charter from: an address over any transport, or a path on disk"
+    describe: "What git fetches the charter or the skills from: an address over any transport, or a path on disk"
   },
   ref: {
     type: "string",
     describe: "The tag, branch or commit to pin to; the source's own default where none is named"
+  },
+  skill: {
+    type: "string",
+    isArray: true,
+    describe: "A skill to take from a skills repository, by its name; typed once per skill, and every skill it holds where none is named. Refused for a charter"
   }
 };
 var VendorAddCommand = class {
   name = "vendor add <source>";
-  summary = "Install a charter from a git source, or bring an installed one up to date";
+  summary = "Install a charter or skills from a git source, or bring an installed one up to date";
   options = OPTIONS16;
-  async run({ charterVendoringApp: charterVendoringApp2 }, { source, ref }) {
-    const folder = await charterVendoringApp2.add(source ?? "", ref);
+  async run({ charterVendoringApp: charterVendoringApp2 }, { source, ref, skill }) {
+    const { folder, primitives } = (await charterVendoringApp2.add(source ?? "", ref, skill)).data;
     return {
       code: EXIT_OK,
       result: [
         `Installed ${source} under ${folder}${ref === void 0 ? "" : `, pinned to ${ref}`}.`,
+        ...primitives.map(
+          ({ data: { kind, id, leftOutHeaders } }) => `  ${kind} ${id}${leftOutHeaders.length === 0 ? "" : `, leaving out ${leftOutHeaders.join(", ")}: the charter has no field for them`}`
+        ),
         'Run "cw build" to compile what it adds to this charter.',
         ""
       ].join("\n")
@@ -59119,7 +59157,16 @@ var PlaybookHeadersSchema = CommonHeadersSchema.extend({
   triggers: GoodArraySchema,
   /** Whether it is kept out of the commands its host offers the user, being a
    *  step of something else; the agent still opens it (CORE-FR-173). */
-  "disable-user-invocation": FlagSchema.optional()
+  "disable-user-invocation": FlagSchema.optional(),
+  /** Whether the agent is kept from opening it by itself, its description
+   *  matching what is asked; the user still runs it as a command (CORE-FR-181). */
+  "disable-model-invocation": FlagSchema.optional()
+}).superRefine((headers, context) => {
+  if (headers["disable-user-invocation"] === true && headers["disable-model-invocation"] === true)
+    context.addIssue({
+      code: "custom",
+      message: `This playbook declares both "disable-user-invocation: true" and "disable-model-invocation: true", so neither the user nor the agent could open it; drop one.`
+    });
 });
 var PlaybookPrimitive = class _PlaybookPrimitive extends BasePrimitive {
   static kind = "playbook";
@@ -59191,7 +59238,16 @@ var SkillHeadersSchema = CommonHeadersSchema.extend({
   triggers: GoodArraySchema,
   /** Whether it is kept out of the commands its host offers the user, being a
    *  step of something else; the agent still opens it (CORE-FR-173). */
-  "disable-user-invocation": FlagSchema.optional()
+  "disable-user-invocation": FlagSchema.optional(),
+  /** Whether the agent is kept from opening it by itself, its description
+   *  matching what is asked; the user still runs it as a command (CORE-FR-181). */
+  "disable-model-invocation": FlagSchema.optional()
+}).superRefine((headers, context) => {
+  if (headers["disable-user-invocation"] === true && headers["disable-model-invocation"] === true)
+    context.addIssue({
+      code: "custom",
+      message: `This skill declares both "disable-user-invocation: true" and "disable-model-invocation: true", so neither the user nor the agent could open it; drop one.`
+    });
 });
 var SkillPrimitive = class _SkillPrimitive extends BasePrimitive {
   static kind = "skill";
@@ -59989,6 +60045,220 @@ agent stops as it would have.`,
 // src/hexagon/domain/models/charter/builtin/index.ts
 var BUILTIN_PRIMITIVES = [new CwAuthorSkill(), new CwSessionTokensCounterScript(), new CwSessionTokensSensor(), new CwSessionCostSkill()];
 
+// src/hexagon/domain/models/vendor/VendorPrimitive.ts
+var SKILL_FILE = "SKILL.md";
+var SKILLS_FOLDER = "skills";
+var SKILLS_FOLDER_DEPTH = 3;
+var DEPENDENCIES_FOLDER = "node_modules";
+var CONVERTED_HEADERS = ["name", "description", "disable-model-invocation", "user-invocable"];
+var VendorPrimitive = class {
+  constructor(kind, id, description, sourceFolder, convertedSkill, leftOutHeaders = []) {
+    this.kind = kind;
+    this.id = id;
+    this.description = description;
+    this.sourceFolder = sourceFolder;
+    this.convertedSkill = convertedSkill;
+    this.leftOutHeaders = leftOutHeaders;
+  }
+  kind;
+  id;
+  description;
+  sourceFolder;
+  convertedSkill;
+  leftOutHeaders;
+};
+function frontmatterOf(markdown, parser2) {
+  const lines3 = markdown.replace(/^/, "").split(/\r?\n/);
+  const frontmatterEnd = lines3[0]?.trim() === "---" ? lines3.findIndex((line, index) => index > 0 && line.trim() === "---") : -1;
+  if (frontmatterEnd === -1) return void 0;
+  return {
+    headers: parser2.parse(lines3.slice(1, frontmatterEnd).join("\n")),
+    body: lines3.slice(frontmatterEnd + 1).join("\n").replace(/^(\s*\n)+/, "").trimEnd()
+  };
+}
+function skillFilesOf(sourcePaths) {
+  const skillFolders = sourcePaths.filter((sourcePath) => sourcePath.startsWith(`${SKILLS_FOLDER}/`) && sourcePath.endsWith(`/${SKILL_FILE}`)).map((skillFile) => skillFile.slice(0, -`/${SKILL_FILE}`.length)).filter((skillFolder) => {
+    const folderNames = skillFolder.split("/");
+    return folderNames.length - 1 <= SKILLS_FOLDER_DEPTH && !folderNames.includes(DEPENDENCIES_FOLDER);
+  });
+  return skillFolders.filter((skillFolder) => !skillFolders.some((outerFolder) => skillFolder.startsWith(`${outerFolder}/`))).map((skillFolder) => `${skillFolder}/${SKILL_FILE}`);
+}
+function charterVendorPrimitiveOf(indexMd, indexPath, charterFolder, parser2) {
+  const sourceFolder = indexPath.slice(0, indexPath.lastIndexOf("/"));
+  const [kind = "", ...idFolders] = sourceFolder.slice(charterFolder.length + 1).split("/");
+  let description = "";
+  try {
+    const declaredDescription = frontmatterOf(indexMd, parser2)?.headers.description;
+    if (typeof declaredDescription === "string") description = declaredDescription;
+  } catch {
+  }
+  return new VendorPrimitive(kind, idFolders.join("/"), description, sourceFolder);
+}
+function skillVendorPrimitiveOf(skillMd, skillFile, parser2) {
+  const skillFrontmatter = frontmatterOf(skillMd, parser2);
+  if (skillFrontmatter === void 0)
+    throw new VendorFault(`${skillFile} opens with no "---" frontmatter block.`, `Take a skill whose ${SKILL_FILE} declares its name and description.`);
+  const { headers: skillHeaders, body } = skillFrontmatter;
+  try {
+    const skillPrimitive = SkillPrimitive.of(
+      {
+        id: skillHeaders.name,
+        description: skillHeaders.description,
+        triggers: [skillHeaders.name],
+        ...skillHeaders["disable-model-invocation"] === true ? { "disable-model-invocation": true } : {},
+        ...skillHeaders["user-invocable"] === false ? { "disable-user-invocation": true } : {}
+      },
+      body
+    );
+    return new VendorPrimitive(
+      SkillPrimitive.kind,
+      skillPrimitive.headers.id,
+      skillPrimitive.headers.description,
+      skillFile.slice(0, -SKILL_FILE.length).replace(/\/$/, ""),
+      skillPrimitive,
+      Object.keys(skillHeaders).filter((header) => !CONVERTED_HEADERS.includes(header))
+    );
+  } catch (raised) {
+    const faultMessages = raised instanceof AggregateError ? raised.errors.map((fault) => fault.message) : [`${raised}`];
+    throw new VendorFault(
+      `${skillFile} is no skill the charter can hold: ${faultMessages.join(" ")}`,
+      `Take a skill whose ${SKILL_FILE} declares a "name" of lowercase words joined by "-", and a "description".`
+    );
+  }
+}
+
+// src/hexagon/domain/models/vendor/VendorSource.ts
+var VendorSource = class {
+  constructor(source, name) {
+    this.source = source;
+    this.name = name;
+  }
+  source;
+  name;
+};
+function vendorSourceOf(source) {
+  const addressPath = source.replace(/\.git$/, "").replace(/^[a-z][a-z0-9+.-]*:\/\/[^/]*/i, "").replace(/^[^/\\:@]+@[^/\\:]+:/, "");
+  const folderNames = addressPath.split(/[/\\]/).filter(Boolean).slice(-2);
+  if (folderNames.length < 2 || folderNames.some((folderName) => folderName === "." || folderName === ".."))
+    throw new VendorFault(`Invalid path "${source}".`, "Use correct git path, naming its owner and its repository.");
+  return new VendorSource(source, folderNames.join("/"));
+}
+function installedVendorFolderOf(name) {
+  const folderNames = name.split(/[/\\]/).filter(Boolean);
+  if (folderNames.length === 0 || folderNames.length > 2 || folderNames.some((folderName) => folderName === "." || folderName === ".."))
+    throw new VendorFault(`Invalid path "${name}".`, "Name the folder as cw vendor list names it under .cw/vendor/.");
+  return folderNames.join("/");
+}
+
+// src/hexagon/service/vendorRepo.ts
+var VENDOR_README = "README.md";
+async function loadVendorFolders(repo, fileReaders) {
+  const installedFolders = await fileReaders.listFolders(vendorFolderIn(repo));
+  const vendorFolders = await Promise.all(
+    installedFolders.map(async (folder) => {
+      const ownerName = decodeURIComponent(folder.href.split("/").at(-2) ?? "");
+      const childFolders = await fileReaders.listFolders(folder);
+      const childFolderNames = childFolders.map((childFolder) => decodeURIComponent(childFolder.href.split("/").at(-2) ?? ""));
+      const isSource = childFolderNames.some((childFolderName) => KINDS.includes(childFolderName)) || (await fileReaders.listFiles(folder)).some(({ file: file2 }) => file2.href.endsWith(`/${VENDOR_README}`));
+      if (isSource) return [{ folder, vendorName: ownerName }];
+      return childFolders.map((childFolder, index) => ({ folder: childFolder, vendorName: `${ownerName}/${childFolderNames[index]}` }));
+    })
+  );
+  return vendorFolders.flat().sort((leftFolder, rightFolder) => leftFolder.vendorName.localeCompare(rightFolder.vendorName));
+}
+async function loadVendorNames(repo, fileReaders) {
+  return (await loadVendorFolders(repo, fileReaders)).map(({ vendorName }) => `${VENDOR_DIRECTORY}/${vendorName}`);
+}
+async function ensureVCSReady(repo, vcs2, because) {
+  if (!await vcs2.isInstalled(repo))
+    throw new DomainFault(
+      "This folder is not inside a git repository, and a vendor lives in one.",
+      'Run "git init" here, or run this again where your repository is.'
+    );
+  if (because !== void 0 && !await vcs2.isClean(repo))
+    throw new DomainFault(
+      `This repository has work in hand, and ${because}.`,
+      "Commit or stash what you are holding, then run this again."
+    );
+}
+async function loadFetchedVendor(repo, fileReaders, vcs2, yamlParser2, source, fetchedCommit) {
+  const vendorName = vendorSourceOf(source).name;
+  const folder = `${VENDOR_DIRECTORY}/${vendorName}`;
+  const sourcePaths = await vcs2.listFilesAt(repo, fetchedCommit);
+  const folderUrl = new URL(`${folder}/`, repo);
+  const installedFolderNames = (await fileReaders.listFolders(folderUrl)).map((installedFolder) => decodeURIComponent(installedFolder.href.split("/").at(-2) ?? ""));
+  const holdsCharter = installedFolderNames.some((installedFolderName) => installedFolderName !== SkillPrimitive.kind) || (await fileReaders.listFiles(folderUrl)).some(({ file: file2 }) => file2.href.endsWith(`/${VENDOR_README}`));
+  const holdsVendorSkills = !holdsCharter && installedFolderNames.includes(SkillPrimitive.kind);
+  const reinstallFix = `Run "cw vendor remove ${vendorName}", then install it again.`;
+  if (sourcePaths.some((sourcePath) => sourcePath.startsWith(`${CHARTER_DIRECTORY}/`))) {
+    if (sourcePaths.some((sourcePath) => sourcePath.startsWith(`${VENDOR_DIRECTORY}/`)))
+      throw new VendorFault(`${source} holds "${VENDOR_DIRECTORY}", and vendoring is one level deep.`, `Remove "${VENDOR_DIRECTORY}" from the source, or install a version without it.`);
+    if (holdsVendorSkills) throw new VendorFault(`${folder} holds skills taken from ${source}, which holds a charter now.`, reinstallFix);
+    const charterIndexPaths = sourcePaths.filter((sourcePath) => sourcePath.startsWith(`${CHARTER_DIRECTORY}/`) && sourcePath.endsWith(`/${SkillPrimitive.index}`));
+    const vendorPrimitives2 = await Promise.all(
+      charterIndexPaths.map(async (indexPath) => charterVendorPrimitiveOf(await vcs2.readFileAt(repo, fetchedCommit, indexPath), indexPath, CHARTER_DIRECTORY, yamlParser2))
+    );
+    return { folder, isCharter: true, vendorPrimitives: vendorPrimitives2 };
+  }
+  const skillFiles = skillFilesOf(sourcePaths);
+  if (skillFiles.length === 0)
+    throw new VendorFault(
+      `${source} has no "${CHARTER_DIRECTORY}" and no ${SKILL_FILE} under "${SKILLS_FOLDER}/".`,
+      `Check that the source holds "${CHARTER_DIRECTORY}", or skills under "${SKILLS_FOLDER}/" each in a folder holding its ${SKILL_FILE}, at the version asked for.`
+    );
+  if (holdsCharter) throw new VendorFault(`${folder} holds a charter installed from ${source}, which holds skills alone now.`, reinstallFix);
+  const vendorPrimitives = await Promise.all(
+    skillFiles.map(async (skillFile) => skillVendorPrimitiveOf(await vcs2.readFileAt(repo, fetchedCommit, skillFile), skillFile, yamlParser2))
+  );
+  const sharedIdPrimitives = vendorPrimitives.filter((vendorPrimitive) => vendorPrimitives.some((otherPrimitive) => otherPrimitive !== vendorPrimitive && otherPrimitive.id === vendorPrimitive.id));
+  if (sharedIdPrimitives.length > 0)
+    throw new VendorFault(
+      `${sharedIdPrimitives.map(({ sourceFolder }) => `${sourceFolder}/${SKILL_FILE}`).join(", ")} declare one name, and a name is one skill.`,
+      "Take the skills from a version of the source whose names are its own."
+    );
+  return { folder, isCharter: false, vendorPrimitives: [...vendorPrimitives].sort((leftPrimitive, rightPrimitive) => leftPrimitive.id.localeCompare(rightPrimitive.id)) };
+}
+async function addVendor(repo, fileReaders, fileWriter2, vcs2, yamlParser2, source, version2, skillIds = []) {
+  await ensureVCSReady(repo, vcs2);
+  vendorSourceOf(source);
+  const fetchedCommit = await vcs2.fetchCommit(source, repo, version2);
+  const { folder, isCharter, vendorPrimitives } = await loadFetchedVendor(repo, fileReaders, vcs2, yamlParser2, source, fetchedCommit);
+  if (isCharter) {
+    if (skillIds.length > 0)
+      throw new VendorFault(`${source} holds a charter, and --skill is for skills repositories (compatible with npx skills), not a charter: a charter is installed whole.`, "Run this again without --skill.");
+    await vcs2.checkoutFolderAt(repo, fetchedCommit, CHARTER_DIRECTORY, folder);
+    if ((await vcs2.listFilesAt(repo, fetchedCommit)).includes(VENDOR_README))
+      await fileWriter2.write(new URL(`${folder}/${VENDOR_README}`, repo), await vcs2.readFileAt(repo, fetchedCommit, VENDOR_README));
+    return { folder, vendorPrimitives };
+  }
+  const heldSkillIds = vendorPrimitives.map(({ id }) => id);
+  const unheldSkillIds = skillIds.filter((skillId) => !heldSkillIds.includes(skillId));
+  if (unheldSkillIds.length > 0) throw new VendorFault(`${source} holds no skill ${unheldSkillIds.join(", ")}.`, `Take one it holds: ${heldSkillIds.join(", ")}.`);
+  const chosenPrimitives = skillIds.length === 0 ? vendorPrimitives : vendorPrimitives.filter(({ id }) => skillIds.includes(id));
+  for (const { id, sourceFolder, convertedSkill } of chosenPrimitives) {
+    const skillFolder = `${folder}/${SkillPrimitive.kind}/${id}`;
+    await vcs2.checkoutFolderAt(repo, fetchedCommit, sourceFolder, skillFolder);
+    await fileWriter2.write(new URL(`${skillFolder}/${SkillPrimitive.index}`, repo), convertedSkill.toMarkdown());
+    await fileWriter2.delete(new URL(`${skillFolder}/${SKILL_FILE}`, repo));
+  }
+  return { folder, vendorPrimitives: chosenPrimitives };
+}
+async function removeVendor(repo, vcs2, name) {
+  await ensureVCSReady(repo, vcs2, "removing a vendor commits that it is gone");
+  const folder = `${VENDOR_DIRECTORY}/${installedVendorFolderOf(name)}`;
+  await vcs2.removeSubFolder(repo, folder);
+  return folder;
+}
+async function driftedVendors(repo, vcs2) {
+  const changed = await vcs2.changedUnder(repo, VENDOR_DIRECTORY);
+  const vendorNames = changed.map((path) => {
+    const [ownerName = "", childName = ""] = path.slice(`${VENDOR_DIRECTORY}/`.length).split("/");
+    const isSource = childName === VENDOR_README || KINDS.includes(childName);
+    return isSource ? ownerName : `${ownerName}/${childName}`;
+  });
+  return [...new Set(vendorNames.filter((vendorName) => vendorName !== "" && !vendorName.endsWith("/")))].sort();
+}
+
 // src/hexagon/service/charterRepo.ts
 async function loadCharterRoot(repo, fileReaders, yamlParser2) {
   const repoHref = repo.href.endsWith("/") ? repo.href : `${repo.href}/`;
@@ -60020,12 +60290,9 @@ async function loadCharterRoot(repo, fileReaders, yamlParser2) {
     ];
   };
   const authoredFiles = await read(charterFolderIn(repo));
-  const vendors = await fileReaders.listFolders(vendorFolderIn(repo));
+  const vendorFolders = await loadVendorFolders(repo, fileReaders);
   const vendorFiles = await Promise.all(
-    vendors.map(async (folder) => {
-      const vendor = decodeURIComponent(folder.href.split("/").at(-2) ?? "");
-      return (await read(folder)).map((one) => ({ ...one, vendor }));
-    })
+    vendorFolders.map(async ({ folder, vendorName }) => (await read(folder)).map((vendoredFile) => ({ ...vendoredFile, vendor: vendorName })))
   );
   const builtinFiles = BUILTIN_PRIMITIVES.map((primitive) => ({
     path: primitive.file,
@@ -60184,54 +60451,6 @@ async function ensureTestSuiteNamed(repo, fileReaders, name) {
     throw new TestSuiteFault(`${TEST_DIRECTORY}/ holds no test file called "${name}".`, 'Run "cw suite add" to write a new one.');
 }
 
-// src/hexagon/domain/models/vendor/VendorSource.ts
-var VendorSource = class {
-  constructor(source, name) {
-    this.source = source;
-    this.name = name;
-  }
-  source;
-  name;
-};
-function vendorSourceOf(source) {
-  const name = source.replace(/\.git$/, "").split(/[/:\\]/).filter(Boolean).at(-1) ?? "";
-  if (name === "." || name === ".." || name === "") throw new VendorFault(`Invalid path "${source}".`, "Use correct git path.");
-  return new VendorSource(source, name);
-}
-
-// src/hexagon/service/vendorRepo.ts
-async function loadVendorNames(repo, fileReaders) {
-  return (await fileReaders.listFolders(vendorFolderIn(repo))).map((folder) => `${VENDOR_DIRECTORY}/${decodeURIComponent(folder.href.split("/").at(-2) ?? "")}`).sort();
-}
-async function ensureVCSReady(repo, vcs2, because) {
-  if (!await vcs2.isInstalled(repo))
-    throw new DomainFault(
-      "This folder is not inside a git repository, and a vendor lives in one.",
-      'Run "git init" here, or run this again where your repository is.'
-    );
-  if (because !== void 0 && !await vcs2.isClean(repo))
-    throw new DomainFault(
-      `This repository has work in hand, and ${because}.`,
-      "Commit or stash what you are holding, then run this again."
-    );
-}
-async function addVendor(repo, vcs2, source, version2) {
-  await ensureVCSReady(repo, vcs2);
-  const folder = `${VENDOR_DIRECTORY}/${vendorSourceOf(source).name}`;
-  return vcs2.subtreeAdd(source, [CHARTER_DIRECTORY, "README.md"], repo, folder, version2, VENDOR_DIRECTORY);
-}
-async function removeVendor(repo, vcs2, name) {
-  await ensureVCSReady(repo, vcs2, "removing a vendor commits that it is gone");
-  const folder = `${VENDOR_DIRECTORY}/${vendorSourceOf(name).name}`;
-  await vcs2.removeSubFolder(repo, folder);
-  return folder;
-}
-async function driftedVendors(repo, vcs2) {
-  const changed = await vcs2.changedUnder(repo, VENDOR_DIRECTORY);
-  const names = changed.map((path) => path.slice(`${VENDOR_DIRECTORY}/`.length).split("/")[0]).filter((name) => name !== void 0 && name !== "");
-  return [...new Set(names)].sort();
-}
-
 // src/hexagon/domain/services/testService.ts
 var TestCaseReport = class {
   constructor(suiteName, situation, unmet) {
@@ -60814,12 +61033,17 @@ function claudeDocumentComponentOf(sc, compiledFile, agentTools) {
     // for them: what decides that the body is worth opening is the description,
     // because that line is all this host reads before deciding (FR-013), and
     // composing it is the primitive's. One that is a step of another is kept
-    // out of the user's commands (CORE-FR-174).
+    // out of the user's commands (CORE-FR-174), and one the user alone starts is
+    // kept out of the agent's own reach (CORE-FR-182).
     case SkillPrimitive.kind:
     case PlaybookPrimitive.kind:
       return ClaudeSkill.of(
         name,
-        { description: sc.description(), ...sc.headers["disable-user-invocation"] === true ? { "user-invocable": false } : {} },
+        {
+          description: sc.description(),
+          ...sc.headers["disable-user-invocation"] === true ? { "user-invocable": false } : {},
+          ...sc.headers["disable-model-invocation"] === true ? { "disable-model-invocation": true } : {}
+        },
         pointerTo(`../${compiledFromClaudeFolder}`)
       );
     default:
@@ -61663,13 +61887,17 @@ var CharterVendoring = class {
   #repoPath;
   #fileReader;
   #vcs;
-  constructor(repoPath2, fileReader2, vcs2) {
+  #fileWriter;
+  #yamlParser;
+  constructor(repoPath2, fileReader2, vcs2, fileWriter2, yamlParser2) {
     this.#repoPath = repoPath2;
     this.#fileReader = fileReader2;
     this.#vcs = vcs2;
+    this.#fileWriter = fileWriter2;
+    this.#yamlParser = yamlParser2;
   }
-  async add(source, version2) {
-    return addVendor(this.#repoPath, this.#vcs, source, version2);
+  async add(source, version2, skillIds = []) {
+    return vendorAddOutcomeDTO(await addVendor(this.#repoPath, this.#fileReader, this.#fileWriter, this.#vcs, this.#yamlParser, source, version2, skillIds));
   }
   async remove(name) {
     return removeVendor(this.#repoPath, this.#vcs, name);
@@ -62390,7 +62618,7 @@ import { execFile } from "child_process";
 import { rm as rm2 } from "fs/promises";
 import { promisify } from "util";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { basename as basename2, join as join3 } from "path";
+import { join as join3 } from "path";
 var run = promisify(execFile);
 var Git = class {
   async isInstalled(folder) {
@@ -62433,74 +62661,47 @@ var Git = class {
       return [];
     }
   }
-  /**
-   * `git fetch`, handed the source exactly as it was written, then each path
-   * asked for read into an index of its own and checked out into the folder
-   * given — a folder's files at that folder's root, a file under its own name:
-   * the repository's own index is never touched, so nothing is staged, nothing
-   * is committed, and whatever is in hand stays as it was. A folder already
-   * there is replaced, so installing a source and bringing it up to date are
-   * one call (FR-023, FR-030, FR-042).
-   *
-   * Which transport it is, whether the credentials are there, whether the
-   * version exists: git answers all three, and what it says is what the user
-   * reads (FR-031). `HEAD` where no version is named, which is what the source
-   * calls its own default.
-   *
-   * `git subtree` takes a source whole and cannot take one folder of it, so
-   * each path is read straight off what was fetched. Whether the first is
-   * there, and whether the refused one is, is asked of git before anything is
-   * touched. What lands has no history to walk (FR-028).
-   */
-  async subtreeAdd(source, includePaths, repo, intoSubFolder, version2, refusedIfSourceHolds) {
+  /** `git fetch` of one version, and `FETCH_HEAD` read at once, before
+   *  anything else can move it. */
+  async fetchCommit(source, repo, version2) {
     const cwd = fileURLToPath3(repo);
-    const ref = version2 ?? "HEAD";
     try {
-      await run("git", ["fetch", "--quiet", "--no-tags", "--", source, ref], { cwd });
+      await run("git", ["fetch", "--quiet", "--no-tags", "--", source, version2 ?? "HEAD"], { cwd });
     } catch (raised) {
       throw new AdapterFault(
-        `${raised}`,
+        `${source} could not be fetched: ${raised}`,
         version2 === void 0 ? "Check the address, and that you can reach it from here." : `Check the address, and that "${version2}" is a tag or branch it has.`
       );
     }
-    const fetchedCommit = (await run("git", ["rev-parse", "FETCH_HEAD"], { cwd })).stdout.trim();
-    const objectTypeAt = (path) => run("git", ["cat-file", "-t", `${fetchedCommit}:${path}`], { cwd }).then(
-      ({ stdout }) => stdout.trim(),
-      () => void 0
-    );
-    const atVersion = version2 === void 0 ? "" : ` at ${version2}`;
-    const [requiredPath = ""] = includePaths;
-    if (await objectTypeAt(requiredPath) === void 0)
-      throw new AdapterFault(`${source} has no "${requiredPath}"${atVersion}.`, `Check that the source holds "${requiredPath}" at the version asked for.`);
-    if (refusedIfSourceHolds !== void 0 && await objectTypeAt(refusedIfSourceHolds) === "tree")
-      throw new AdapterFault(
-        `${source} holds "${refusedIfSourceHolds}"${atVersion}, which this copy refuses.`,
-        `Remove "${refusedIfSourceHolds}" from the source, or copy a version without it.`
-      );
-    const vendorIndexPath = (await run("git", ["rev-parse", "--path-format=absolute", "--git-path", "cw-vendor-index"], { cwd })).stdout.trim();
-    const vendorIndexEnv = { ...process.env, GIT_INDEX_FILE: vendorIndexPath };
+    return (await run("git", ["rev-parse", "FETCH_HEAD"], { cwd })).stdout.trim();
+  }
+  /** `git ls-tree -r`, the paths split on the NUL `-z` ends each with, so a
+   *  path holding a newline or a quote is read as it is. */
+  async listFilesAt(repo, commit) {
+    const { stdout } = await run("git", ["ls-tree", "-r", "-z", "--name-only", commit], { cwd: fileURLToPath3(repo), maxBuffer: 64 * 1024 * 1024 });
+    return stdout.split("\0").filter((path) => path !== "");
+  }
+  /** `git show <commit>:<path>`. */
+  async readFileAt(repo, commit, path) {
+    return (await run("git", ["show", `${commit}:${path}`], { cwd: fileURLToPath3(repo), maxBuffer: 64 * 1024 * 1024 })).stdout;
+  }
+  /** `git read-tree --prefix` into an index of its own, then `checkout-index`
+   *  over the folder emptied first: the repository's own
+   *  index, and what is staged in it, is never read from or written to. */
+  async checkoutFolderAt(repo, commit, fromFolder, intoSubFolder) {
+    const cwd = fileURLToPath3(repo);
+    const checkoutIndexPath = (await run("git", ["rev-parse", "--path-format=absolute", "--git-path", "cw-checkout-index"], { cwd })).stdout.trim();
+    const checkoutIndexEnv = { ...process.env, GIT_INDEX_FILE: checkoutIndexPath };
     try {
-      await rm2(vendorIndexPath, { force: true });
-      for (const includePath of includePaths) {
-        const objectType = await objectTypeAt(includePath);
-        if (objectType === "tree")
-          await run("git", ["read-tree", `--prefix=${intoSubFolder}/`, `${fetchedCommit}:${includePath}`], { cwd, env: vendorIndexEnv });
-        if (objectType === "blob") {
-          const [fileMode = "100644", , fileHash = ""] = (await run("git", ["ls-tree", fetchedCommit, "--", includePath], { cwd })).stdout.split(/\s+/);
-          await run("git", ["update-index", "--add", "--cacheinfo", `${fileMode},${fileHash},${intoSubFolder}/${basename2(includePath)}`], {
-            cwd,
-            env: vendorIndexEnv
-          });
-        }
-      }
+      await rm2(checkoutIndexPath, { force: true });
+      await run("git", ["read-tree", `--prefix=${intoSubFolder}/`, fromFolder === "" ? commit : `${commit}:${fromFolder}`], { cwd, env: checkoutIndexEnv });
       await rm2(join3(cwd, intoSubFolder), { recursive: true, force: true });
-      await run("git", ["checkout-index", "--all", "--force"], { cwd, env: vendorIndexEnv });
-      return intoSubFolder;
+      await run("git", ["checkout-index", "--all", "--force"], { cwd, env: checkoutIndexEnv });
     } catch (raised) {
       await run("git", ["restore", "--source=HEAD", "--worktree", "--", intoSubFolder], { cwd }).catch(() => void 0);
       throw new AdapterFault(`${raised}`, `Check that "${intoSubFolder}" can be written, and run this again.`);
     } finally {
-      await rm2(vendorIndexPath, { force: true });
+      await rm2(checkoutIndexPath, { force: true });
     }
   }
   /** `git rm -r` and a commit of its own: the folder is gone from the working
@@ -65594,7 +65795,7 @@ var charterAuthoringApp = new CharterAuthoring(
   secrets,
   authorizing
 );
-var charterVendoringApp = new CharterVendoring(repoPath, fileReader, vcs);
+var charterVendoringApp = new CharterVendoring(repoPath, fileReader, vcs, fileWriter, yamlParser);
 var testAuthoringApp = new TestAuthoring(repoPath, fileReader, fileWriter);
 var mcpConnectingApp = new McpConnecting(repoPath, fileReader, secrets, authorizing, yamlParser, mcpServers);
 var homePath = pathToFileURL2(`${homedir()}/`);