agents-inc 0.170.0 → 0.170.2

package/dist/chunk-GEMW5RQ2.js

@@ -0,0 +1,1169 @@
+#!/usr/bin/env node
+import {
+  SHARED_CONFIG_APPLY,
+  SHARED_CONFIG_ARRIVALS,
+  STATUS_MESSAGES,
+  addedToGlobalSubAgents,
+  buildMarketplacePluginRef,
+  claimSlug,
+  completedWithFailures,
+  copy,
+  defaultUsageGuidance,
+  directoryExists,
+  fetchMarketplace,
+  fileExists,
+  findConfigLoadFailures,
+  findUnusableSavedSkillMetadata,
+  getCurrentDate,
+  getErrorMessage,
+  getStackSkillIds,
+  glob,
+  hostAt,
+  installationConfigsUnreadable,
+  isHomeDirectory,
+  isLocalOnlySkill,
+  loadProjectConfigFromDir,
+  parseFrontmatter,
+  pluginsInstalled,
+  propagatedRecompileSummary,
+  providerInUse,
+  readFile,
+  readForkedFromMetadata,
+  readSkillMetadata,
+  refuseUnofferedPlacements,
+  refuseUnofferedStack,
+  refuseUnwritableStack,
+  registeredProjectConfigUnreadable,
+  registeredProjectGone,
+  registeredProjectOnAnotherProvider,
+  remove,
+  resolveBranding,
+  resolveInstallPaths,
+  savedSkillMetadataUnusableError,
+  scopeBlockedStackAssignment,
+  sharedConfigProjectScopeAtHome,
+  skillAssignedToNoAgent,
+  skillMetadataUnusableDetail,
+  skippedUnknownAgents,
+  skippedUnknownSkills,
+  typedEntries,
+  typedKeys,
+  typedValues,
+  validateSkillPath,
+  verbose,
+  warn,
+  writeFile
+} from "./chunk-GAKVZNTX.js";
+import {
+  BUILT_IN_MATRIX,
+  getCategoryDomain,
+  getSkillDisplayName,
+  matrix,
+  stripTerminalControls
+} from "./chunk-AUNRHWH4.js";
+import {
+  CLI_COLORS,
+  CLI_INVOKE_COMMAND,
+  DEFAULT_BRANDING,
+  EJECT_SOURCE,
+  GITHUB_PREFIX,
+  GITHUB_SOURCE,
+  LOCAL_SKILLS_PATH,
+  MIN_TERMINAL_SIZE,
+  STANDARD_FILES,
+  externalIdsNamingNoDirectory,
+  isActiveAt,
+  orderDomains,
+  seedExternalSkillSchema
+} from "./chunk-7C3PFRBU.js";
+
+// src/cli/utils/terminal.ts
+function clearTerminalScreen() {
+  process.stdout.write("\x1B[H\x1B[2J\x1B[3J");
+}
+function isTerminalLargeEnough(columns, rows) {
+  return columns >= MIN_TERMINAL_SIZE.COLS && rows >= MIN_TERMINAL_SIZE.ROWS;
+}
+function formatTerminalTooSmallMessage(columns) {
+  const issue = columns < MIN_TERMINAL_SIZE.COLS ? `too narrow (need ${MIN_TERMINAL_SIZE.COLS})` : `too short (need ${MIN_TERMINAL_SIZE.ROWS})`;
+  return `Terminal ${issue}. Please resize.`;
+}
+
+// src/cli/lib/exit-codes.ts
+var EXIT_CODES = {
+  SUCCESS: 0,
+  ERROR: 1,
+  INVALID_ARGS: 2,
+  NETWORK_ERROR: 3,
+  CANCELLED: 4,
+  /**
+   * Ran to the end but part of the work failed. Unlike ERROR the work landed, so repeating the run
+   * is wrong; the output names the remedy. Raised at the end of a command, never mid-flight.
+   */
+  COMPLETED_WITH_FAILURES: 5
+};
+
+// src/cli/lib/seed/external-skills.ts
+import os from "os";
+import path from "path";
+import { mkdtemp } from "fs/promises";
+
+// ../compile/src/carried-skill.ts
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var FRONTMATTER_BLOCK = /^---\r?\n([\s\S]*?)\r?\n---/;
+var NAME_FIELD = /^name:.*$/m;
+function withInstalledName(manifest, { id, description }) {
+  const named = `name: ${id}`;
+  const block = FRONTMATTER_BLOCK.exec(manifest);
+  if (!block) {
+    return `---
+${named}
+description: ${description}
+---
+
+${manifest}`;
+  }
+  const [whole, fields = ""] = block;
+  const renamed = NAME_FIELD.test(fields) ? fields.replace(NAME_FIELD, named) : `${named}
+${fields}`;
+  return `---
+${renamed}
+---${manifest.slice(whole.length)}`;
+}
+function carriedSkillAuthor(repo) {
+  const [owner = repo] = repo.split("/");
+  return `@${owner}`;
+}
+function carriedSkillMetadata({
+  id,
+  skill,
+  domain,
+  usageGuidance,
+  shipped
+}) {
+  return {
+    author: carriedSkillAuthor(skill.repo),
+    usageGuidance,
+    ...shipped,
+    displayName: skill.displayName,
+    slug: id,
+    category: skill.categoryId,
+    domain,
+    cliDescription: shortLabel(skill.description),
+    custom: true
+  };
+}
+var CLI_DESCRIPTION_MAX_LENGTH = 60;
+var ELLIPSIS = "\u2026";
+function shortLabel(description) {
+  if (description.length <= CLI_DESCRIPTION_MAX_LENGTH) return description;
+  const roomLength = CLI_DESCRIPTION_MAX_LENGTH - ELLIPSIS.length;
+  const room = description.slice(0, roomLength);
+  const endsOnAWord = description[roomLength] === " ";
+  return `${endsOnAWord ? room.trimEnd() : toLastWholeWord(room)}${ELLIPSIS}`;
+}
+function toLastWholeWord(text) {
+  const lastBreak = text.lastIndexOf(" ");
+  return (lastBreak > 0 ? text.slice(0, lastBreak) : text).trimEnd();
+}
+async function installedSkillTree(install) {
+  const manifest = withInstalledName(manifestOf(install.skill.files), {
+    id: install.id,
+    description: install.skill.description
+  });
+  return {
+    ...install.skill.files,
+    [STANDARD_FILES.SKILL_MD]: manifest,
+    [STANDARD_FILES.METADATA_YAML]: await metadataYaml(install, manifest)
+  };
+}
+var METADATA_SCHEMA_COMMENT = "# yaml-language-server: $schema=https://raw.githubusercontent.com/agents-inc/agents-inc/main/packages/cli/src/schemas/metadata.schema.json";
+var NO_LINE_FOLDING = 0;
+async function metadataYaml(install, manifest) {
+  const metadata = carriedSkillMetadata({
+    ...install,
+    shipped: shippedMetadata(install.skill.files)
+  });
+  const stamp = await provenanceStamp(install, manifest);
+  return asMetadataFile(withForkedFrom(metadata, stamp));
+}
+async function provenanceStamp(install, manifest) {
+  return {
+    skillId: install.id,
+    contentHash: await contentHashOf(manifest),
+    date: install.date,
+    source: `${GITHUB_PREFIX}${install.skill.repo}`,
+    path: install.skill.path
+  };
+}
+var asMetadataFile = (metadata) => `${METADATA_SCHEMA_COMMENT}
+${stringifyYaml(metadata, {
+  lineWidth: NO_LINE_FOLDING
+})}`;
+function withForkedFrom(metadata, forkedFrom) {
+  const { forkedFrom: _replaced, ...rest } = metadata;
+  return { ...rest, forkedFrom };
+}
+function shippedMetadata(files) {
+  const shipped = files[STANDARD_FILES.METADATA_YAML];
+  if (shipped === void 0) return null;
+  const parsed = parsedYaml(shipped);
+  return isMapping(parsed) && hasReadableProvenance(parsed) ? parsed : null;
+}
+function parsedYaml(text) {
+  try {
+    return parseYaml(text);
+  } catch {
+    return void 0;
+  }
+}
+var isMapping = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var PROVENANCE_REQUIRED = ["skillId", "contentHash", "date"];
+var PROVENANCE_OPTIONAL = ["source", "path"];
+function hasReadableProvenance(metadata) {
+  if (!Object.hasOwn(metadata, "forkedFrom")) return true;
+  const provenance = metadata.forkedFrom;
+  return isMapping(provenance) && PROVENANCE_REQUIRED.every((key) => typeof provenance[key] === "string") && PROVENANCE_OPTIONAL.every(
+    (key) => !Object.hasOwn(provenance, key) || typeof provenance[key] === "string"
+  );
+}
+function manifestOf(files) {
+  const manifest = files[STANDARD_FILES.SKILL_MD];
+  if (manifest === void 0) {
+    throw new Error(
+      `A carried skill's directory holds no ${STANDARD_FILES.SKILL_MD}, which seedSkillTreeSchema refuses`
+    );
+  }
+  return manifest;
+}
+var CONTENT_HASH_LENGTH = 7;
+async function contentHashOf(text) {
+  const digest = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(text)
+  );
+  return hexOf(new Uint8Array(digest)).slice(0, CONTENT_HASH_LENGTH);
+}
+var hexOf = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+
+// src/cli/lib/seed/external-skills.ts
+function pluginInstallError(ids) {
+  return [
+    "This configuration cannot be installed: these skills travel inside it, so no marketplace serves them and they cannot be installed as plugins:",
+    ...ids.map((id) => `  ${id}`),
+    "Re-share it with each skill above set to eject, which is the only way a carried skill installs."
+  ].join("\n");
+}
+function selectedExternals(payload) {
+  return typedEntries(payload.external ?? {}).flatMap(([id, skill]) => {
+    const entry = payload.skills[id];
+    return entry ? [{ id, skill, entry }] : [];
+  });
+}
+function askedForAsPlugin(externals) {
+  return externals.filter(({ entry }) => entry.install !== "eject").map(({ id }) => id);
+}
+function claimingACatalogueId(externals, matrix2) {
+  return externals.filter(({ id }) => heldByEitherCatalogue(id, matrix2)).map(({ id }) => id);
+}
+var CATALOGUE_SKILL_IDS = new Set(typedKeys(BUILT_IN_MATRIX.skills));
+function heldByEitherCatalogue(id, matrix2) {
+  return heldByLoadedCatalogue(matrix2.skills[id]) || CATALOGUE_SKILL_IDS.has(id);
+}
+function heldByLoadedCatalogue(incumbent) {
+  return incumbent !== void 0 && incumbent.local !== true;
+}
+function catalogueIdCollisionError(ids) {
+  return [
+    "This configuration cannot be installed: these skills travel inside it under ids a catalogue already owns:",
+    ...ids.map((id) => `  ${id}`),
+    "A skill id is the directory the skill installs into, so each would be written over the catalogue's own copy of that skill. Re-share it with each skill above added again, which mints an id \u2014 'external-<category>-<name>' \u2014 that no catalogue owns."
+  ].join("\n");
+}
+function externalSlug(id) {
+  return id;
+}
+function externalSkillDir(id, scope, projectDir) {
+  return path.join(resolveInstallPaths(projectDir, scope).skillsDir, id);
+}
+function externalCatalogueEntry(install) {
+  return {
+    id: install.id,
+    slug: externalSlug(install.id),
+    displayName: install.skill.displayName,
+    description: install.skill.description,
+    // Boundary cast: seatExternalSkill has confirmed this catalogue declares the category.
+    category: install.skill.categoryId,
+    author: carriedSkillAuthor(install.skill.repo),
+    path: `${LOCAL_SKILLS_PATH}/${install.id}/`,
+    conflictsWith: [],
+    requires: [],
+    alternatives: [],
+    discourages: [],
+    local: true,
+    custom: true,
+    localPath: install.skillDir
+  };
+}
+function seatExternalSkill({ id, skill, entry }, matrix2, projectDir) {
+  const domain = getCategoryDomain(skill.categoryId);
+  if (domain === void 0) return [];
+  const install = {
+    id,
+    skill,
+    domain,
+    scope: entry.scope,
+    skillDir: externalSkillDir(id, entry.scope, projectDir)
+  };
+  matrix2.skills[id] = externalCatalogueEntry(install);
+  claimSlug(matrix2.slugMap, externalSlug(id), id);
+  return [install];
+}
+function notADirectoryNameError(ids) {
+  return [
+    "This configuration cannot be installed: these skills travel inside it under ids that are not a single directory name:",
+    ...ids.map((id) => `  ${JSON.stringify(id)}`),
+    "A skill id is the directory the skill is written into, so an id holding a path separator, or naming '.' or '..', would be written somewhere other than a directory of its own, and one holding a control character would hand it to the terminal wherever that directory is named. Re-share it with each skill above added again, which mints an id \u2014 'external-<category>-<name>' \u2014 that names one directory."
+  ].join("\n");
+}
+function registerExternalSkills(payload, matrix2, projectDir) {
+  const notDirectoryNames = externalIdsNamingNoDirectory(payload);
+  if (notDirectoryNames.length > 0) throw new Error(notADirectoryNameError(notDirectoryNames));
+  const externals = selectedExternals(payload);
+  const asPlugin = askedForAsPlugin(externals);
+  const colliding = claimingACatalogueId(externals, matrix2);
+  if (asPlugin.length > 0) throw new Error(pluginInstallError(asPlugin));
+  if (colliding.length > 0) throw new Error(catalogueIdCollisionError(colliding));
+  return externals.flatMap((external) => seatExternalSkill(external, matrix2, projectDir));
+}
+async function writeExternalSkills(installs) {
+  await refuseUncarriedDestinations(installs);
+  const written = await Promise.all(installs.map(writeExternalSkill));
+  return changedIds(written);
+}
+var SCRATCH_DIR_PREFIX = "agents-inc-carried-";
+async function carriedSkillsThatDiffer(installs) {
+  if (installs.length === 0) return [];
+  const scratch = await mkdtemp(path.join(os.tmpdir(), SCRATCH_DIR_PREFIX));
+  try {
+    const written = await Promise.all(
+      installs.map(async (install) => writeExternalSkill(await scratchCopyOf(install, scratch)))
+    );
+    return changedIds(written);
+  } finally {
+    await remove(scratch);
+  }
+}
+async function scratchCopyOf(install, scratch) {
+  const skillDir = path.join(scratch, install.id);
+  if (await directoryExists(install.skillDir)) await copy(install.skillDir, skillDir);
+  return { ...install, skillDir };
+}
+function changedIds(written) {
+  return written.filter(({ changed }) => changed).map(({ id }) => id);
+}
+async function writeExternalSkill(install) {
+  const files = typedEntries(await treeToWrite(install));
+  refuseEscapingPaths(install.skillDir, files);
+  const written = await Promise.all(
+    files.map(
+      ([relativePath, contents]) => writeIfChanged(path.join(install.skillDir, relativePath), contents)
+    )
+  );
+  return { id: install.id, changed: written.some(Boolean) };
+}
+function refuseEscapingPaths(skillDir, files) {
+  for (const [relativePath] of files) {
+    validateSkillPath(path.join(skillDir, relativePath), skillDir, relativePath);
+  }
+}
+async function treeToWrite(install) {
+  const shipped = await withShippedMetadata(install);
+  const unchanged = await treeAsInstalled(install, shipped);
+  return unchanged ?? carriedTree(install, shipped, getCurrentDate());
+}
+async function treeAsInstalled(install, shipped) {
+  const recorded = (await readForkedFromMetadata(install.skillDir))?.date;
+  if (recorded === void 0) return null;
+  const tree = await carriedTree(install, shipped, recorded);
+  const onDisk = await bytesOnDisk(path.join(install.skillDir, STANDARD_FILES.METADATA_YAML));
+  return tree[STANDARD_FILES.METADATA_YAML] === onDisk ? tree : null;
+}
+function carriedTree(install, skill, date) {
+  return installedSkillTree({
+    id: install.id,
+    skill,
+    domain: install.domain,
+    usageGuidance: defaultUsageGuidance(install.skill.categoryId),
+    date
+  });
+}
+async function withShippedMetadata(install) {
+  if (Object.hasOwn(install.skill.files, STANDARD_FILES.METADATA_YAML)) return install.skill;
+  const onDisk = await bytesOnDisk(path.join(install.skillDir, STANDARD_FILES.METADATA_YAML));
+  if (onDisk === null) return install.skill;
+  return {
+    ...install.skill,
+    files: { ...install.skill.files, [STANDARD_FILES.METADATA_YAML]: onDisk }
+  };
+}
+async function bytesOnDisk(filePath) {
+  return await fileExists(filePath) ? readFile(filePath) : null;
+}
+async function writeIfChanged(filePath, contents) {
+  if (await bytesOnDisk(filePath) === contents) return false;
+  await writeFile(filePath, contents);
+  return true;
+}
+async function refuseUncarriedDestinations(installs) {
+  const judged = await Promise.all(installs.map(judgeDestination));
+  const blocked = judged.filter((destination) => destination !== null);
+  if (blocked.length > 0) throw new Error(uncarriedDestinationError(blocked));
+}
+async function judgeDestination(install) {
+  const { id, skillDir } = install;
+  if (!await directoryExists(skillDir)) return null;
+  if ((await readForkedFromMetadata(skillDir))?.path !== void 0) return null;
+  return { id, skillDir };
+}
+function uncarriedDestinationError(blocked) {
+  return [
+    "This configuration cannot be installed: these skills travel inside it under ids this installation already keeps a skill directory for, and no shared configuration put those directories there:",
+    ...blocked.map(({ id, skillDir }) => `  ${id}  ->  ${skillDir}`),
+    "A skill id is the directory the skill installs into, so each would be written over a skill written here by hand or ejected from a marketplace. Move or rename the directory above, or re-share the configuration with each skill added again, which mints an id \u2014 'external-<category>-<name>' \u2014 that nothing here holds."
+  ].join("\n");
+}
+function unnameableRepoMessage(id) {
+  return `${id} travels inside a shared configuration, and this installation does not record the repository its content came from`;
+}
+function uncarryableContentMessage(id, reason) {
+  return `${id} travels inside a shared configuration, and ${reason}`;
+}
+function repoFromRef(ref) {
+  if (ref === void 0 || !ref.startsWith(GITHUB_SOURCE.GITHUB_PREFIX)) return void 0;
+  return ref.slice(GITHUB_SOURCE.GITHUB_PREFIX.length);
+}
+var NO_MANIFEST_DESCRIPTION = `no description can be read from its ${STANDARD_FILES.SKILL_MD}`;
+function manifestDescription(files, skillDir) {
+  const manifest = files[STANDARD_FILES.SKILL_MD];
+  if (manifest === void 0) return null;
+  const frontmatter = parseFrontmatter(manifest, path.join(skillDir, STANDARD_FILES.SKILL_MD));
+  return frontmatter === null ? null : frontmatter.description;
+}
+async function readSkillTree(skillDir) {
+  const files = await glob("**/*", skillDir, { dot: true });
+  const entries = await Promise.all(
+    files.map(async (file) => [file, await readFile(path.join(skillDir, file))])
+  );
+  return Object.fromEntries(entries);
+}
+async function readCarriedSkill({ id, skillDir, provenance }) {
+  if (provenance.path === void 0) return { carries: "nothing" };
+  const repo = repoFromRef(provenance.source);
+  if (repo === void 0) return { carries: "unshareable", line: unnameableRepoMessage(id) };
+  const described = await readSkillMetadata(path.join(skillDir, STANDARD_FILES.METADATA_YAML));
+  if (!described.usable) {
+    return { carries: "unshareable", line: uncarryableContentMessage(id, described.reason) };
+  }
+  const files = await readSkillTree(skillDir);
+  const description = manifestDescription(files, skillDir);
+  if (description === null) {
+    return { carries: "unshareable", line: uncarryableContentMessage(id, NO_MANIFEST_DESCRIPTION) };
+  }
+  const parsed = seedExternalSkillSchema.safeParse({
+    displayName: described.metadata.displayName,
+    description,
+    categoryId: described.metadata.category,
+    repo,
+    path: provenance.path,
+    files
+  });
+  if (!parsed.success) {
+    const reason = parsed.error.issues.map((issue) => issue.message).join("; ");
+    return { carries: "unshareable", line: uncarryableContentMessage(id, reason) };
+  }
+  return { carries: "content", id, skill: parsed.data };
+}
+async function readCarriedSkills(owned) {
+  const reads = await Promise.all(owned.map(readCarriedSkill));
+  return {
+    external: Object.fromEntries(
+      reads.flatMap((read) => read.carries === "content" ? [[read.id, read.skill]] : [])
+    ),
+    uncarryable: reads.flatMap((read) => read.carries === "unshareable" ? [read.line] : [])
+  };
+}
+
+// src/cli/lib/seed/seed-apply.ts
+import os2 from "os";
+import { isDeepEqual, omit, partition, pick } from "remeda";
+var NOTHING_KEPT = {
+  authoredSkillIds: [],
+  unplaceableSkillIds: []
+};
+function reconcileSharedConfig(options) {
+  const { decoded, installed } = options;
+  if (!installed) return nothingToReconcile(decoded);
+  const keptSkills = skillsToKeep(options, installed);
+  if (keptSkills.length === 0) return nothingToReconcile(decoded);
+  const { result, unassigned } = withKeptEntries(decoded, installed, keptSkills);
+  return { result, kept: describeKept(options, keptSkills), unassigned };
+}
+function nothingToReconcile(decoded) {
+  return { result: decoded, kept: NOTHING_KEPT, unassigned: [] };
+}
+function skillsToKeep(options, installed) {
+  const named = new Set(options.decoded.skills.map((skill) => skill.id));
+  return installed.skills.filter(
+    (skill) => !skill.excluded && !named.has(skill.id) && mayNotRemove(skill, options)
+  );
+}
+function mayNotRemove(skill, options) {
+  return options.authoredHere.has(skill.id) || options.unplaceable.has(skill.id);
+}
+function describeKept(options, keptSkills) {
+  const idsKeptFor = (reason) => keptSkills.filter((skill) => reasonKept(skill, options) === reason).map((skill) => skill.id);
+  return {
+    authoredSkillIds: idsKeptFor("authored"),
+    unplaceableSkillIds: idsKeptFor("unplaceable")
+  };
+}
+function reasonKept(skill, options) {
+  return options.authoredHere.has(skill.id) ? "authored" : "unplaceable";
+}
+function withKeptEntries(decoded, installed, keptSkills) {
+  const withSkills = {
+    ...decoded,
+    skills: [...decoded.skills, ...keptSkills],
+    selectedDomains: withKeptDomains(decoded.selectedDomains, keptSkills)
+  };
+  const { assignedStack, unassigned } = withKeptStackRows(decoded.assignedStack, installed.stack, {
+    keptSkillIds: new Set(keptSkills.map((skill) => skill.id)),
+    survivingAgents: new Set(decoded.selectedAgents)
+  });
+  return { result: { ...withSkills, assignedStack }, unassigned };
+}
+function withKeptDomains(selected, keptSkills) {
+  const keptDomains = keptSkills.flatMap((skill) => domainOfSkill(skill.id) ?? []);
+  const missing = keptDomains.filter((domain) => !selected.includes(domain));
+  if (missing.length === 0) return selected;
+  return orderDomains([...selected, ...new Set(missing)]);
+}
+function domainOfSkill(skillId) {
+  const category = matrix.skills[skillId]?.category;
+  return category === void 0 ? void 0 : getCategoryDomain(category);
+}
+function withKeptStackRows(assigned, installedStack, filter) {
+  const isKept = (_category, row) => filter.keptSkillIds.has(row.id);
+  return typedEntries(installedStack ?? {}).filter(([agent]) => filter.survivingAgents.has(agent)).reduce(
+    (carried, [agent, agentStack]) => withAgentKeptRows(carried, agent, rowsWhere(agentStack, isKept), assigned[agent]),
+    { assignedStack: assigned, unassigned: [] }
+  );
+}
+function withAgentKeptRows(carried, agent, keptRows, payloadRows) {
+  const filled = filledExclusiveCategories(payloadRows);
+  const [displaced, joining] = partition(keptRows, ([category]) => filled.has(category));
+  return {
+    assignedStack: withAppendedRows(carried.assignedStack, agent, joining),
+    unassigned: [
+      ...carried.unassigned,
+      ...displaced.map(([category, row]) => ({ skillId: row.id, agentName: agent, category }))
+    ]
+  };
+}
+function withUnplaceableAssignees(decoded, installed, payload, unplaceable) {
+  if (!installed) return decoded;
+  const assigned = assigneesOfHeld(payload, installed, unplaceable);
+  const selected = new Set(decoded.selectedAgents);
+  const leftOutThoughAssigned = (agent) => !agent.excluded && assigned.has(agent.name) && !selected.has(agent.name);
+  const assignees = installed.agents.filter(leftOutThoughAssigned);
+  if (assignees.length === 0) return decoded;
+  return {
+    ...decoded,
+    selectedAgents: [...decoded.selectedAgents, ...assignees.map((agent) => agent.name)],
+    agentConfigs: [...decoded.agentConfigs, ...assignees]
+  };
+}
+function assigneesOfHeld(payload, installed, unplaceable) {
+  const held = new Set(
+    installed.skills.filter((skill) => !skill.excluded).map((skill) => skill.id)
+  );
+  const isHeldUnplaceable = ([id]) => unplaceable.has(id) && held.has(id);
+  const isNotSwitchedOff = (name) => payload.agents[name]?.on !== false;
+  return new Set(
+    typedEntries(payload.skills).filter(isHeldUnplaceable).flatMap(([, skill]) => typedKeys(skill.assignments)).filter(isNotSwitchedOff)
+  );
+}
+async function readInstalledGlobal(projectDir) {
+  const loaded = await loadProjectConfigFromDir(os2.homedir(), providerInUse(projectDir));
+  return loaded?.config ?? null;
+}
+var NO_GLOBAL_ENTRIES = { skillIds: [], agentNames: [] };
+function holdInstalledGlobal(decoded, installed) {
+  if (!installed) {
+    return {
+      result: decoded,
+      installed: NO_GLOBAL_ENTRIES,
+      keptAsInstalled: NO_GLOBAL_ENTRIES,
+      joined: []
+    };
+  }
+  const heldSkills = activeGlobalById(installed.skills, (skill) => skill.id);
+  const heldAgents = activeGlobalById(installed.agents, (agent) => agent.name);
+  const skills = pairWithHeld(decoded.skills, heldSkills, (skill) => skill.id);
+  const agents = pairWithHeld(decoded.agentConfigs, heldAgents, (agent) => agent.name);
+  const namedSkillIds = skills.map(({ named }) => named.id);
+  const namedAgentNames = agents.map(({ named }) => named.name);
+  const { assignedStack, joined } = withHeldRows(decoded.assignedStack, installed.stack, {
+    agentNames: namedAgentNames,
+    skippedSkillIds: new Set(namedSkillIds)
+  });
+  return {
+    result: {
+      ...decoded,
+      skills: decoded.skills.map(asHeld(skills)),
+      agentConfigs: decoded.agentConfigs.map(asHeld(agents)),
+      assignedStack
+    },
+    installed: { skillIds: namedSkillIds, agentNames: namedAgentNames },
+    keptAsInstalled: {
+      skillIds: skillsKeptAsInstalled(skills),
+      agentNames: agentsKeptAsInstalled(agents, {
+        stated: decoded.assignedStack,
+        held: assignedStack,
+        joined
+      })
+    },
+    joined
+  };
+}
+function skillsKeptAsInstalled(pairs) {
+  return pairs.filter((pair) => !restatesSkill(pair)).map(({ named }) => named.id);
+}
+function restatesSkill({ named, held }) {
+  return named.origin === held.origin;
+}
+function agentsKeptAsInstalled(pairs, rows) {
+  const joinedNames = new Set(rows.joined.map(({ agentName }) => agentName));
+  const keptAsIs = (pair) => !restatesAgent(pair, rows) && !joinedNames.has(pair.named.name);
+  return pairs.filter(keptAsIs).map(({ named }) => named.name);
+}
+function restatesAgent({ named, held }, rows) {
+  return named.model === held.model && named.codexModel === held.codexModel && named.effort === held.effort && sameAssignments(rows.stated[named.name], rows.held[named.name]);
+}
+function restoreInstalledGlobal(decoded, installed) {
+  const held = holdInstalledGlobal(decoded, installed);
+  if (!installed) return held;
+  const omitted = omittedGlobal(held.result, installed);
+  const { skillIds, agentNames } = held.keptAsInstalled;
+  return {
+    ...held,
+    result: withOmittedGlobal(held.result, installed, omitted),
+    keptAsInstalled: {
+      skillIds: [...skillIds, ...omitted.skills.map((skill) => skill.id)],
+      agentNames: [...agentNames, ...omitted.agents.map((agent) => agent.name)]
+    }
+  };
+}
+function activeGlobalById(entries, keyOf) {
+  return new Map(
+    entries.filter((entry) => isActiveAt(entry, "global")).map((entry) => [keyOf(entry), entry])
+  );
+}
+function asHeld(pairs) {
+  const heldFor = new Map(pairs.map(({ named, held }) => [named, held]));
+  return (entry) => heldFor.get(entry) ?? entry;
+}
+function pairWithHeld(decoded, heldByKey, keyOf) {
+  return decoded.flatMap((named) => {
+    const held = heldByKey.get(keyOf(named));
+    return held !== void 0 && isActiveAt(named, "global") ? [{ named, held }] : [];
+  });
+}
+function sameAssignments(left, right) {
+  return isDeepEqual(assignmentKeys(left), assignmentKeys(right));
+}
+function assignmentKeys(agentStack) {
+  return typedEntries(agentStack ?? {}).flatMap(
+    ([category, assignments]) => assignments.map((row) => `${category}/${row.id}/${row.preloaded === true}`)
+  ).sort();
+}
+function withInstalledRows(assigned, installedStack, agentNames) {
+  return { ...omit(assigned, agentNames), ...pick(installedStack ?? {}, agentNames) };
+}
+function withHeldRows(assigned, installedStack, held) {
+  const asInstalled = withInstalledRows(assigned, installedStack, held.agentNames);
+  const arrivals = held.agentNames.map((agentName) => ({
+    agentName,
+    rows: arrivingRows(assigned[agentName], asInstalled[agentName], held.skippedSkillIds)
+  }));
+  return {
+    assignedStack: arrivals.reduce(
+      (stack, { agentName, rows }) => withAppendedRows(stack, agentName, rows),
+      asInstalled
+    ),
+    joined: arrivals.filter(({ rows }) => rows.length > 0).map(asJoined)
+  };
+}
+function asJoined({ agentName, rows }) {
+  return { agentName, skillIds: rows.map(([, row]) => row.id) };
+}
+function arrivingRows(stated, installed, skippedSkillIds) {
+  const alreadyLoaded = new Set(rowIds(installed));
+  const filled = filledExclusiveCategories(installed);
+  const arrives = (category, row) => !skippedSkillIds.has(row.id) && !alreadyLoaded.has(row.id) && !filled.has(category);
+  return rowsWhere(stated, arrives);
+}
+function rowIds(agentStack) {
+  return typedValues(agentStack ?? {}).flatMap(
+    (rows) => rows.map((row) => row.id)
+  );
+}
+function filledExclusiveCategories(agentStack) {
+  const isExclusive = (category) => matrix.categories[category]?.exclusive === true;
+  return new Set(
+    typedEntries(agentStack ?? {}).filter(([category, rows]) => rows.length > 0 && isExclusive(category)).map(([category]) => category)
+  );
+}
+function withAppendedRows(stack, agentName, added) {
+  if (added.length === 0) return stack;
+  return { ...stack, [agentName]: appendRows(stack[agentName] ?? {}, added) };
+}
+function rowsWhere(agentStack, keep) {
+  return typedEntries(agentStack ?? {}).flatMap(
+    ([category, rows]) => rows.filter((row) => keep(category, row)).map((row) => [category, row])
+  );
+}
+function appendRows(agentStack, added) {
+  return added.reduce(
+    (rows, [category, row]) => ({ ...rows, [category]: [...rows[category] ?? [], row] }),
+    agentStack
+  );
+}
+function omittedGlobal(result, installed) {
+  const namedSkillIds = new Set(result.skills.map((skill) => skill.id));
+  const namedAgentNames = new Set(result.agentConfigs.map((agent) => agent.name));
+  return {
+    skills: [...activeGlobalById(installed.skills, (skill) => skill.id).values()].filter(
+      (skill) => !namedSkillIds.has(skill.id)
+    ),
+    agents: [...activeGlobalById(installed.agents, (agent) => agent.name).values()].filter(
+      (agent) => !namedAgentNames.has(agent.name)
+    )
+  };
+}
+function withOmittedGlobal(result, installed, omitted) {
+  const omittedAgentNames = omitted.agents.map((agent) => agent.name);
+  return {
+    ...result,
+    skills: [...result.skills, ...omitted.skills],
+    agentConfigs: [...result.agentConfigs, ...omitted.agents],
+    selectedAgents: [.../* @__PURE__ */ new Set([...result.selectedAgents, ...omittedAgentNames])],
+    selectedDomains: withKeptDomains(result.selectedDomains, omitted.skills),
+    assignedStack: withInstalledRows(result.assignedStack, installed.stack, omittedAgentNames)
+  };
+}
+function notInstalledGlobally(entries, held) {
+  const installed = new Set(held.installed.skillIds);
+  return entries.filter((entry) => !installed.has(entry.id));
+}
+function arrivalsByScope(skills, agents) {
+  return {
+    project: entriesActiveAt(skills, agents, "project"),
+    global: entriesActiveAt(skills, agents, "global")
+  };
+}
+function entriesActiveAt(skills, agents, scope) {
+  return {
+    skillIds: skills.filter((skill) => isActiveAt(skill, scope)).map((skill) => skill.id),
+    agentNames: agents.filter((agent) => isActiveAt(agent, scope)).map((agent) => agent.name)
+  };
+}
+function installArrivals(held) {
+  const installedSkillIds = new Set(held.installed.skillIds);
+  const installedAgentNames = new Set(held.installed.agentNames);
+  return arrivalsByScope(
+    held.result.skills.filter((skill) => !installedSkillIds.has(skill.id)),
+    held.result.agentConfigs.filter((agent) => !installedAgentNames.has(agent.name))
+  );
+}
+function installPlanLines(held) {
+  return [
+    ...arrivalLines(installArrivals(held)),
+    ...scopeLines(SHARED_CONFIG_ARRIVALS.SKIPPED_HEADING, skippedAsInstalled(held)),
+    ...joinedStatement(held)
+  ];
+}
+function skippedAsInstalled({ installed, joined }) {
+  const joinedNames = new Set(joined.map(({ agentName }) => agentName));
+  return {
+    skillIds: installed.skillIds,
+    agentNames: installed.agentNames.filter((name) => !joinedNames.has(name))
+  };
+}
+function joinedStatement(held) {
+  return held.joined.length === 0 ? [] : [addedToGlobalSubAgents(held.joined)];
+}
+function skillLabel(skillId) {
+  const displayName = getSkillDisplayName(skillId);
+  return displayName === skillId ? skillId : `${displayName} (${skillId})`;
+}
+function arrivalLines(arrivals) {
+  return [
+    ...scopeLines(SHARED_CONFIG_ARRIVALS.PROJECT_HEADING, arrivals.project),
+    ...scopeLines(SHARED_CONFIG_ARRIVALS.GLOBAL_HEADING, arrivals.global)
+  ];
+}
+function scopeLines(heading, entries) {
+  const groups = [
+    { label: SHARED_CONFIG_APPLY.SKILLS_HEADING, items: entries.skillIds.map(skillLabel) },
+    { label: SHARED_CONFIG_APPLY.AGENTS_HEADING, items: entries.agentNames }
+  ].filter((group) => group.items.length > 0);
+  if (groups.length === 0) return [];
+  return [
+    heading,
+    ...groups.flatMap((group) => [`  ${group.label}`, ...group.items.map((item) => `    ${item}`)])
+  ];
+}
+function projectScopedContent(result) {
+  return entriesActiveAt(result.skills, result.agentConfigs, "project");
+}
+function installsAtHome(result) {
+  const { skillIds, agentNames } = projectScopedContent(result);
+  return skillIds.length === 0 && agentNames.length === 0;
+}
+function skippedWithTheirSkills(skipped, selectedAgents) {
+  const selected = new Set(selectedAgents);
+  return skipped.flatMap(({ skillId, agentNames }) => {
+    const left = agentNames.filter((name) => !selected.has(name));
+    return left.length === 0 ? [] : [{ skillId, agentNames: left }];
+  });
+}
+
+// src/cli/base-command.ts
+import { Command } from "@oclif/core";
+import chalk from "chalk";
+import { unique } from "remeda";
+
+// src/cli/lib/operations/source/ensure-marketplace.ts
+async function ensureMarketplace(sourceResult, host) {
+  const marketplace = await resolveMarketplaceName(sourceResult);
+  if (marketplace === null) return { marketplace: null, registered: false };
+  const exists = await host.marketplaceExists(marketplace);
+  if (!exists) {
+    const marketplaceSource = sourceResult.sourceConfig.source.replace(/^github:/, "");
+    await host.addMarketplace(marketplaceSource);
+    return { marketplace, registered: true };
+  }
+  try {
+    await host.refreshMarketplace(marketplace);
+  } catch {
+    warn("Could not update marketplace \u2014 continuing with cached version");
+  }
+  return { marketplace, registered: false };
+}
+async function resolveMarketplaceName(sourceResult) {
+  if (sourceResult.marketplace) return sourceResult.marketplace;
+  const source = sourceResult.sourceConfig.source;
+  try {
+    const marketplaceResult = await fetchMarketplace(source);
+    sourceResult.marketplace = marketplaceResult.marketplace.name;
+    return sourceResult.marketplace;
+  } catch (error) {
+    warn(`Could not resolve a marketplace from '${source}': ${getErrorMessage(error)}`);
+    return null;
+  }
+}
+
+// src/cli/lib/operations/source/require-marketplace.ts
+async function requireMarketplace(sourceResult, purpose, host) {
+  const mpResult = await ensureMarketplace(sourceResult, host);
+  if (!mpResult.marketplace) {
+    return {
+      ok: false,
+      error: `Cannot ${purpose}: marketplace could not be resolved from '${sourceResult.sourceConfig.source}'. Plugin install mode requires a marketplace \u2014 fix the marketplace or switch the affected skills to eject mode.`
+    };
+  }
+  return { ok: true, marketplace: mpResult.marketplace, registered: mpResult.registered };
+}
+
+// src/cli/lib/operations/skills/install-plugin-skills.ts
+function pluginInstallFailureError(failedCount) {
+  return `Failed to install ${failedCount} plugin skill(s). Plugin install intent could not be honored. Verify the skill id matches the marketplace, run '${CLI_INVOKE_COMMAND} update' to refresh the marketplace, or switch affected skills to eject mode.`;
+}
+function unbackedPluginSkillIds(skills, matrix2) {
+  return skills.filter((skill) => skill.origin !== EJECT_SOURCE).filter((skill) => isLocalOnlySkill(matrix2.skills[skill.id])).map((skill) => skill.id);
+}
+function unbackedPluginInstallError(ids) {
+  return `Cannot install ${ids.length} skill(s) as plugins \u2014 no marketplace carries them: ${ids.join(", ")}. A skill that exists only in this project can only be installed as a local copy. Set its Install mode to eject in the editor, or publish it to a marketplace first.`;
+}
+async function installPluginSkills(skills, marketplace, projectDir) {
+  const host = hostAt(projectDir);
+  const pluginSkills = skills.filter((s) => s.origin !== EJECT_SOURCE);
+  const installed = [];
+  const failed = [];
+  for (const skill of pluginSkills) {
+    const pluginRef = buildMarketplacePluginRef(skill.id, marketplace);
+    try {
+      await host.installPlugin(pluginRef, skill.scope, projectDir);
+      installed.push({ id: skill.id, ref: pluginRef });
+    } catch (error) {
+      failed.push({ id: skill.id, error: getErrorMessage(error) });
+    }
+  }
+  return { installed, failed };
+}
+
+// src/cli/base-command.ts
+var TERMINAL_RESIZE_POLL_MS = 500;
+var terminalColumns = () => process.stdout.columns ?? MIN_TERMINAL_SIZE.COLS;
+var terminalRows = () => process.stdout.rows ?? MIN_TERMINAL_SIZE.ROWS;
+function isTerminalBigEnough() {
+  return isTerminalLargeEnough(terminalColumns(), terminalRows());
+}
+function waitForTerminal(isSatisfied) {
+  return new Promise((resolve) => {
+    const check = () => {
+      if (!isSatisfied()) return;
+      clearInterval(interval);
+      process.stdout.off("resize", check);
+      resolve();
+    };
+    const interval = setInterval(check, TERMINAL_RESIZE_POLL_MS);
+    process.stdout.on("resize", check);
+  });
+}
+function findUnassignedSkills(config, selected) {
+  const assignedIds = new Set(config.stack ? getStackSkillIds(config.stack) : []);
+  const selectedIds = new Set(selected.map((skill) => skill.id));
+  const globalAgentNames = config.agents.filter((agent) => isActiveAt(agent, "global")).map((agent) => agent.name);
+  const unassignedIds = unique(
+    config.skills.filter((skill) => !skill.excluded && selectedIds.has(skill.id)).map((skill) => skill.id).filter((skillId) => !assignedIds.has(skillId))
+  );
+  return unassignedIds.map((skillId) => ({
+    skillId,
+    blockedBy: hasActiveProjectEntry(config.skills, skillId) ? globalAgentNames : []
+  }));
+}
+function hasActiveProjectEntry(skills, skillId) {
+  return skills.some((skill) => skill.id === skillId && isActiveAt(skill, "project"));
+}
+var BaseCommand = class extends Command {
+  /** Non-empty decides the exit code; see {@link exitIfWorkIncomplete}. */
+  incompleteWork = [];
+  async init() {
+    await super.init();
+    await this.ensureTerminalSize();
+  }
+  async ensureTerminalSize() {
+    if (isTerminalBigEnough()) return;
+    clearTerminalScreen();
+    this.log(chalk.hex(CLI_COLORS.WARNING)(formatTerminalTooSmallMessage(terminalColumns())));
+    await waitForTerminal(isTerminalBigEnough);
+  }
+  handleError(error) {
+    const message = getErrorMessage(error);
+    this.error(message, { exit: EXIT_CODES.ERROR });
+  }
+  /**
+   * Degrades on an unreadable config: `doctor` and `uninstall` must survive one, and a heading is
+   * not worth refusing over. The command's own config reader reports the cause.
+   */
+  async resolveBrandingName(projectDir) {
+    try {
+      const branding = await resolveBranding(projectDir);
+      return branding.name;
+    } catch (error) {
+      verbose(`Could not read branding from the config: ${getErrorMessage(error)}`);
+      return DEFAULT_BRANDING.NAME;
+    }
+  }
+  logSuccess(message) {
+    this.log(`\u2713 ${message}`);
+  }
+  /** `onRegistered` fires only when the marketplace had to be registered. */
+  async requireMarketplaceOrExit(sourceResult, purpose, host, onRegistered) {
+    const required = await requireMarketplace(sourceResult, purpose, host);
+    if (!required.ok) {
+      this.error(required.error, { exit: EXIT_CODES.ERROR });
+    }
+    if (required.registered) {
+      onRegistered?.(required.marketplace);
+    }
+    return required.marketplace;
+  }
+  /** Advisory: the selection installs either way. A message can quote a payload's own ids. */
+  reportValidationErrors(validation) {
+    for (const error of validation.errors) {
+      this.warn(stripTerminalControls(error.message));
+    }
+  }
+  /** Refuses skills no marketplace carries before the host's CLI is asked. */
+  async installPluginSkillsReported(skills, marketplace, projectDir, matrix2) {
+    const unbacked = unbackedPluginSkillIds(skills, matrix2);
+    if (unbacked.length > 0) {
+      this.error(unbackedPluginInstallError(unbacked), { exit: EXIT_CODES.ERROR });
+    }
+    this.announcePluginInstall();
+    const result = await installPluginSkills(skills, marketplace, projectDir);
+    this.reportPluginInstalls(result);
+    return result;
+  }
+  /** Split out for the eject-to-plugin migration, which runs its own installs. */
+  announcePluginInstall() {
+    this.log(STATUS_MESSAGES.INSTALLING_PLUGINS);
+  }
+  /** Hard-errors on any failure, before a config can record an origin for an uninstalled plugin. */
+  reportPluginInstalls(result) {
+    for (const item of result.installed) {
+      this.log(`  Installed ${item.ref}`);
+    }
+    for (const item of result.failed) {
+      this.warn(`Failed to install plugin ${item.id}: ${item.error}`);
+    }
+    if (result.failed.length > 0) {
+      this.error(pluginInstallFailureError(result.failed.length), { exit: EXIT_CODES.ERROR });
+    }
+    this.log(`${pluginsInstalled(result.installed.length)}
+`);
+  }
+  reportFanOut(report) {
+    for (const projectPath of report.propagated.unreadable) {
+      this.warn(registeredProjectConfigUnreadable(projectPath));
+    }
+    this.reportPropagatedRecompile(report);
+  }
+  reportProjectsOutOfReach(propagated) {
+    for (const projectPath of propagated.gone) {
+      this.warn(registeredProjectGone(projectPath));
+    }
+    for (const projectPath of propagated.notOurs) {
+      this.warn(registeredProjectOnAnotherProvider(projectPath));
+    }
+  }
+  reportPropagatedRecompile(report) {
+    if (report.propagated.updated.length === 0) return;
+    const { rewrittenCount, unchangedCount, failedCount, warnings } = report.recompile;
+    for (const warning of warnings) {
+      this.warn(warning);
+    }
+    this.log(propagatedRecompileSummary(rewrittenCount, unchangedCount, failedCount));
+  }
+  reportUnassignedSkills(config, selected) {
+    for (const { skillId, blockedBy } of findUnassignedSkills(config, selected)) {
+      this.warn(skillAssignedToNoAgent(skillId));
+      if (blockedBy.length > 0) {
+        this.warn(scopeBlockedStackAssignment(blockedBy, skillId));
+      }
+    }
+  }
+  /**
+   * Aborts up front when the project or global config exists but cannot be loaded, so nothing is
+   * installed before the config write fails. A missing config passes.
+   */
+  async ensureConfigReadable(projectDir) {
+    const failures = await findConfigLoadFailures(projectDir);
+    if (failures.length > 0) {
+      this.error(installationConfigsUnreadable(failures), { exit: EXIT_CODES.ERROR });
+    }
+  }
+  /** Only entries the catalogue lacks are checked; one whose files are gone is not refused. */
+  async ensureSavedSkillsReadable(savedSkills, matrix2, projectDir) {
+    const unresolved = savedSkills.filter((saved) => !matrix2.skills[saved.id]);
+    await this.refuseUnusableSavedSkillMetadata(
+      unresolved,
+      projectDir,
+      savedSkillMetadataUnusableError
+    );
+  }
+  async refuseUnusableSavedSkillMetadata(savedSkills, projectDir, refusal) {
+    const unusable = await findUnusableSavedSkillMetadata(savedSkills, projectDir);
+    if (unusable.length === 0) return;
+    for (const entry of unusable) {
+      this.log(skillMetadataUnusableDetail(entry));
+    }
+    this.error(refusal(unusable), { exit: EXIT_CODES.ERROR });
+  }
+  /**
+   * The home directory is the global scope, so project-scoped content there would land in the
+   * global config mislabelled. Needs the decoded selection; callers run it before any write.
+   */
+  refuseProjectScopedContentAtHome(result, projectDir) {
+    if (!isHomeDirectory(projectDir) || installsAtHome(result)) return;
+    const { skillIds, agentNames } = projectScopedContent(result);
+    this.error(sharedConfigProjectScopeAtHome(skillIds, agentNames), { exit: EXIT_CODES.ERROR });
+  }
+  /** Measured against the selection after its restores, so a sub-agent kept is not named skipped. */
+  warnOfSkippedEntries(mapping, selectedAgents) {
+    const { skippedSkillIds, skippedAgentNames, agentsOnlySkippedSkillsCarried } = mapping;
+    const skippedWith = skippedWithTheirSkills(agentsOnlySkippedSkillsCarried, selectedAgents);
+    if (skippedSkillIds.length > 0) this.warn(skippedUnknownSkills(skippedSkillIds, skippedWith));
+    if (skippedAgentNames.length > 0) this.warn(skippedUnknownAgents(skippedAgentNames));
+  }
+  /** The `--from` refusals that need the decoded selection, asked before the confirm. */
+  async refuseSharedConfigBeforeAsking(selection, carried, root, sourceResult) {
+    this.refuseUnofferablePlacementsBeforeWriting(selection.skills, root);
+    try {
+      await refuseUnofferedStack(selection.selectedStackId, sourceResult);
+      await refuseUncarriedDestinations(carried);
+      refuseUnwritableStack(selection.assignedStack, sourceResult.matrix);
+    } catch (error) {
+      this.handleError(error);
+    }
+  }
+  /**
+   * Pre-flight over every row, ejected included: the per-plugin guard in `installPlugin` fires
+   * mid-loop, after earlier plugins are already installed.
+   */
+  refuseUnofferablePlacementsBeforeWriting(skills, root) {
+    try {
+      refuseUnofferedPlacements(skills, hostAt(root));
+    } catch (error) {
+      this.error(getErrorMessage(error), { exit: EXIT_CODES.ERROR });
+    }
+  }
+  get hasIncompleteWork() {
+    return this.incompleteWork.length > 0;
+  }
+  /** Never aborts: every caller is past a mutation that has already landed. */
+  reportIncompleteWork(what, recovery) {
+    this.warn(what);
+    this.recordIncompleteWork(what, recovery);
+  }
+  /** For a caller that has already warned. */
+  recordIncompleteWork(what, recovery) {
+    this.incompleteWork.push({ what, recovery });
+  }
+  /** Every command that records must call this; `this.exit` skips the `Error:` framing. */
+  exitIfWorkIncomplete() {
+    if (!this.hasIncompleteWork) return;
+    this.log(`
+${chalk.hex(CLI_COLORS.WARNING)(completedWithFailures(this.incompleteWork))}
+`);
+    this.exit(EXIT_CODES.COMPLETED_WITH_FAILURES);
+  }
+};
+
+export {
+  clearTerminalScreen,
+  EXIT_CODES,
+  registerExternalSkills,
+  writeExternalSkills,
+  carriedSkillsThatDiffer,
+  readCarriedSkills,
+  reconcileSharedConfig,
+  withUnplaceableAssignees,
+  readInstalledGlobal,
+  holdInstalledGlobal,
+  restoreInstalledGlobal,
+  sameAssignments,
+  notInstalledGlobally,
+  arrivalsByScope,
+  installPlanLines,
+  joinedStatement,
+  skillLabel,
+  arrivalLines,
+  installsAtHome,
+  BaseCommand
+};
+//# sourceMappingURL=chunk-GEMW5RQ2.js.map