agents-inc 0.164.0 → 0.166.0

package/dist/chunk-V3I7VQ7N.js

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+import {
+  SHARED_CONFIG_APPLY,
+  SHARED_CONFIG_ARRIVALS,
+  execCommand,
+  getErrorMessage,
+  loadProjectConfigFromDir,
+  providerInUse
+} from "./chunk-A4KDXNOT.js";
+import {
+  getCategoryDomain,
+  getSkillDisplayName,
+  matrix,
+  typedEntries,
+  typedKeys,
+  typedValues
+} from "./chunk-V5WXIM2F.js";
+import {
+  isActiveAt,
+  orderDomains
+} from "./chunk-ENGYJCTF.js";
+
+// src/cli/lib/seed/seed-apply.ts
+import os 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)
+  };
+  if (decoded.assignedStack === void 0) return { result: withSkills, unassigned: [] };
+  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(os.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 };
+  }
+  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 = decoded.assignedStack && withHeldRows(decoded.assignedStack, installed.stack, {
+    agentNames: namedAgentNames,
+    skippedSkillIds: new Set(namedSkillIds)
+  });
+  const restatesSkill = ({ named, held }) => named.origin === held.origin;
+  const restatesAgent = ({ named, held }) => named.model === held.model && named.effort === held.effort && sameAssignments(decoded.assignedStack?.[named.name], assignedStack?.[named.name]);
+  return {
+    result: {
+      ...decoded,
+      skills: decoded.skills.map(asHeld(skills)),
+      agentConfigs: decoded.agentConfigs.map(asHeld(agents)),
+      ...assignedStack !== void 0 && { assignedStack }
+    },
+    installed: { skillIds: namedSkillIds, agentNames: namedAgentNames },
+    keptAsInstalled: {
+      skillIds: skills.filter((pair) => !restatesSkill(pair)).map(({ named }) => named.id),
+      agentNames: agents.filter((pair) => !restatesAgent(pair)).map(({ named }) => 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);
+  return held.agentNames.reduce(
+    (stack, agentName) => withAppendedRows(
+      stack,
+      agentName,
+      arrivingRows(assigned[agentName], stack[agentName], held.skippedSkillIds)
+    ),
+    asInstalled
+  );
+}
+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),
+    ...result.assignedStack !== void 0 && {
+      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) {
+  const landingAt = (scope) => ({
+    skillIds: skills.filter((skill) => isActiveAt(skill, scope)).map((skill) => skill.id),
+    agentNames: agents.filter((agent) => isActiveAt(agent, scope)).map((agent) => agent.name)
+  });
+  return { project: landingAt("project"), global: landingAt("global") };
+}
+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, {
+      skillIds: held.installed.skillIds,
+      agentNames: []
+    })
+  ];
+}
+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}`)])
+  ];
+}
+
+// src/cli/utils/open-url.ts
+function browserOpenerCommand(platform, url) {
+  if (platform === "darwin") return { command: "open", args: [url] };
+  if (platform === "win32") return { command: "cmd", args: ["/c", "start", "", url] };
+  return { command: "xdg-open", args: [url] };
+}
+function openerRefusedMessage(command, exitCode) {
+  return `Could not open your browser \u2014 '${command}' exited ${exitCode}.`;
+}
+function openerUnavailableMessage(command, reason) {
+  return `Could not open your browser \u2014 '${command}' could not be run: ${reason}`;
+}
+async function openUrl(url) {
+  const { command, args } = browserOpenerCommand(process.platform, url);
+  try {
+    const result = await execCommand(command, args);
+    if (result.exitCode !== 0) {
+      return { ok: false, error: openerRefusedMessage(command, result.exitCode) };
+    }
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, error: openerUnavailableMessage(command, getErrorMessage(error)) };
+  }
+}
+
+export {
+  reconcileSharedConfig,
+  withUnplaceableAssignees,
+  readInstalledGlobal,
+  holdInstalledGlobal,
+  restoreInstalledGlobal,
+  sameAssignments,
+  notInstalledGlobally,
+  arrivalsByScope,
+  installPlanLines,
+  skillLabel,
+  arrivalLines,
+  openUrl
+};
+//# sourceMappingURL=chunk-V3I7VQ7N.js.map

package/dist/chunk-V3I7VQ7N.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli/lib/seed/seed-apply.ts","../src/cli/utils/open-url.ts"],"sourcesContent":["import os from \"os\";\n\nimport { isDeepEqual, omit, partition, pick } from \"remeda\";\n\nimport { loadProjectConfigFromDir } from \"../configuration/project-config.js\";\nimport { isActiveAt } from \"../configuration/scope-predicates.js\";\nimport { providerInUse } from \"../installation/install-layout.js\";\nimport { getCategoryDomain, getSkillDisplayName, matrix } from \"../matrix/matrix-provider.js\";\nimport { orderDomains } from \"../wizard/domain-order.js\";\nimport { SHARED_CONFIG_APPLY, SHARED_CONFIG_ARRIVALS } from \"../../utils/messages.js\";\nimport { typedEntries, typedKeys, typedValues } from \"../../utils/typed-object.js\";\n\nimport type { WizardResultV2 } from \"../../components/wizard/wizard.js\";\nimport type { AgentName } from \"../../types/agents.js\";\nimport type {\n  AgentScopeConfig,\n  ProjectConfig,\n  SkillConfig,\n  SkillScope,\n} from \"../../types/config.js\";\nimport type { Category, Domain } from \"../../types/matrix.js\";\nimport type { SkillAssignment, SkillId } from \"../../types/skills.js\";\nimport type { StackAgentConfig } from \"../../types/stacks.js\";\nimport type { SeedPayload, SeedSkill } from \"@workspace/matrix/seed\";\n\n/**\n * What applying a shared configuration here is not allowed to take away, split by the reason —\n * because the reasons have different remedies and only the user knows which they meant.\n */\nexport type KeptFromRoundTrip = {\n  /** Written here rather than installed, so no shared configuration ever carried them. */\n  authoredSkillIds: SkillId[];\n  /** Named by the configuration and unplaceable by this catalogue, so nothing here applied. */\n  unplaceableSkillIds: SkillId[];\n};\n\n/**\n * A kept skill's installed row that the payload's own skill displaced: the category holds one\n * skill, and the payload fills it on that sub-agent. The skill stays installed; the row goes.\n */\nexport type UnassignedRow = { skillId: SkillId; agentName: AgentName; category: Category };\n\nexport type ReconciledSharedConfig = {\n  /** The decoded payload with everything above put back into it. */\n  result: WizardResultV2;\n  kept: KeptFromRoundTrip;\n  /** The kept skills' rows left out, each because the payload's own skill takes its slot. */\n  unassigned: UnassignedRow[];\n};\n\nexport type ReconcileOptions = {\n  /** The payload as `seedToWizardResult` decoded it. */\n  decoded: WizardResultV2;\n  /** This directory's installation — its own config, or the global one it inherits. */\n  installed: ProjectConfig | null;\n  /** Ids outside the round trip, from `skillsAuthoredHere` — one definition, both halves. */\n  authoredHere: ReadonlySet<SkillId>;\n  /**\n   * Ids the payload NAMED that the decode could not place — `SeedMapping.skippedSkillIds`,\n   * which is why they are ids off the wire rather than `SkillId`s of this catalogue.\n   *\n   * Stated by the caller rather than recomputed here: the decode already answered it, and a\n   * second derivation could disagree with the skips the same run reported.\n   */\n  unplaceable: ReadonlySet<string>;\n};\n\nconst NOTHING_KEPT: KeptFromRoundTrip = {\n  authoredSkillIds: [],\n  unplaceableSkillIds: [],\n};\n\n/**\n * Puts back what this run may not remove, so the destructive apply removes only what it may.\n *\n * `edit --from` makes the project MATCH the payload: a skill the previous configuration\n * installed and this one omits is removed. Two kinds of installed entry are outside that\n * authority, and each is outside it for its own reason.\n *\n * A skill written here, because `forkedFrom` decides ownership and the producer drops a\n * directory carrying none: the payload never named it, so reading its absence as an instruction\n * to delete it would be this command inventing an instruction nobody gave. And an id the payload\n * DID name that this catalogue could not place, because there the instruction exists and the run\n * failed to carry it out — a destructive command removes on intent, never on its own inability.\n *\n * Scope is the third reason, and it is answered apart, by {@link restoreInstalledGlobal}: from a\n * project the global install is not this run's to remove from or change at all, so it is put back\n * whole rather than entry by entry, and nothing about it is a disclosure of something kept.\n *\n * Both are put back into the RESULT rather than excused at the writer, and that is the whole\n * point of this module. `authoritativeScope` decides whether the merger preserves a config row;\n * it does not protect the files, because the removal DIFF is what drives the plugin uninstall\n * and the `deleteLocalSkill` call. An entry left in the removal set is deleted from disk\n * whatever the merger later does with its row.\n *\n * What comes back with an entry matters as much as the entry. A kept skill with no stack row is\n * installed and loaded by no sub-agent; a kept skill whose domain fell off `selectedDomains` is\n * hidden from the next wizard, deselected by not being shown, and deleted by the run after this\n * one — a removal this one promised not to make.\n */\nexport function reconcileSharedConfig(options: ReconcileOptions): ReconciledSharedConfig {\n  const { decoded, installed } = options;\n  if (!installed) return nothingToReconcile(decoded);\n\n  const keptSkills = skillsToKeep(options, installed);\n  if (keptSkills.length === 0) return nothingToReconcile(decoded);\n\n  const { result, unassigned } = withKeptEntries(decoded, installed, keptSkills);\n  return { result, kept: describeKept(options, keptSkills), unassigned };\n}\n\nfunction nothingToReconcile(decoded: WizardResultV2): ReconciledSharedConfig {\n  return { result: decoded, kept: NOTHING_KEPT, unassigned: [] };\n}\n\n/**\n * The installed skills this run has to leave alone: absent from what the payload placed here,\n * and immune to removal by authorship, or because this catalogue could not place the id the\n * payload named.\n *\n * A tombstone is neither. It is a statement about something that is NOT installed here, so\n * there are no files to protect and nothing to tell the user is staying.\n */\nfunction skillsToKeep(options: ReconcileOptions, installed: ProjectConfig): SkillConfig[] {\n  const named = new Set(options.decoded.skills.map((skill) => skill.id));\n\n  return installed.skills.filter(\n    (skill) => !skill.excluded && !named.has(skill.id) && mayNotRemove(skill, options),\n  );\n}\n\n/** Whether either reason covers this entry — the question the split below refines. */\nfunction mayNotRemove(skill: SkillConfig, options: ReconcileOptions): boolean {\n  return options.authoredHere.has(skill.id) || options.unplaceable.has(skill.id);\n}\n\ntype KeptReason = \"authored\" | \"unplaceable\";\n\nfunction describeKept(options: ReconcileOptions, keptSkills: SkillConfig[]): KeptFromRoundTrip {\n  const idsKeptFor = (reason: KeptReason): SkillId[] =>\n    keptSkills.filter((skill) => reasonKept(skill, options) === reason).map((skill) => skill.id);\n\n  return {\n    authoredSkillIds: idsKeptFor(\"authored\"),\n    unplaceableSkillIds: idsKeptFor(\"unplaceable\"),\n  };\n}\n\n/**\n * Which of the two an entry is disclosed as, where both are true — judged from the more\n * permanent claim to the less, because each statement carries its own remedy and only the one\n * that is true of the whole entry is worth naming.\n *\n * A skill nobody installed cannot be removed by any shared configuration from anywhere. An id\n * this catalogue cannot place is inert only for as long as this installation reads this\n * catalogue, so `update` is a real way out of it and nothing is a way out of the other.\n */\nfunction reasonKept(skill: SkillConfig, options: ReconcileOptions): KeptReason {\n  return options.authoredHere.has(skill.id) ? \"authored\" : \"unplaceable\";\n}\n\n/**\n * The payload, plus the entries it was never entitled to speak about — and the kept rows its own\n * skills left no room for.\n */\nfunction withKeptEntries(\n  decoded: WizardResultV2,\n  installed: ProjectConfig,\n  keptSkills: SkillConfig[],\n): Pick<ReconciledSharedConfig, \"result\" | \"unassigned\"> {\n  const withSkills: WizardResultV2 = {\n    ...decoded,\n    skills: [...decoded.skills, ...keptSkills],\n    selectedDomains: withKeptDomains(decoded.selectedDomains, keptSkills),\n  };\n  if (decoded.assignedStack === undefined) return { result: withSkills, unassigned: [] };\n\n  const { assignedStack, unassigned } = withKeptStackRows(decoded.assignedStack, installed.stack, {\n    keptSkillIds: new Set(keptSkills.map((skill) => skill.id)),\n    survivingAgents: new Set(decoded.selectedAgents),\n  });\n  return { result: { ...withSkills, assignedStack }, unassigned };\n}\n\n/** The domains the payload chose, plus the ones its kept entries still need a tab for. */\nfunction withKeptDomains(selected: Domain[], keptSkills: SkillConfig[]): Domain[] {\n  const keptDomains = keptSkills.flatMap((skill) => domainOfSkill(skill.id) ?? []);\n  const missing = keptDomains.filter((domain) => !selected.includes(domain));\n  if (missing.length === 0) return selected;\n\n  return orderDomains([...selected, ...new Set(missing)]);\n}\n\n/**\n * A kept skill's domain, where this catalogue knows the skill. Optional by nature rather than by\n * caution: a config entry the loaded source cannot resolve has no category to place, and\n * `edit`'s own unresolvable-entry path is what speaks about those.\n */\nfunction domainOfSkill(skillId: SkillId): Domain | undefined {\n  const category = matrix.skills[skillId]?.category;\n  return category === undefined ? undefined : getCategoryDomain(category);\n}\n\ntype KeptRowFilter = {\n  keptSkillIds: ReadonlySet<SkillId>;\n  survivingAgents: ReadonlySet<AgentName>;\n};\n\n/** The payload's stack with the kept rows folded in, and the kept rows it had no room for. */\ntype KeptRows = {\n  assignedStack: Partial<Record<AgentName, StackAgentConfig>>;\n  unassigned: UnassignedRow[];\n};\n\n/**\n * The installed stack rows a kept skill needs, folded into the payload's own.\n *\n * `assignedStack` REPLACES the ownership-derived stack rather than merging with it, so a row\n * this reconcile does not carry is a row nothing downstream re-derives. A kept skill is kept\n * because the payload never spoke about it, and a row naming it is the same silence one layer\n * down — so the row the installation already had is the only statement there is about it.\n *\n * A row under a sub-agent this configuration removes is dropped with it. That sub-agent IS this\n * run's to remove, and a stack row naming one no configuration installs is what `compile` warns\n * about and leaves out of the agents it writes.\n *\n * A kept row JOINS the payload's rows under its category rather than replacing them: the payload\n * may assign a skill of its own to the same category of the same sub-agent, and a replaced array\n * leaves that skill installed and loaded by no sub-agent. Except where the category holds one\n * skill and the payload already fills it: the two cannot both be written there, so the payload's\n * skill takes the slot — the same rule {@link arrivingRows} keeps for a global sub-agent — and the\n * kept row is handed back as unassigned for the plan to name.\n */\nfunction withKeptStackRows(\n  assigned: Partial<Record<AgentName, StackAgentConfig>>,\n  installedStack: Partial<Record<AgentName, StackAgentConfig>> | undefined,\n  filter: KeptRowFilter,\n): KeptRows {\n  const isKept = (_category: Category, row: SkillAssignment): boolean =>\n    filter.keptSkillIds.has(row.id);\n\n  return typedEntries<AgentName, StackAgentConfig>(installedStack ?? {})\n    .filter(([agent]) => filter.survivingAgents.has(agent))\n    .reduce<KeptRows>(\n      (carried, [agent, agentStack]) =>\n        withAgentKeptRows(carried, agent, rowsWhere(agentStack, isKept), assigned[agent]),\n      { assignedStack: assigned, unassigned: [] },\n    );\n}\n\n/**\n * One sub-agent's kept rows, folded in: each joins the payload's rows under its category, unless\n * that category holds one skill the payload already gives this sub-agent.\n */\nfunction withAgentKeptRows(\n  carried: KeptRows,\n  agent: AgentName,\n  keptRows: [Category, SkillAssignment][],\n  payloadRows: StackAgentConfig | undefined,\n): KeptRows {\n  const filled = filledExclusiveCategories(payloadRows);\n  const [displaced, joining] = partition(keptRows, ([category]) => filled.has(category));\n\n  return {\n    assignedStack: withAppendedRows(carried.assignedStack, agent, joining),\n    unassigned: [\n      ...carried.unassigned,\n      ...displaced.map(([category, row]) => ({ skillId: row.id, agentName: agent, category })),\n    ],\n  };\n}\n\n/**\n * The decode, plus each installed sub-agent the payload assigns a skill this catalogue cannot place\n * and this installation still holds — each as installed.\n *\n * The decode carries a sub-agent in by the skills it places, so one whose only skill it skipped is\n * left out, and the destructive apply would remove it. That is the removal\n * {@link reconcileSharedConfig} refuses for the skill, for the same reason: the payload named this\n * sub-agent, so its absence is this catalogue's limit rather than an instruction. Put back before\n * the reconcile, it survives it, and the reconcile carries the kept skill's rows onto it.\n */\nexport function withUnplaceableAssignees(\n  decoded: WizardResultV2,\n  installed: ProjectConfig | null,\n  payload: SeedPayload,\n  unplaceable: ReadonlySet<string>,\n): WizardResultV2 {\n  if (!installed) return decoded;\n\n  const assigned = assigneesOfHeld(payload, installed, unplaceable);\n  const selected = new Set(decoded.selectedAgents);\n  const leftOutThoughAssigned = (agent: AgentScopeConfig): boolean =>\n    !agent.excluded && assigned.has(agent.name) && !selected.has(agent.name);\n\n  const assignees = installed.agents.filter(leftOutThoughAssigned);\n  if (assignees.length === 0) return decoded;\n\n  return {\n    ...decoded,\n    selectedAgents: [...decoded.selectedAgents, ...assignees.map((agent) => agent.name)],\n    agentConfigs: [...decoded.agentConfigs, ...assignees],\n  };\n}\n\n/**\n * The sub-agents the payload assigns an unplaceable skill the installation holds, less any it\n * switches off — whose rows the decode ignores even for a skill it places.\n */\nfunction assigneesOfHeld(\n  payload: SeedPayload,\n  installed: ProjectConfig,\n  unplaceable: ReadonlySet<string>,\n): Set<string> {\n  const held = new Set<string>(\n    installed.skills.filter((skill) => !skill.excluded).map((skill) => skill.id),\n  );\n  const isHeldUnplaceable = ([id]: [string, SeedSkill]): boolean =>\n    unplaceable.has(id) && held.has(id);\n  const isNotSwitchedOff = (name: string): boolean => payload.agents[name]?.on !== false;\n\n  return new Set(\n    typedEntries<string, SeedSkill>(payload.skills)\n      .filter(isHeldUnplaceable)\n      .flatMap(([, skill]) => typedKeys<string>(skill.assignments))\n      .filter(isNotSwitchedOff),\n  );\n}\n\n/** The parts of the global installation's config a project run must leave as they are. */\nexport type InstalledGlobal = Pick<ProjectConfig, \"skills\" | \"agents\" | \"stack\">;\n\n/**\n * The global installation a run in `projectDir` inherits, as its own config states it — or `null`\n * when there is none.\n *\n * Read from the global config rather than from the rows a project's own file inlines: the global\n * config is what the gate writes and what every other registered project inherits, and an inlined\n * copy can be older than it. Through the project's own provider, because a project inherits only\n * from the global installation of its provider. Called only from a project — at the home directory\n * the run IS the global installation, and there is nothing to leave alone.\n */\nexport async function readInstalledGlobal(projectDir: string): Promise<InstalledGlobal | null> {\n  const loaded = await loadProjectConfigFromDir(os.homedir(), providerInUse(projectDir));\n  return loaded?.config ?? null;\n}\n\n/** Global entries a configuration names, by what a project run does with each. */\ntype GlobalEntries = { skillIds: SkillId[]; agentNames: AgentName[] };\n\n/** What a run from a project does with the global install above it: adds to it, and nothing else. */\nexport type HeldGlobal = {\n  /** The configuration, with every global entry the global install holds stated as it holds it. */\n  result: WizardResultV2;\n  /**\n   * The global entries the configuration names that the global install already holds. Its skills\n   * are skipped — neither installed nor given a row — and listed as skipped.\n   */\n  installed: GlobalEntries;\n  /**\n   * Of those, the ones the configuration states otherwise — a skill's install mode, a sub-agent's\n   * tuning, or rows other than the ones it ends up with — disclosed as kept as installed. From\n   * {@link restoreInstalledGlobal}, also every global skill and sub-agent the configuration leaves\n   * out.\n   */\n  keptAsInstalled: GlobalEntries;\n};\n\nconst NO_GLOBAL_ENTRIES: GlobalEntries = { skillIds: [], agentNames: [] };\n\n/**\n * Restates every global entry the configuration names that the global install already holds, as\n * the global install holds it: the skill's install mode, the sub-agent's tuning, and the rows\n * that sub-agent already has.\n *\n * From a project, `--from` only ADDS to the global install (owner ruling 2026-10-02). It is one\n * installation every project on the machine reads, and a run started in one of them is not a\n * decision about the rest — so an entry it already holds is not this run's to reinstall, retune or\n * reassign, however the configuration states it. Restated in the RESULT rather than excused at\n * the writer, for the reason {@link reconcileSharedConfig} gives: the result is what the diff, the\n * install steps and the writer all read, so an entry left as the payload stated it is one of them\n * acting on it.\n *\n * What the global install lacks arrives whole, and a skill's assignment is part of it: a new\n * global skill assigned to a global sub-agent the global install already holds adds its row to\n * that sub-agent, beside the rows it has (owner ruling, later on 2026-10-02). A skill the global\n * install already holds is skipped outright, so it brings no row with it either.\n *\n * `installed` is `null` where there is nothing to hold: at the home directory, where the run IS\n * the global install, and on a machine with none.\n */\nexport function holdInstalledGlobal(\n  decoded: WizardResultV2,\n  installed: InstalledGlobal | null,\n): HeldGlobal {\n  if (!installed) {\n    return { result: decoded, installed: NO_GLOBAL_ENTRIES, keptAsInstalled: NO_GLOBAL_ENTRIES };\n  }\n\n  const heldSkills = activeGlobalById(installed.skills, (skill) => skill.id);\n  const heldAgents = activeGlobalById(installed.agents, (agent) => agent.name);\n  const skills = pairWithHeld(decoded.skills, heldSkills, (skill) => skill.id);\n  const agents = pairWithHeld(decoded.agentConfigs, heldAgents, (agent) => agent.name);\n  const namedSkillIds = skills.map(({ named }) => named.id);\n  const namedAgentNames = agents.map(({ named }) => named.name);\n  const assignedStack =\n    decoded.assignedStack &&\n    withHeldRows(decoded.assignedStack, installed.stack, {\n      agentNames: namedAgentNames,\n      skippedSkillIds: new Set(namedSkillIds),\n    });\n\n  const restatesSkill = ({ named, held }: Held<SkillConfig>): boolean =>\n    named.origin === held.origin;\n  const restatesAgent = ({ named, held }: Held<AgentScopeConfig>): boolean =>\n    named.model === held.model &&\n    named.effort === held.effort &&\n    sameAssignments(decoded.assignedStack?.[named.name], assignedStack?.[named.name]);\n\n  return {\n    result: {\n      ...decoded,\n      skills: decoded.skills.map(asHeld(skills)),\n      agentConfigs: decoded.agentConfigs.map(asHeld(agents)),\n      ...(assignedStack !== undefined && { assignedStack }),\n    },\n    installed: { skillIds: namedSkillIds, agentNames: namedAgentNames },\n    keptAsInstalled: {\n      skillIds: skills.filter((pair) => !restatesSkill(pair)).map(({ named }) => named.id),\n      agentNames: agents.filter((pair) => !restatesAgent(pair)).map(({ named }) => named.name),\n    },\n  };\n}\n\n/**\n * {@link holdInstalledGlobal}, plus every global entry the configuration leaves out, put back as\n * installed — what `edit --from` needs from a project.\n *\n * That apply is destructive: an installed entry absent from the result is removed, files and\n * all. The project's own entries are its to remove; the global install's are not, so they are put\n * back whole — skills, sub-agents and those sub-agents' rows — and the removal plan never holds\n * one. A global skill or sub-agent put back is one the configuration leaves out, so it is named as\n * kept.\n */\nexport function restoreInstalledGlobal(\n  decoded: WizardResultV2,\n  installed: InstalledGlobal | null,\n): HeldGlobal {\n  const held = holdInstalledGlobal(decoded, installed);\n  if (!installed) return held;\n\n  const omitted = omittedGlobal(held.result, installed);\n  const { skillIds, agentNames } = held.keptAsInstalled;\n  return {\n    ...held,\n    result: withOmittedGlobal(held.result, installed, omitted),\n    keptAsInstalled: {\n      skillIds: [...skillIds, ...omitted.skills.map((skill) => skill.id)],\n      agentNames: [...agentNames, ...omitted.agents.map((agent) => agent.name)],\n    },\n  };\n}\n\n/** A config roster's active global entries, by the key the result names them with. */\nfunction activeGlobalById<Entry extends SkillConfig | AgentScopeConfig, Key extends string>(\n  entries: Entry[],\n  keyOf: (entry: Entry) => Key,\n): Map<Key, Entry> {\n  return new Map(\n    entries.filter((entry) => isActiveAt(entry, \"global\")).map((entry) => [keyOf(entry), entry]),\n  );\n}\n\n/** A decoded global entry, beside the entry the global install already holds under its name. */\ntype Held<Entry> = { named: Entry; held: Entry };\n\n/** Each decoded entry as the global install holds it, where it names one; otherwise unchanged. */\nfunction asHeld<Entry>(pairs: Held<Entry>[]): (entry: Entry) => Entry {\n  const heldFor = new Map(pairs.map(({ named, held }) => [named, held]));\n  return (entry) => heldFor.get(entry) ?? entry;\n}\n\n/** The decoded entries that name, at global scope, one the global install already holds. */\nfunction pairWithHeld<Entry extends SkillConfig | AgentScopeConfig, Key extends string>(\n  decoded: Entry[],\n  heldByKey: ReadonlyMap<Key, Entry>,\n  keyOf: (entry: Entry) => Key,\n): Held<Entry>[] {\n  return decoded.flatMap((named) => {\n    const held = heldByKey.get(keyOf(named));\n    return held !== undefined && isActiveAt(named, \"global\") ? [{ named, held }] : [];\n  });\n}\n\n/**\n * Whether two sub-agent stacks hold the same skills under the same categories at the same load\n * state — the order rows were written in is not part of what a sub-agent loads.\n */\nexport function sameAssignments(\n  left: StackAgentConfig | undefined,\n  right: StackAgentConfig | undefined,\n): boolean {\n  return isDeepEqual(assignmentKeys(left), assignmentKeys(right));\n}\n\n/** One stack's rows as comparable strings, in a fixed order. */\nfunction assignmentKeys(agentStack: StackAgentConfig | undefined): string[] {\n  return typedEntries<Category, SkillAssignment[]>(agentStack ?? {})\n    .flatMap(([category, assignments]) =>\n      assignments.map((row) => `${category}/${row.id}/${row.preloaded === true}`),\n    )\n    .sort();\n}\n\n/**\n * The payload's stack, with each named sub-agent's rows replaced by the ones it is installed\n * with — none, where the global install gives it none.\n */\nfunction withInstalledRows(\n  assigned: Partial<Record<AgentName, StackAgentConfig>>,\n  installedStack: InstalledGlobal[\"stack\"],\n  agentNames: AgentName[],\n): Partial<Record<AgentName, StackAgentConfig>> {\n  return { ...omit(assigned, agentNames), ...pick(installedStack ?? {}, agentNames) };\n}\n\n/** The held sub-agents, and the skills whose rows stay out because the skill is skipped. */\ntype HeldRows = { agentNames: AgentName[]; skippedSkillIds: ReadonlySet<SkillId> };\n\n/**\n * {@link withInstalledRows}, plus the configuration's rows on those sub-agents for the skills the\n * global install lacks — a skill arrives together with its assignment. A row the sub-agent\n * already has stays first and as it is, so what it loads now it still loads, in the same order.\n */\nfunction withHeldRows(\n  assigned: Partial<Record<AgentName, StackAgentConfig>>,\n  installedStack: InstalledGlobal[\"stack\"],\n  held: HeldRows,\n): Partial<Record<AgentName, StackAgentConfig>> {\n  const asInstalled = withInstalledRows(assigned, installedStack, held.agentNames);\n\n  return held.agentNames.reduce(\n    (stack, agentName) =>\n      withAppendedRows(\n        stack,\n        agentName,\n        arrivingRows(assigned[agentName], stack[agentName], held.skippedSkillIds),\n      ),\n    asInstalled,\n  );\n}\n\n/**\n * The configuration's rows for one held sub-agent that bring something with them: a skill the\n * global install lacks, which that sub-agent does not already load, under a category with room for\n * it. A category that holds one skill, which the sub-agent already fills, keeps the skill it has —\n * the arriving one is installed without that row, rather than written as a second skill where the\n * config can hold only one.\n */\nfunction arrivingRows(\n  stated: StackAgentConfig | undefined,\n  installed: StackAgentConfig | undefined,\n  skippedSkillIds: ReadonlySet<SkillId>,\n): [Category, SkillAssignment][] {\n  const alreadyLoaded = new Set(rowIds(installed));\n  const filled = filledExclusiveCategories(installed);\n  const arrives = (category: Category, row: SkillAssignment): boolean =>\n    !skippedSkillIds.has(row.id) && !alreadyLoaded.has(row.id) && !filled.has(category);\n\n  return rowsWhere(stated, arrives);\n}\n\n/** One sub-agent's rows, as the skill ids they load. */\nfunction rowIds(agentStack: StackAgentConfig | undefined): SkillId[] {\n  return typedValues<Category, SkillAssignment[]>(agentStack ?? {}).flatMap((rows) =>\n    rows.map((row) => row.id),\n  );\n}\n\n/**\n * The categories this sub-agent already fills that hold one skill at most — declared so by the\n * catalogue, because a category it does not declare is not exclusive (see `propagate.ts`).\n */\nfunction filledExclusiveCategories(agentStack: StackAgentConfig | undefined): Set<Category> {\n  const isExclusive = (category: Category): boolean =>\n    matrix.categories[category]?.exclusive === true;\n\n  return new Set(\n    typedEntries<Category, SkillAssignment[]>(agentStack ?? {})\n      .filter(([category, rows]) => rows.length > 0 && isExclusive(category))\n      .map(([category]) => category),\n  );\n}\n\n/** The stack, with `added` appended to one sub-agent's rows — as it was where nothing is added. */\nfunction withAppendedRows(\n  stack: Partial<Record<AgentName, StackAgentConfig>>,\n  agentName: AgentName,\n  added: [Category, SkillAssignment][],\n): Partial<Record<AgentName, StackAgentConfig>> {\n  if (added.length === 0) return stack;\n  return { ...stack, [agentName]: appendRows(stack[agentName] ?? {}, added) };\n}\n\n/** The rows of one sub-agent's stack that pass `keep`, each beside the category it sits under. */\nfunction rowsWhere(\n  agentStack: StackAgentConfig | undefined,\n  keep: (category: Category, row: SkillAssignment) => boolean,\n): [Category, SkillAssignment][] {\n  return typedEntries<Category, SkillAssignment[]>(agentStack ?? {}).flatMap(([category, rows]) =>\n    rows\n      .filter((row) => keep(category, row))\n      .map((row): [Category, SkillAssignment] => [category, row]),\n  );\n}\n\n/** A sub-agent's stack with `added` appended, each row after those already under its category. */\nfunction appendRows(\n  agentStack: StackAgentConfig,\n  added: [Category, SkillAssignment][],\n): StackAgentConfig {\n  return added.reduce<StackAgentConfig>(\n    (rows, [category, row]) => ({ ...rows, [category]: [...(rows[category] ?? []), row] }),\n    agentStack,\n  );\n}\n\n/** The global install's active entries a result does not name. */\ntype OmittedGlobal = { skills: SkillConfig[]; agents: AgentScopeConfig[] };\n\nfunction omittedGlobal(result: WizardResultV2, installed: InstalledGlobal): OmittedGlobal {\n  const namedSkillIds = new Set(result.skills.map((skill) => skill.id));\n  const namedAgentNames = new Set(result.agentConfigs.map((agent) => agent.name));\n\n  return {\n    skills: [...activeGlobalById(installed.skills, (skill) => skill.id).values()].filter(\n      (skill) => !namedSkillIds.has(skill.id),\n    ),\n    agents: [...activeGlobalById(installed.agents, (agent) => agent.name).values()].filter(\n      (agent) => !namedAgentNames.has(agent.name),\n    ),\n  };\n}\n\n/** The result, plus every global entry it does not name, each as the global install holds it. */\nfunction withOmittedGlobal(\n  result: WizardResultV2,\n  installed: InstalledGlobal,\n  omitted: OmittedGlobal,\n): WizardResultV2 {\n  const omittedAgentNames = omitted.agents.map((agent) => agent.name);\n\n  return {\n    ...result,\n    skills: [...result.skills, ...omitted.skills],\n    agentConfigs: [...result.agentConfigs, ...omitted.agents],\n    selectedAgents: [...new Set([...result.selectedAgents, ...omittedAgentNames])],\n    selectedDomains: withKeptDomains(result.selectedDomains, omitted.skills),\n    ...(result.assignedStack !== undefined && {\n      assignedStack: withInstalledRows(result.assignedStack, installed.stack, omittedAgentNames),\n    }),\n  };\n}\n\n/**\n * The entries a run writes, less those the global install already holds: a carried skill's bytes\n * written over a global skill directory would change it as surely as a reinstall.\n */\nexport function notInstalledGlobally<Entry extends { id: SkillId }>(\n  entries: Entry[],\n  held: HeldGlobal,\n): Entry[] {\n  const installed = new Set(held.installed.skillIds);\n  return entries.filter((entry) => !installed.has(entry.id));\n}\n\n/** What a `--from` install puts into one scope, as its list names them. */\nexport type ArrivingEntries = { skillIds: SkillId[]; agentNames: AgentName[] };\n\n/** What a `--from` install puts where — the two lists it prints before it writes. */\nexport type Arrivals = Record<SkillScope, ArrivingEntries>;\n\n/** The active skills and sub-agents given, split by the scope each one lands at. */\nexport function arrivalsByScope(skills: SkillConfig[], agents: AgentScopeConfig[]): Arrivals {\n  const landingAt = (scope: SkillScope): ArrivingEntries => ({\n    skillIds: skills.filter((skill) => isActiveAt(skill, scope)).map((skill) => skill.id),\n    agentNames: agents.filter((agent) => isActiveAt(agent, scope)).map((agent) => agent.name),\n  });\n  return { project: landingAt(\"project\"), global: landingAt(\"global\") };\n}\n\n/**\n * Everything `init --from` installs, by scope: the whole configuration, less what the global\n * install already holds — that is not arriving anywhere.\n */\nfunction installArrivals(held: HeldGlobal): Arrivals {\n  const installedSkillIds = new Set(held.installed.skillIds);\n  const installedAgentNames = new Set(held.installed.agentNames);\n  return arrivalsByScope(\n    held.result.skills.filter((skill) => !installedSkillIds.has(skill.id)),\n    held.result.agentConfigs.filter((agent) => !installedAgentNames.has(agent.name)),\n  );\n}\n\n/**\n * What `init --from` prints before it writes: the two lists of what it installs where, then the\n * global skills it skips because the global install above the project already holds them. A\n * skipped skill is named rather than left out, so a configuration's skill that does not arrive is\n * never one the user was not told about.\n */\nexport function installPlanLines(held: HeldGlobal): string[] {\n  return [\n    ...arrivalLines(installArrivals(held)),\n    ...scopeLines(SHARED_CONFIG_ARRIVALS.SKIPPED_HEADING, {\n      skillIds: held.installed.skillIds,\n      agentNames: [],\n    }),\n  ];\n}\n\n/** How a skill reads in a shared-config plan: the name it was picked by, with the id behind it. */\nexport function skillLabel(skillId: SkillId): string {\n  const displayName = getSkillDisplayName(skillId);\n  return displayName === skillId ? skillId : `${displayName} (${skillId})`;\n}\n\n/**\n * The two lists, as printed: project first, then global, each omitted when nothing lands there,\n * and each split into skills and sub-agents under the headings the removal plan uses.\n */\nexport function arrivalLines(arrivals: Arrivals): string[] {\n  return [\n    ...scopeLines(SHARED_CONFIG_ARRIVALS.PROJECT_HEADING, arrivals.project),\n    ...scopeLines(SHARED_CONFIG_ARRIVALS.GLOBAL_HEADING, arrivals.global),\n  ];\n}\n\n/** One scope's list, or nothing when nothing lands there. */\nfunction scopeLines(heading: string, entries: ArrivingEntries): string[] {\n  const groups = [\n    { label: SHARED_CONFIG_APPLY.SKILLS_HEADING, items: entries.skillIds.map(skillLabel) },\n    { label: SHARED_CONFIG_APPLY.AGENTS_HEADING, items: entries.agentNames },\n  ].filter((group) => group.items.length > 0);\n  if (groups.length === 0) return [];\n\n  return [\n    heading,\n    ...groups.flatMap((group) => [`  ${group.label}`, ...group.items.map((item) => `    ${item}`)]),\n  ];\n}\n","import { execCommand } from \"./exec.js\";\nimport { getErrorMessage } from \"./errors.js\";\n\n/** The shell-out one platform answers \"open this with whatever handles it\" with. */\nexport type OpenerCommand = { command: string; args: string[] };\n\n/**\n * Never a throw. A machine with no browser, no desktop session or no opener at all is a\n * legitimate place to run this CLI, so failing to open a link is something to say rather than\n * something to fail on — the same posture the seed boundaries take, and for the same reason:\n * the link is already printed by the time this runs, so nothing is lost by it not working.\n */\nexport type OpenUrlResult = { ok: true } | { ok: false; error: string };\n\n/**\n * The command a platform opens a link with.\n *\n * There is no dependency for this. All three are one-line shell-outs to something the operating\n * system already ships, and a package for it would be a fourth thing to keep current for no\n * behaviour this does not have.\n *\n * Windows goes through `cmd` because `start` is a shell builtin rather than a program, and the\n * empty string after it is its TITLE argument: without one, `start` reads the first quoted\n * argument it is given as the window title and opens nothing.\n */\nexport function browserOpenerCommand(platform: NodeJS.Platform, url: string): OpenerCommand {\n  if (platform === \"darwin\") return { command: \"open\", args: [url] };\n  if (platform === \"win32\") return { command: \"cmd\", args: [\"/c\", \"start\", \"\", url] };\n  return { command: \"xdg-open\", args: [url] };\n}\n\nfunction openerRefusedMessage(command: string, exitCode: number): string {\n  return `Could not open your browser — '${command}' exited ${exitCode}.`;\n}\n\nfunction openerUnavailableMessage(command: string, reason: string): string {\n  return `Could not open your browser — '${command}' could not be run: ${reason}`;\n}\n\n/**\n * Hands a link to whatever this platform opens links with.\n *\n * The URL travels as its own argument rather than inside a command line: `execCommand` spawns\n * without a shell, so the argument vector is the whole of the injection guard — there is no\n * string for a link to break out of.\n */\nexport async function openUrl(url: string): Promise<OpenUrlResult> {\n  const { command, args } = browserOpenerCommand(process.platform, url);\n\n  try {\n    const result = await execCommand(command, args);\n    if (result.exitCode !== 0) {\n      return { ok: false, error: openerRefusedMessage(command, result.exitCode) };\n    }\n    return { ok: true };\n  } catch (error) {\n    return { ok: false, error: openerUnavailableMessage(command, getErrorMessage(error)) };\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-AVK2HEKB.js → chunk-V5WXIM2F.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   seatCatalog
-} from "./chunk-UITEKY2R.js";
+} from "./chunk-ENGYJCTF.js";
 
 // src/cli/types/generated/matrix.ts
 var BUILT_IN_MATRIX = {
@@ -9341,9 +9341,6 @@ function allSkills() {
 function getCategoryDomain(category) {
   return matrix.categories[category]?.domain;
 }
-function hasSkill(id) {
-  return id in matrix.skills;
-}
 function findStack(stackId) {
   return matrix.suggestedStacks.find((s) => s.id === stackId);
 }
@@ -9360,7 +9357,6 @@ export {
   getSkillDisplayName,
   allSkills,
   getCategoryDomain,
-  hasSkill,
   findStack
 };
-//# sourceMappingURL=chunk-AVK2HEKB.js.map
+//# sourceMappingURL=chunk-V5WXIM2F.js.map