agents-inc 0.153.0 → 0.155.0

package/CHANGELOG.md

@@ -7,6 +7,71 @@ Each release has detailed notes in its own file under [`changelogs/`](./changelo
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.155.0] - 2026-08-18
+
+**The editor and the CLI share one configuration**
+
+- **Breaking:** `--source`/`-s` is now `--marketplace`/`-m`, the old spelling rejected rather than aliased, and `CC_SOURCE` is now `CC_MARKETPLACE` (CLI-463)
+- **Breaking:** the config fields say what they hold — `marketplace` to `marketplaceName`, `source` to `marketplace`, `SkillConfig.source` to `origin`; an older `config.ts` is a hard error naming the pairs that moved (CLI-501)
+- `share` and `edit --ui` mint a shared id from the installation in the current directory (CLI-354)
+- `edit --from <id>` applies a configuration built in the editor, destructively and interactively (CLI-462)
+- External skills install: a skill in neither catalogue travels in the payload as content (CLI-507)
+- The round trip leaves what it does not own alone — a skill nobody installed is neither carried nor removed (CLI-508)
+- Carry-back closes the loop, so a shared configuration survives more than one lap (CLI-509)
+- The stale-id refusal names the remedy instead of a cause it cannot observe (CLI-510)
+- `new marketplace` returns, and what it scaffolds works end to end (CLI-454)
+- `build marketplace` emits the `catalog.json` the editor fetches (CLI-504)
+- A locally authored skill installs (CLI-407), keeps its identity through the install (CLI-408), and one writer answers the custom question (CLI-409), completing the install half of custom skill support (D-212)
+- A compiled agent says who compiled it — legs 2 and 3 (CLI-470)
+- Two marketplaces can no longer name one skill: ids are namespaced by their marketplace (CLI-498)
+- `catalog.json` becomes deterministic (CLI-411), carries what the editor needs (CLI-412) and is emitted from one place (CLI-413)
+- One broken skill no longer blinds `doctor` — each skill is judged on its own (CLI-475)
+- A global install refuses project-scoped content at the boundary (D-310)
+- A global skill is removable from a project, with the user's informed consent (CLI-519)
+- Three validators that judged the wrong subject: a parse boundary that reads as guarded (CLI-503), `doctor` judging a shared directory as if it owned it (CLI-505), and one more found in the same pass (CLI-513)
+- The second producer stops re-costing its skips (CLI-511) and stops inheriting the first's refusals (CLI-512)
+- The `FILES` enumeration is complete, and so are five others beside it (CLI-506)
+- The unowned-install row stops claiming agent files `uninstall` refuses (CLI-515)
+- The global split stops carrying the whole stack when no global agent survives (CLI-516)
+- The two screens agree (CLI-517), and they agree on agents (CLI-522)
+- The fan-out line counts projects reached, not rewrites (CLI-518)
+- The removal reporting says what it did (CLI-521)
+- The narrowing probe cannot be fooled by a syntax error (CLI-525), and the page is now checked (CLI-526)
+- The harness stops handing the binary its own environment (CLI-523) and spawns it clean (CLI-524)
+- The plugin suite stops writing into the machine that runs it (CLI-514)
+- Journey 7's arc is actually run, and journey 9 closed with it (CLI-527)
+- The gate that declined to judge, silently, now reports what it skipped (CLI-528)
+- Prose that asserted behaviour the code no longer had (CLI-530), and a documented gap filled a day earlier (CLI-533)
+- The enumeration-drift checker, filed five times in eighteen days, is finally built (CLI-531)
+- The smoke files are finally run by something (CLI-520)
+- Three of the four escape shapes are judgement and one is a selector (CLI-529), and the vacuous-comparison rules reach every workspace (CLI-532)
+
+See [changelogs/0.155.0.md](./changelogs/0.155.0.md) for full details.
+
+## [0.154.0] - 2026-08-10
+
+**The wizard stops reaching through the lock**
+
+- A skill's `metadata.yaml` category now reaches the marketplace it is published to, so `build marketplace` stops reporting every plugin as uncategorized (CLI-481)
+- A skill that reaches no sub-agent says so, at both the wizard and `compile` (CLI-491)
+- Generated files order themselves, so a re-emit is a fixed point and an unchanged agent stops being rewritten (CLI-478)
+- The Sources step's bulk install-mode hotkeys are withdrawn: in a project edit they rewrote inherited global rows the per-row toggle deliberately cannot reach, and really installed plugins (CLI-479)
+- Project configurations carry the project's own name (CLI-482)
+- Uninstall promises exactly what it removes — one plan, rendered and executed (CLI-494)
+- One operation owns removing sub-agents and tidying their directory (CLI-495)
+- The removal plan is honest when the configuration cannot be read: the compiled agents are named as kept, and why (CLI-470)
+- Emptied `.claude/skills/` and `.claude/agents/` are removed, and a project-only install stops pre-creating an empty global agents directory (CLI-480)
+- A sub-agent moved from global to project scope keeps its skill catalogue — it was silently shrinking from seven skills to four (CLI-483)
+- `list` counts the plugin skills a project owns, instead of reporting `Skills: 0` from a project directory (CLI-484)
+- `init` names the configuration that actually holds the agent-skill assignments (CLI-485)
+- A refusal no longer paints over a live loading spinner (CLI-486)
+- A moved source is downloaded once per run, not once per load — a full duplicate tarball for `github:` sources (CLI-487)
+- The home root stops calling the global configuration a project one, in `compile`, `edit` and `doctor` (CLI-488)
+- The plugin-to-eject direction of a mode switch reports the copies it made (CLI-489)
+- `search` names the skill and the source it found, in the columns whose headers claim them (CLI-490)
+
+See [changelogs/0.154.0.md](./changelogs/0.154.0.md) for full details.
+
 ## [0.153.0] - 2026-08-09
 
 **One marketplace at a time**

package/dist/chunk-2H7UWE2G.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+import {
+  SEED_API_URL,
+  SEED_USER_AGENT,
+  readCarriedSkills
+} from "./chunk-PMUABBPG.js";
+import {
+  ERROR_MESSAGES,
+  MATRIX_VERSION,
+  SEED_VERSION,
+  isScopePairCompatible,
+  loadProjectConfig,
+  readForkedFromMetadata,
+  resolveInstallPaths,
+  seedModelSchema,
+  seedPayloadSchema
+} from "./chunk-WCAUUBHO.js";
+import {
+  directoryExists,
+  getErrorMessage
+} from "./chunk-XAXJWXI4.js";
+import {
+  typedEntries,
+  typedValues
+} from "./chunk-VASLW636.js";
+import {
+  DEFAULT_PUBLIC_SOURCE_NAME,
+  EJECT_SOURCE
+} from "./chunk-IO5YBKHV.js";
+
+// src/cli/lib/seed/installation-payload.ts
+import path from "path";
+
+// src/cli/lib/seed/config-to-seed.ts
+function isInstalled(entry) {
+  return !entry.excluded;
+}
+function needsMarketplaceNamed(origin) {
+  return origin !== EJECT_SOURCE && origin !== DEFAULT_PUBLIC_SOURCE_NAME;
+}
+function isSeedModel(model) {
+  return seedModelSchema.safeParse(model).success;
+}
+function seedLoadState(preloaded) {
+  return preloaded === true ? "preloaded" : "lazy";
+}
+function unnameableOriginMessage(skill) {
+  return `${skill.id} comes from the marketplace '${skill.origin}', and this installation does not record where that marketplace is fetched from`;
+}
+function unnameableModelMessage(agent, model) {
+  return `${agent} pins model '${model}', which this contract has no word for \u2014 leaving it out would say "keep the sub-agent's own metadata", which is a different instruction`;
+}
+function unwritablePairMessage(skillId, agent) {
+  return `${skillId} -> ${agent}: a project-scoped skill never reaches a sub-agent that rests at global scope`;
+}
+function unshareableConfigError(unshareable) {
+  return [
+    "This installation cannot be shared as it stands \u2014 a shared configuration has no way to carry:",
+    ...unshareable.map((line) => `  ${line}`),
+    "Sharing it anyway would mint an id that installs something else."
+  ].join("\n");
+}
+function isRecordedMarketplace(config, skill) {
+  return config.marketplace !== void 0 && skill.origin === config.marketplaceName;
+}
+function readMarketplace(config, skills) {
+  const served = skills.filter((skill) => needsMarketplaceNamed(skill.origin));
+  if (served.length === 0) return { ref: void 0, unnameable: [] };
+  const unaccounted = served.filter((skill) => !isRecordedMarketplace(config, skill));
+  if (unaccounted.length > 0) {
+    return { ref: void 0, unnameable: unaccounted.map(unnameableOriginMessage) };
+  }
+  return { ref: config.marketplace, unnameable: [] };
+}
+function unnameableModels(agents) {
+  return agents.flatMap(
+    (agent) => agent.model !== void 0 && !isSeedModel(agent.model) ? [unnameableModelMessage(agent.name, agent.model)] : []
+  );
+}
+function readStack(stack, skillScopes, agentScopes) {
+  const assignments = /* @__PURE__ */ new Map();
+  const unwritable = [];
+  for (const [agent, agentStack] of typedEntries(stack ?? {})) {
+    const agentScope = agentScopes.get(agent);
+    if (agentScope === void 0) continue;
+    for (const categoryAssignments of typedValues(agentStack)) {
+      for (const { id, preloaded } of categoryAssignments) {
+        const skillScope = skillScopes.get(id);
+        if (skillScope === void 0) continue;
+        if (!isScopePairCompatible(skillScope, agentScope)) {
+          unwritable.push(unwritablePairMessage(id, agent));
+          continue;
+        }
+        const forSkill = assignments.get(id) ?? {};
+        forSkill[agent] = seedLoadState(preloaded);
+        assignments.set(id, forSkill);
+      }
+    }
+  }
+  return { assignments, unwritable };
+}
+function toSeedSkill(skill, assignments) {
+  return {
+    // "eject" is the project's own copy; anything else is a plugin the marketplace serves, and
+    // which marketplace that is has already had to be one the envelope's ref accounts for.
+    install: skill.origin === EJECT_SOURCE ? "eject" : "plugin",
+    scope: skill.scope,
+    assignments: assignments ?? {}
+  };
+}
+function toSeedAgent(agent) {
+  return {
+    on: true,
+    scope: agent.scope,
+    ...agent.model !== void 0 && isSeedModel(agent.model) && { model: agent.model },
+    ...agent.effort !== void 0 && { effort: agent.effort }
+  };
+}
+function configToSeedPayload(config, carried) {
+  const skills = config.skills.filter(isInstalled);
+  const agents = config.agents.filter(isInstalled);
+  const skillScopes = new Map(skills.map((skill) => [skill.id, skill.scope]));
+  const agentScopes = new Map(agents.map((agent) => [agent.name, agent.scope]));
+  const { assignments, unwritable } = readStack(config.stack, skillScopes, agentScopes);
+  const marketplace = readMarketplace(config, skills);
+  const unshareable = [
+    ...marketplace.unnameable,
+    ...unnameableModels(agents),
+    ...unwritable,
+    ...carried.uncarryable
+  ];
+  if (unshareable.length > 0) throw new Error(unshareableConfigError(unshareable));
+  return seedPayloadSchema.parse({
+    v: SEED_VERSION,
+    matrixVersion: MATRIX_VERSION,
+    stackId: null,
+    ...marketplace.ref !== void 0 && { marketplace: marketplace.ref },
+    skills: Object.fromEntries(
+      skills.map((skill) => [skill.id, toSeedSkill(skill, assignments.get(skill.id))])
+    ),
+    // Absent rather than empty, for the reason the marketplace ref is: an id is the hash of its
+    // body, so a key meaning what its absence already means would remint every ordinary payload.
+    ...Object.keys(carried.external).length > 0 && { external: carried.external },
+    agents: Object.fromEntries(agents.map((agent) => [agent.name, toSeedAgent(agent)]))
+  });
+}
+
+// src/cli/lib/seed/installation-payload.ts
+async function seedPayloadForInstallation(projectDir) {
+  const installed = await readInstalledConfig(projectDir);
+  if (!installed.ok) return installed;
+  const mapped = mapOrRefuse(await readRoundTrip(installed.config, projectDir));
+  if (!mapped.ok) return mapped;
+  const { payload } = mapped;
+  const skills = Object.keys(payload.skills).length;
+  const agents = Object.keys(payload.agents).length;
+  if (skills === 0 && agents === 0) return { ok: false, error: ERROR_MESSAGES.NO_INSTALLATION };
+  return { ok: true, payload, skills, agents };
+}
+async function readInstalledConfig(projectDir) {
+  try {
+    const loaded = await loadProjectConfig(projectDir);
+    if (!loaded) return { ok: false, error: ERROR_MESSAGES.NO_INSTALLATION };
+    return { ok: true, config: loaded.config };
+  } catch (error) {
+    return { ok: false, error: getErrorMessage(error) };
+  }
+}
+async function readRoundTrip(config, projectDir) {
+  const owned = (await judgeSkills(config, projectDir)).filter((entry) => entry.owned);
+  return {
+    config: { ...config, skills: owned.map((entry) => entry.skill) },
+    content: await readCarriedSkills(owned.flatMap((entry) => entry.carried ?? []))
+  };
+}
+function judgeSkills(config, projectDir) {
+  return Promise.all(config.skills.map((skill) => judgeSkill(skill, projectDir)));
+}
+async function skillsAuthoredHere(config, projectDir) {
+  const judged = await judgeSkills(config, projectDir);
+  return new Set(judged.filter((entry) => !entry.owned).map((entry) => entry.skill.id));
+}
+function travelsAsAnId(skill) {
+  return { skill, owned: true, carried: null };
+}
+async function judgeSkill(skill, projectDir) {
+  if (skill.origin !== EJECT_SOURCE) return travelsAsAnId(skill);
+  if (!isInstalled(skill)) return travelsAsAnId(skill);
+  const skillsDir = resolveInstallPaths(projectDir, skill.scope).skillsDir;
+  const skillDir = path.join(skillsDir, skill.id);
+  if (!await directoryExists(skillDir)) return travelsAsAnId(skill);
+  const provenance = await readForkedFromMetadata(skillDir);
+  if (provenance === null) return { skill, owned: false, carried: null };
+  return { skill, owned: true, carried: { id: skill.id, skillDir, provenance } };
+}
+function mapOrRefuse({ config, content }) {
+  try {
+    return { ok: true, payload: configToSeedPayload(config, content) };
+  } catch (error) {
+    return { ok: false, error: getErrorMessage(error) };
+  }
+}
+
+// src/cli/lib/seed/publish-seed.ts
+import { z } from "zod";
+var mintedSchema = z.object({ id: z.string().min(1) });
+async function publishSeedConfig(payload) {
+  const url = `${SEED_API_URL}/configs`;
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: {
+        accept: "application/json",
+        "content-type": "application/json",
+        // The same signal the fetch half sends: it is the only thing that tells the store a
+        // configuration came from the CLI rather than from a browser.
+        "user-agent": SEED_USER_AGENT
+      },
+      body: JSON.stringify(payload)
+    });
+  } catch {
+    return { ok: false, error: `Could not reach ${SEED_API_URL} \u2014 check your connection.` };
+  }
+  if (!response.ok) {
+    return { ok: false, error: `Sharing this configuration failed (HTTP ${response.status}).` };
+  }
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return { ok: false, error: "The configuration store returned something that is not JSON." };
+  }
+  const minted = mintedSchema.safeParse(body);
+  if (!minted.success) {
+    return { ok: false, error: "The configuration store did not return an id for this share." };
+  }
+  return { ok: true, id: minted.data.id };
+}
+
+export {
+  seedPayloadForInstallation,
+  skillsAuthoredHere,
+  publishSeedConfig
+};
+//# sourceMappingURL=chunk-2H7UWE2G.js.map

package/dist/chunk-2H7UWE2G.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli/lib/seed/installation-payload.ts","../src/cli/lib/seed/config-to-seed.ts","../src/cli/lib/seed/publish-seed.ts"],"sourcesContent":["import path from \"path\";\n\nimport { configToSeedPayload, isInstalled } from \"./config-to-seed.js\";\nimport { readCarriedSkills } from \"./external-skills.js\";\nimport { EJECT_SOURCE } from \"../../consts.js\";\nimport { loadProjectConfig } from \"../configuration/project-config.js\";\nimport { resolveInstallPaths } from \"../installation/install-base-dir.js\";\nimport { readForkedFromMetadata } from \"../skills/skill-metadata.js\";\nimport { getErrorMessage } from \"../../utils/errors.js\";\nimport { directoryExists } from \"../../utils/fs.js\";\nimport { ERROR_MESSAGES } from \"../../utils/messages.js\";\n\nimport type { ContentReading, OwnedSkillDir } from \"./external-skills.js\";\nimport type { ProjectConfig, SkillConfig, SkillId } from \"../../types/index.js\";\nimport type { SeedPayload } from \"@workspace/matrix/seed\";\n\n/**\n * A payload ready to post, and what it will install — counted the way the sharer's own screens\n * count it, off the payload rather than off the config, so what a caller announces and what it\n * posts cannot disagree.\n */\nexport type InstallationPayload =\n  { ok: true; payload: SeedPayload; skills: number; agents: number } | { ok: false; error: string };\n\n/** The config to map, or the sentence explaining why there is none to map. */\ntype InstalledConfig = { ok: true; config: ProjectConfig } | { ok: false; error: string };\n\n/** The mapped payload, or every line naming something the contract cannot carry. */\ntype MappedPayload = { ok: true; payload: SeedPayload } | { ok: false; error: string };\n\n/** The installation as the round trip sees it: what it owns, and what it has to carry with it. */\ntype RoundTrip = { config: ProjectConfig; content: ContentReading };\n\n/**\n * What the round trip makes of one installed entry: whether it travels at all, and whether its\n * bytes travel with it.\n */\ntype SkillJudgement = { skill: SkillConfig; owned: boolean; carried: OwnedSkillDir | null };\n\n/**\n * Read, map, refuse — everything that can fail locally, failing before anybody spends a write.\n *\n * Shared by the two commands that mint an id for what is installed here: `share`, which reports\n * the id, and `edit --ui`, which opens it. They are one operation with two endings, and this is\n * the half that has to be identical — two spellings of \"the installation in this directory\"\n * would mint two different ids for one project, and only one of them would be true.\n *\n * Every failure is a message rather than a throw, because nothing has been written by the time\n * it runs: the caller's only job is to explain, and both callers explain the same way.\n */\nexport async function seedPayloadForInstallation(projectDir: string): Promise<InstallationPayload> {\n  const installed = await readInstalledConfig(projectDir);\n  if (!installed.ok) return installed;\n\n  const mapped = mapOrRefuse(await readRoundTrip(installed.config, projectDir));\n  if (!mapped.ok) return mapped;\n\n  const { payload } = mapped;\n  const skills = Object.keys(payload.skills).length;\n  const agents = Object.keys(payload.agents).length;\n\n  // The same guard `init --from` applies on arrival, applied here before the write instead of\n  // there after it. A sub-agent is installable on its own — it has front-matter, a prompt and a\n  // compiled file without owning a single skill — so only a configuration with neither skills\n  // nor sub-agents is nothing to carry.\n  if (skills === 0 && agents === 0) return { ok: false, error: ERROR_MESSAGES.NO_INSTALLATION };\n\n  return { ok: true, payload, skills, agents };\n}\n\n/**\n * The installation this directory has: its own configuration, or the global one it inherits.\n *\n * That is the config every other command reads here, and it carries the entries of BOTH scopes\n * with each entry's own scope on it — which is exactly what the wire keys by. So a payload minted\n * from a project describes the whole of what is installed for it rather than half of it, and the\n * receiver puts each entry back where this one had it.\n *\n * A config file that exists but cannot be loaded is a fault, not an absence, so its own message\n * is reported rather than read as \"not installed\".\n */\nasync function readInstalledConfig(projectDir: string): Promise<InstalledConfig> {\n  try {\n    const loaded = await loadProjectConfig(projectDir);\n    if (!loaded) return { ok: false, error: ERROR_MESSAGES.NO_INSTALLATION };\n    return { ok: true, config: loaded.config };\n  } catch (error) {\n    return { ok: false, error: getErrorMessage(error) };\n  }\n}\n\n/**\n * The installation minus what the round trip does not own, plus the content it has to take along.\n *\n * `forkedFrom` decides ownership, and the round trip leaves what it does not own alone. The CLI\n * stamps that key into every skill directory it writes — an ejected catalogue skill, and a skill\n * a payload carried inline — while a skill the user wrote by hand into `.claude/skills/` carries\n * none. So absence of the key is not the whole answer and provenance is: what the CLI put there\n * says so on disk, and what a person put there says nothing because nothing forked it.\n *\n * A user-authored skill is therefore neither carried nor refused — it is simply outside the\n * round trip, and nothing about leaving it home is lossy because it was never in scope. Dropping\n * it here rather than in a command is what keeps `share` and `edit --ui`, which mint an id from\n * the same directory, from disagreeing about a single project.\n *\n * The stack rows naming a dropped skill go with it: `configToSeedPayload` keys assignments by\n * the skills it carries, so a row whose skill is gone is gone too.\n *\n * One walk answers both questions, because they are asked of the same file: whether the CLI put\n * this directory here, and — for the one kind of skill no catalogue can resolve — where its bytes\n * came from, so they can travel a second time.\n */\nasync function readRoundTrip(config: ProjectConfig, projectDir: string): Promise<RoundTrip> {\n  const owned = (await judgeSkills(config, projectDir)).filter((entry) => entry.owned);\n\n  return {\n    config: { ...config, skills: owned.map((entry) => entry.skill) },\n    content: await readCarriedSkills(owned.flatMap((entry) => entry.carried ?? [])),\n  };\n}\n\n/** Every installed entry, judged. One walk of the disk, whichever half of the trip is asking. */\nfunction judgeSkills(config: ProjectConfig, projectDir: string): Promise<SkillJudgement[]> {\n  return Promise.all(config.skills.map((skill) => judgeSkill(skill, projectDir)));\n}\n\n/**\n * The installed skills the round trip does NOT own — the user's own work, sitting in\n * `.claude/skills/` with no `forkedFrom` to say the CLI put it there.\n *\n * The producer already drops these on the way out, so no payload minted here ever named one.\n * This is the same judgement read by the other half: `edit --from` applies a payload\n * destructively, and a payload that made no statement about a skill cannot be read as an\n * instruction to delete it. Both halves ask {@link judgeSkill}, so \"outside the round trip\" has\n * one definition and cannot come to mean two things on one machine.\n */\nexport async function skillsAuthoredHere(\n  config: ProjectConfig,\n  projectDir: string,\n): Promise<Set<SkillId>> {\n  const judged = await judgeSkills(config, projectDir);\n  return new Set(judged.filter((entry) => !entry.owned).map((entry) => entry.skill.id));\n}\n\n/** The entry travels and no directory is read for it: a row naming an id is the whole of it. */\nfunction travelsAsAnId(skill: SkillConfig): SkillJudgement {\n  return { skill, owned: true, carried: null };\n}\n\n/**\n * How one installed entry answers to the round trip — asked of the disk, offline, exactly as\n * `uninstall` asks it before removing anything.\n *\n * Only a directory that EXISTS and carries no provenance is somebody's own work, and that is the\n * one thing this excludes; each guard below says why the case above it never gets that far.\n */\nasync function judgeSkill(skill: SkillConfig, projectDir: string): Promise<SkillJudgement> {\n  // A marketplace skill has no local directory to hold provenance and needs none: the marketplace\n  // is what installs it again.\n  if (skill.origin !== EJECT_SOURCE) return travelsAsAnId(skill);\n  // A tombstone is a statement about something that is NOT installed here, so there are no bytes\n  // of it to carry — and a refusal raised over them would refuse a share for a skill it is not\n  // sharing.\n  if (!isInstalled(skill)) return travelsAsAnId(skill);\n\n  const skillsDir = resolveInstallPaths(projectDir, skill.scope).skillsDir;\n  const skillDir = path.join(skillsDir, skill.id);\n  // A configuration recording an install that is not there is evidence of nothing rather than\n  // evidence of authorship, so it travels as the configuration records it.\n  if (!(await directoryExists(skillDir))) return travelsAsAnId(skill);\n\n  const provenance = await readForkedFromMetadata(skillDir);\n  if (provenance === null) return { skill, owned: false, carried: null };\n\n  return { skill, owned: true, carried: { id: skill.id, skillDir, provenance } };\n}\n\n/**\n * The mapping, with its refusals turned into this module's own currency.\n *\n * `configToSeedPayload` throws, and what it throws is a list: every line names something this\n * installation has that a shared configuration cannot say. That is a message for the user, not a\n * fault to propagate — the alternative is worse than a failed command, because a payload quietly\n * missing what it could not say still mints an id, and that id installs a configuration nobody\n * chose.\n */\nfunction mapOrRefuse({ config, content }: RoundTrip): MappedPayload {\n  try {\n    return { ok: true, payload: configToSeedPayload(config, content) };\n  } catch (error) {\n    return { ok: false, error: getErrorMessage(error) };\n  }\n}\n","import { MATRIX_VERSION } from \"@workspace/matrix\";\nimport { SEED_VERSION, seedModelSchema, seedPayloadSchema } from \"@workspace/matrix/seed\";\n\nimport { DEFAULT_PUBLIC_SOURCE_NAME, EJECT_SOURCE } from \"../../consts.js\";\nimport { isScopePairCompatible } from \"../configuration/config-generator.js\";\nimport { typedEntries, typedValues } from \"../../utils/typed-object.js\";\n\nimport type { ContentReading } from \"./external-skills.js\";\nimport type {\n  AgentScopeConfig,\n  ProjectConfig,\n  SkillConfig,\n  SkillScope,\n} from \"../../types/config.js\";\nimport type { ModelName } from \"../../types/matrix.js\";\nimport type { SkillId } from \"../../types/skills.js\";\nimport type {\n  SeedAgent,\n  SeedLoadState,\n  SeedModel,\n  SeedPayload,\n  SeedSkill,\n} from \"@workspace/matrix/seed\";\n\n/** Sub-agent name -> load state for one skill: the shape the wire keys by skill. */\ntype SeedAssignments = Record<string, SeedLoadState>;\n\n/** What one walk of `config.stack` yields: the wire's assignments, and the rows that cannot be one. */\ntype StackReading = {\n  assignments: Map<SkillId, SeedAssignments>;\n  /** Pairs the config model has nowhere to write, worded for the refusal. */\n  unwritable: string[];\n};\n\n/**\n * An installed entry. An excluded one is a tombstone — a statement about something that is NOT\n * installed here — and presence is selection on the wire, so it has nothing to say. Nothing is\n * lost by leaving it home either: `init --from` installs into a clean setup, where there is no\n * global install for a tombstone to mask.\n *\n * Exported because the reader that gathers what an installation CARRIES has to agree with the\n * mapper about what it installs: content read for an entry this payload will not name is content\n * paid for by nobody, and a refusal raised over it would refuse a share for a skill it is not\n * sharing.\n */\nexport function isInstalled(entry: { excluded?: boolean }): boolean {\n  return !entry.excluded;\n}\n\n/**\n * Whether a skill from this origin obliges the payload to name a marketplace.\n *\n * Two do not. An ejected copy travels with the project, and the default public catalogue is what\n * an absent ref already means — so neither puts a ref on the wire, and two identical selections\n * cannot mint two different ids over one.\n */\nfunction needsMarketplaceNamed(origin: string): boolean {\n  return origin !== EJECT_SOURCE && origin !== DEFAULT_PUBLIC_SOURCE_NAME;\n}\n\n/**\n * Asked of the contract's own enum rather than spelled out here, so widening `MODEL_NAMES`\n * without widening the wire cannot slip past as a silently dropped pin.\n */\nfunction isSeedModel(model: ModelName): model is SeedModel {\n  return seedModelSchema.safeParse(model).success;\n}\n\n/** The wire spells as an enum what a stack entry spells as a boolean, and an absent flag is lazy. */\nfunction seedLoadState(preloaded: boolean | undefined): SeedLoadState {\n  return preloaded === true ? \"preloaded\" : \"lazy\";\n}\n\nfunction unnameableOriginMessage(skill: SkillConfig): string {\n  return `${skill.id} comes from the marketplace '${skill.origin}', and this installation does not record where that marketplace is fetched from`;\n}\n\nfunction unnameableModelMessage(agent: AgentScopeConfig[\"name\"], model: ModelName): string {\n  return `${agent} pins model '${model}', which this contract has no word for — leaving it out would say \"keep the sub-agent's own metadata\", which is a different instruction`;\n}\n\nfunction unwritablePairMessage(skillId: SkillId, agent: string): string {\n  return `${skillId} -> ${agent}: a project-scoped skill never reaches a sub-agent that rests at global scope`;\n}\n\n/**\n * Names everything the contract cannot carry at once, not one thing at a time: a sharer who fixes\n * one only to be refused for the next learns nothing the first message could not have told them.\n *\n * The refusal exists because the alternative is worse than a failed command. A payload quietly\n * missing what it could not say still mints an id, and that id installs a configuration nobody\n * chose — with nothing on either side saying so.\n */\nfunction unshareableConfigError(unshareable: string[]): string {\n  return [\n    \"This installation cannot be shared as it stands — a shared configuration has no way to carry:\",\n    ...unshareable.map((line) => `  ${line}`),\n    \"Sharing it anyway would mint an id that installs something else.\",\n  ].join(\"\\n\");\n}\n\n/** The ref a payload has to carry, and the skills no ref this config holds can account for. */\ntype MarketplaceReading = {\n  /** Absent when nothing installed here came from a marketplace. */\n  ref: string | undefined;\n  unnameable: string[];\n};\n\n/**\n * Whether the marketplace this installation reads is the one `skill` came from.\n *\n * A skill's `origin` is a marketplace's NAME, `config.marketplace` is the ref it was fetched from,\n * and `marketplaceName` is what joins them — the name the install read out of that repository's\n * own manifest. Without both halves agreeing, the ref would send the receiver to a repository that\n * never served this skill, which is the same silent swap under a different spelling.\n */\nfunction isRecordedMarketplace(config: ProjectConfig, skill: SkillConfig): boolean {\n  return config.marketplace !== undefined && skill.origin === config.marketplaceName;\n}\n\n/** Which marketplace the payload names, decided by the skills that oblige it to name one. */\nfunction readMarketplace(config: ProjectConfig, skills: SkillConfig[]): MarketplaceReading {\n  const served = skills.filter((skill) => needsMarketplaceNamed(skill.origin));\n  if (served.length === 0) return { ref: undefined, unnameable: [] };\n\n  const unaccounted = served.filter((skill) => !isRecordedMarketplace(config, skill));\n  if (unaccounted.length > 0) {\n    return { ref: undefined, unnameable: unaccounted.map(unnameableOriginMessage) };\n  }\n\n  return { ref: config.marketplace, unnameable: [] };\n}\n\nfunction unnameableModels(agents: AgentScopeConfig[]): string[] {\n  return agents.flatMap((agent) =>\n    agent.model !== undefined && !isSeedModel(agent.model)\n      ? [unnameableModelMessage(agent.name, agent.model)]\n      : [],\n  );\n}\n\n/**\n * Turns `config.stack` inside out: it is keyed by sub-agent and this contract is keyed by skill.\n *\n * Rows naming a sub-agent or a skill this configuration does not install are dropped rather than\n * refused, because they are already no part of what is installed — `compile` warns about exactly\n * those and leaves them out of the agents it writes, so carrying them would share more than this\n * project has.\n *\n * A row the config model cannot write is the opposite case and is collected for the refusal: the\n * decoder turns the same pair away on the way back in, so minting it would produce an id that\n * cannot be installed.\n */\nfunction readStack(\n  stack: ProjectConfig[\"stack\"],\n  skillScopes: Map<SkillId, SkillScope>,\n  agentScopes: Map<string, SkillScope>,\n): StackReading {\n  const assignments = new Map<SkillId, SeedAssignments>();\n  const unwritable: string[] = [];\n\n  for (const [agent, agentStack] of typedEntries(stack ?? {})) {\n    const agentScope = agentScopes.get(agent);\n    if (agentScope === undefined) continue;\n\n    for (const categoryAssignments of typedValues(agentStack)) {\n      for (const { id, preloaded } of categoryAssignments) {\n        const skillScope = skillScopes.get(id);\n        if (skillScope === undefined) continue;\n\n        if (!isScopePairCompatible(skillScope, agentScope)) {\n          unwritable.push(unwritablePairMessage(id, agent));\n          continue;\n        }\n\n        const forSkill = assignments.get(id) ?? {};\n        forSkill[agent] = seedLoadState(preloaded);\n        assignments.set(id, forSkill);\n      }\n    }\n  }\n\n  return { assignments, unwritable };\n}\n\nfunction toSeedSkill(skill: SkillConfig, assignments: SeedAssignments | undefined): SeedSkill {\n  return {\n    // \"eject\" is the project's own copy; anything else is a plugin the marketplace serves, and\n    // which marketplace that is has already had to be one the envelope's ref accounts for.\n    install: skill.origin === EJECT_SOURCE ? \"eject\" : \"plugin\",\n    scope: skill.scope,\n    assignments: assignments ?? {},\n  };\n}\n\n/**\n * A sub-agent's own row, and it always says `on`.\n *\n * The web app pins `on` only where a person did, because there an agent switched on by its rows is\n * already implied by them. An installed config is not an inference — every sub-agent it names was\n * chosen and has a compiled file on disk — so saying so outright is what carries the one that owns\n * no skill, which is the only thing the agents map can do that assignments cannot.\n */\nfunction toSeedAgent(agent: AgentScopeConfig): SeedAgent {\n  return {\n    on: true,\n    scope: agent.scope,\n    ...(agent.model !== undefined && isSeedModel(agent.model) && { model: agent.model }),\n    ...(agent.effort !== undefined && { effort: agent.effort }),\n  };\n}\n\n/**\n * Turns the installation this directory records into the payload the config store holds, so the\n * CLI can mint an id rather than only consume one.\n *\n * The inverse of {@link import(\"./seed-to-wizard.js\").seedToWizardResult}, and held to it: a\n * payload minted here and decoded there has to describe the same install. That is why the scope\n * of every skill and sub-agent travels per entry rather than being implied, why the whole stack\n * is carried as per-`(skill, sub-agent)` assignments, and why nothing here leans on a wire default\n * the decoder would have to guess back.\n *\n * What it will not do is share a thinner configuration than the one installed. Anything the\n * contract cannot state is refused by name — see {@link unshareableConfigError} — because the\n * failure mode of the alternative is an id that silently installs something else.\n *\n * `stackId` is always null. A saved config records a stack's expansion and never the id it came\n * from, and the assignments above carry that expansion in full; naming an id this module invented\n * would make the receiver overlay a stack's own preload flags over the curation being shared.\n *\n * `marketplace` is the one field carried for the payload rather than for an entry, because the\n * receiver loads one catalogue before it reads a single skill row — see {@link readMarketplace}.\n *\n * `carried` arrives as an argument because it is read off disk and this mapping touches none:\n * every id above is resolved by the receiver against a catalogue it already has, and the entries\n * in `carried` are the ones that answer to no catalogue in either direction. Stated rather than\n * defaulted, because a producer that forgot the content is exactly the defect this closed.\n */\nexport function configToSeedPayload(config: ProjectConfig, carried: ContentReading): SeedPayload {\n  const skills = config.skills.filter(isInstalled);\n  const agents = config.agents.filter(isInstalled);\n  const skillScopes = new Map(skills.map((skill) => [skill.id, skill.scope]));\n  const agentScopes = new Map<string, SkillScope>(agents.map((agent) => [agent.name, agent.scope]));\n\n  const { assignments, unwritable } = readStack(config.stack, skillScopes, agentScopes);\n  const marketplace = readMarketplace(config, skills);\n\n  const unshareable = [\n    ...marketplace.unnameable,\n    ...unnameableModels(agents),\n    ...unwritable,\n    ...carried.uncarryable,\n  ];\n  if (unshareable.length > 0) throw new Error(unshareableConfigError(unshareable));\n\n  // Parsed rather than merely assembled, exactly as the web app's encoder is: it makes \"the JSON\n  // the store will hold\" literal, and it is the one gate that catches a field whose values have\n  // drifted out of the wire's enums since this module last named them.\n  return seedPayloadSchema.parse({\n    v: SEED_VERSION,\n    matrixVersion: MATRIX_VERSION,\n    stackId: null,\n    ...(marketplace.ref !== undefined && { marketplace: marketplace.ref }),\n    skills: Object.fromEntries(\n      skills.map((skill) => [skill.id, toSeedSkill(skill, assignments.get(skill.id))]),\n    ),\n    // Absent rather than empty, for the reason the marketplace ref is: an id is the hash of its\n    // body, so a key meaning what its absence already means would remint every ordinary payload.\n    ...(Object.keys(carried.external).length > 0 && { external: carried.external }),\n    agents: Object.fromEntries(agents.map((agent) => [agent.name, toSeedAgent(agent)])),\n  });\n}\n","import { z } from \"zod\";\n\nimport { SEED_API_URL, SEED_USER_AGENT } from \"./fetch-seed.js\";\n\nimport type { SeedPayload } from \"@workspace/matrix/seed\";\n\n/**\n * The store answers a stored configuration with its content-addressed id and nothing else.\n * Revalidated rather than read off the response type, because that type describes the worker this\n * CLI was built against and what answers is whatever is deployed.\n */\nconst mintedSchema = z.object({ id: z.string().min(1) });\n\nexport type PublishSeedResult = { ok: true; id: string } | { ok: false; error: string };\n\n/**\n * Stores a configuration and returns the id it was given.\n *\n * The outbound half of the boundary {@link import(\"./fetch-seed.js\").fetchSeedConfig} owns the\n * inbound half of, and it keeps the same posture: every failure is a message rather than a throw.\n * Nothing local has been written by the time this runs, so there is nothing to roll back and the\n * caller's only job is to explain.\n *\n * The id is the payload's own hash, so re-sharing an unchanged configuration returns the id it\n * had — the store spends no write, and a caller can share as often as it likes.\n */\nexport async function publishSeedConfig(payload: SeedPayload): Promise<PublishSeedResult> {\n  const url = `${SEED_API_URL}/configs`;\n\n  let response: Response;\n  try {\n    response = await fetch(url, {\n      method: \"POST\",\n      headers: {\n        accept: \"application/json\",\n        \"content-type\": \"application/json\",\n        // The same signal the fetch half sends: it is the only thing that tells the store a\n        // configuration came from the CLI rather than from a browser.\n        \"user-agent\": SEED_USER_AGENT,\n      },\n      body: JSON.stringify(payload),\n    });\n  } catch {\n    return { ok: false, error: `Could not reach ${SEED_API_URL} — check your connection.` };\n  }\n\n  if (!response.ok) {\n    return { ok: false, error: `Sharing this configuration failed (HTTP ${response.status}).` };\n  }\n\n  let body: unknown;\n  try {\n    body = await response.json();\n  } catch {\n    return { ok: false, error: \"The configuration store returned something that is not JSON.\" };\n  }\n\n  const minted = mintedSchema.safeParse(body);\n  if (!minted.success) {\n    // Reporting success here would print an id nobody can install and tell the user to use it.\n    return { ok: false, error: \"The configuration store did not return an id for this share.\" };\n  }\n\n  return { ok: true, id: minted.data.id };\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-ZNDLUWWD.js → chunk-4A4L3YIW.js}

@@ -6,16 +6,16 @@ import {
   HOTKEY_TOGGLE_LABELS,
   KEY_SPACE,
   isHotkey
-} from "./chunk-2HC2SNRP.js";
+} from "./chunk-WTJ3AY33.js";
 import {
   useSectionScroll
-} from "./chunk-Q5FLW4JG.js";
+} from "./chunk-OKH64JZE.js";
 import {
   getSkillById
-} from "./chunk-35VOK7XE.js";
+} from "./chunk-RWOYPOMR.js";
 import {
   CLI_COLORS
-} from "./chunk-R54KIGN2.js";
+} from "./chunk-IO5YBKHV.js";
 
 // src/cli/components/wizard/category-grid.tsx
 import { useCallback as useCallback2, useEffect as useEffect2 } from "react";
@@ -266,4 +266,4 @@ var CategoryGrid = ({
 export {
   CategoryGrid
 };
-//# sourceMappingURL=chunk-ZNDLUWWD.js.map
+//# sourceMappingURL=chunk-4A4L3YIW.js.map

package/dist/chunk-4G2YHZIM.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+import {
+  readPluginManifest
+} from "./chunk-WCAUUBHO.js";
+import {
+  ensureDir,
+  glob,
+  verbose,
+  warn,
+  writeFile
+} from "./chunk-XAXJWXI4.js";
+import {
+  DEFAULT_PUBLIC_SOURCE_NAME,
+  DEFAULT_VERSION,
+  PLUGIN_MANIFEST_DIR,
+  PLUGIN_MANIFEST_FILE,
+  PUBLIC_CATALOGUE_PACKAGE
+} from "./chunk-IO5YBKHV.js";
+
+// src/cli/lib/marketplace-generator.ts
+import path from "path";
+import { countBy, sortBy } from "remeda";
+var PLUGIN_MANIFEST_PATH = `${PLUGIN_MANIFEST_DIR}/${PLUGIN_MANIFEST_FILE}`;
+var MARKETPLACE_SCHEMA_URL = "https://anthropic.com/claude-code/marketplace.schema.json";
+var EXTERNAL_SKILL_NAMESPACE = "external";
+var LOCAL_SKILL_NAMESPACE = "local";
+var RESERVED_MARKETPLACE_NAMES = [
+  DEFAULT_PUBLIC_SOURCE_NAME,
+  EXTERNAL_SKILL_NAMESPACE,
+  LOCAL_SKILL_NAMESPACE
+];
+var MAX_REPORTED_NAMESPACE_VIOLATIONS = 10;
+function convertManifestToMarketplacePlugin(manifest, pluginRoot, pluginDirName) {
+  return {
+    name: manifest.name,
+    source: `./${pluginRoot}/${pluginDirName}`,
+    ...manifest.description !== void 0 && { description: manifest.description },
+    ...manifest.version !== void 0 && { version: manifest.version },
+    ...manifest.author !== void 0 && { author: manifest.author },
+    ...manifest.category !== void 0 && { category: manifest.category },
+    ...manifest.keywords !== void 0 && { keywords: manifest.keywords }
+  };
+}
+async function generateMarketplace(pluginsDir, options) {
+  verbose(`Scanning plugins directory: ${pluginsDir}`);
+  const manifestFiles = await glob(`**/${PLUGIN_MANIFEST_PATH}`, pluginsDir);
+  verbose(`Found ${manifestFiles.length} plugin manifests`);
+  const plugins = [];
+  for (const manifestFile of manifestFiles) {
+    const separator = manifestFile.indexOf("/");
+    const pluginDirName = separator === -1 ? manifestFile : manifestFile.slice(0, separator);
+    const pluginDir = path.join(pluginsDir, pluginDirName);
+    const manifest = await readPluginManifest(pluginDir);
+    if (!manifest) {
+      warn(`Could not read plugin manifest: '${manifestFile}'`);
+      continue;
+    }
+    const plugin = convertManifestToMarketplacePlugin(
+      manifest,
+      options.pluginRoot.replace(/^\.\//, ""),
+      pluginDirName
+    );
+    plugins.push(plugin);
+    verbose(`  [OK] ${plugin.name}`);
+  }
+  const sortedPlugins = sortBy(plugins, (p) => p.name);
+  return {
+    $schema: MARKETPLACE_SCHEMA_URL,
+    name: options.name,
+    version: options.version ?? DEFAULT_VERSION,
+    owner: {
+      name: options.ownerName,
+      ...options.ownerEmail ? { email: options.ownerEmail } : {}
+    },
+    metadata: {
+      pluginRoot: options.pluginRoot
+    },
+    plugins: sortedPlugins,
+    ...options.description ? { description: options.description } : {}
+  };
+}
+function validateMarketplaceName(marketplaceName, packageName) {
+  if (!RESERVED_MARKETPLACE_NAMES.includes(marketplaceName)) return null;
+  if (isCatalogueOwnReservedName(marketplaceName, packageName)) return null;
+  return reservedNameError(marketplaceName);
+}
+function validateSkillIdNamespace(marketplace) {
+  if (marketplace.name === DEFAULT_PUBLIC_SOURCE_NAME) return null;
+  const foreignIds = marketplace.plugins.filter((plugin) => !carriesNamespace(plugin.name, marketplace.name)).map((plugin) => plugin.name);
+  if (foreignIds.length === 0) return null;
+  return namespaceViolationError(foreignIds, marketplace.name);
+}
+function isCatalogueOwnReservedName(marketplaceName, packageName) {
+  return marketplaceName === DEFAULT_PUBLIC_SOURCE_NAME && packageName === PUBLIC_CATALOGUE_PACKAGE;
+}
+function carriesNamespace(skillId, marketplaceName) {
+  return skillId.startsWith(`${marketplaceName}-`);
+}
+function reservedNameError(marketplaceName) {
+  return `Marketplace name '${marketplaceName}' is reserved. '${DEFAULT_PUBLIC_SOURCE_NAME}' is the public catalogue's own namespace, and '${EXTERNAL_SKILL_NAMESPACE}' and '${LOCAL_SKILL_NAMESPACE}' hold the skills that belong to no marketplace \u2014 publishing under any of them claims skill ids that are not this marketplace's. Choose a name of your own: set package.json 'name', or pass --name.`;
+}
+function namespaceViolationError(foreignIds, marketplaceName) {
+  const listed = foreignIds.slice(0, MAX_REPORTED_NAMESPACE_VIOLATIONS).map((id) => `  ${id} -> ${marketplaceName}-${id}`);
+  const unlisted = foreignIds.length - listed.length;
+  return [
+    `Marketplace '${marketplaceName}' ships ${foreignIds.length} skill id(s) outside its own namespace. Every skill id must begin with the marketplace's name:`,
+    ...listed,
+    ...unlisted > 0 ? [`  ... and ${unlisted} more`] : [],
+    `Rename each skill directory and the id in its metadata, re-run 'build plugins', then build the marketplace again.`
+  ].join("\n");
+}
+async function writeMarketplace(outputPath, marketplace) {
+  await ensureDir(path.dirname(outputPath));
+  const content = `${JSON.stringify(marketplace, null, 2)}
+`;
+  await writeFile(outputPath, content);
+}
+function getMarketplaceStats(marketplace) {
+  return {
+    total: marketplace.plugins.length,
+    byCategory: countBy(marketplace.plugins, (p) => p.category ?? "uncategorized")
+  };
+}
+
+export {
+  generateMarketplace,
+  validateMarketplaceName,
+  validateSkillIdNamespace,
+  writeMarketplace,
+  getMarketplaceStats
+};
+//# sourceMappingURL=chunk-4G2YHZIM.js.map

package/dist/chunk-4G2YHZIM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli/lib/marketplace-generator.ts"],"sourcesContent":["import path from \"path\";\nimport { countBy, sortBy } from \"remeda\";\n\nimport {\n  DEFAULT_PUBLIC_SOURCE_NAME,\n  DEFAULT_VERSION,\n  PLUGIN_MANIFEST_DIR,\n  PLUGIN_MANIFEST_FILE,\n  PUBLIC_CATALOGUE_PACKAGE,\n} from \"../consts\";\nimport { writeFile, glob, ensureDir } from \"../utils/fs\";\nimport { verbose, warn } from \"../utils/logger\";\nimport type { Marketplace, MarketplacePlugin, PluginManifest } from \"../types\";\nimport { readPluginManifest } from \"./plugins\";\n\nconst PLUGIN_MANIFEST_PATH = `${PLUGIN_MANIFEST_DIR}/${PLUGIN_MANIFEST_FILE}`;\nconst MARKETPLACE_SCHEMA_URL = \"https://anthropic.com/claude-code/marketplace.schema.json\";\n\n/** Namespace a skill with no marketplace at all is given. */\nconst EXTERNAL_SKILL_NAMESPACE = \"external\";\n\n/** Namespace a skill created in place, rather than fetched from a marketplace, is given. */\nconst LOCAL_SKILL_NAMESPACE = \"local\";\n\n/**\n * Marketplace names that are not an author's to take.\n *\n * The public catalogue's skills ship unprefixed, so every bare id in the catalogue\n * already lives in `agents-inc`; the other two hold the skills that belong to no\n * marketplace. Publishing under any of them claims ids the marketplace does not own.\n */\nconst RESERVED_MARKETPLACE_NAMES: readonly string[] = [\n  DEFAULT_PUBLIC_SOURCE_NAME,\n  EXTERNAL_SKILL_NAMESPACE,\n  LOCAL_SKILL_NAMESPACE,\n];\n\n/** How many offending ids a namespace refusal lists before summarising the rest. */\nconst MAX_REPORTED_NAMESPACE_VIOLATIONS = 10;\n\ntype MarketplaceOptions = {\n  name: string;\n  version?: string;\n  description?: string;\n  ownerName: string;\n  ownerEmail?: string;\n  pluginRoot: string;\n};\n\nfunction convertManifestToMarketplacePlugin(\n  manifest: PluginManifest,\n  pluginRoot: string,\n  pluginDirName: string,\n): MarketplacePlugin {\n  return {\n    name: manifest.name,\n    source: `./${pluginRoot}/${pluginDirName}`,\n    ...(manifest.description !== undefined && { description: manifest.description }),\n    ...(manifest.version !== undefined && { version: manifest.version }),\n    ...(manifest.author !== undefined && { author: manifest.author }),\n    ...(manifest.category !== undefined && { category: manifest.category }),\n    ...(manifest.keywords !== undefined && { keywords: manifest.keywords }),\n  };\n}\n\nexport async function generateMarketplace(\n  pluginsDir: string,\n  options: MarketplaceOptions,\n): Promise<Marketplace> {\n  verbose(`Scanning plugins directory: ${pluginsDir}`);\n\n  const manifestFiles = await glob(`**/${PLUGIN_MANIFEST_PATH}`, pluginsDir);\n  verbose(`Found ${manifestFiles.length} plugin manifests`);\n\n  const plugins: MarketplacePlugin[] = [];\n\n  for (const manifestFile of manifestFiles) {\n    const separator = manifestFile.indexOf(\"/\");\n    const pluginDirName = separator === -1 ? manifestFile : manifestFile.slice(0, separator);\n    const pluginDir = path.join(pluginsDir, pluginDirName);\n\n    const manifest = await readPluginManifest(pluginDir);\n    if (!manifest) {\n      warn(`Could not read plugin manifest: '${manifestFile}'`);\n      continue;\n    }\n\n    const plugin = convertManifestToMarketplacePlugin(\n      manifest,\n      options.pluginRoot.replace(/^\\.\\//, \"\"),\n      pluginDirName,\n    );\n    plugins.push(plugin);\n    verbose(`  [OK] ${plugin.name}`);\n  }\n\n  const sortedPlugins = sortBy(plugins, (p) => p.name);\n\n  // Field order matters: the object is serialized verbatim into marketplace.json,\n  // so conditional fields keep the same positions the previous emissions used.\n  return {\n    $schema: MARKETPLACE_SCHEMA_URL,\n    name: options.name,\n    version: options.version ?? DEFAULT_VERSION,\n    owner: {\n      name: options.ownerName,\n      ...(options.ownerEmail ? { email: options.ownerEmail } : {}),\n    },\n    metadata: {\n      pluginRoot: options.pluginRoot,\n    },\n    plugins: sortedPlugins,\n    ...(options.description ? { description: options.description } : {}),\n  };\n}\n\n/**\n * Refuses a marketplace name that belongs to a namespace the author does not own,\n * or returns null when the name is theirs to take.\n *\n * `packageName` is package.json's own `name`. It is read for one purpose: the public\n * catalogue publishes under a reserved name legitimately, and\n * {@link PUBLIC_CATALOGUE_PACKAGE} is what distinguishes it from a claimant.\n */\nexport function validateMarketplaceName(\n  marketplaceName: string,\n  packageName: string,\n): string | null {\n  if (!RESERVED_MARKETPLACE_NAMES.includes(marketplaceName)) return null;\n  if (isCatalogueOwnReservedName(marketplaceName, packageName)) return null;\n\n  return reservedNameError(marketplaceName);\n}\n\n/**\n * Refuses a marketplace whose skill ids fall outside its own namespace, or returns\n * null when every id carries it.\n *\n * The public catalogue is exempt: its skills ship unprefixed by design and\n * `agents-inc` IS the namespace they occupy. Reading that exemption off the NAME is\n * only safe because {@link validateMarketplaceName} runs first and lets nothing but\n * the catalogue's own package hold it — the two checks are a pair, in that order.\n */\nexport function validateSkillIdNamespace(marketplace: Marketplace): string | null {\n  if (marketplace.name === DEFAULT_PUBLIC_SOURCE_NAME) return null;\n\n  const foreignIds = marketplace.plugins\n    .filter((plugin) => !carriesNamespace(plugin.name, marketplace.name))\n    .map((plugin) => plugin.name);\n\n  if (foreignIds.length === 0) return null;\n\n  return namespaceViolationError(foreignIds, marketplace.name);\n}\n\n/**\n * Whether the reserved NAME this build publishes under is the catalogue's own, which\n * takes both halves: the name claimed is the catalogue's, and the package claiming it\n * is the catalogue's package.\n *\n * The load side asks a different question of the same identity: `isPublicCatalogueCheckout`\n * in `configuration/config.ts` asks whether a DIRECTORY is a checkout of that repository,\n * and reads the package name off it rather than being handed one.\n */\nfunction isCatalogueOwnReservedName(marketplaceName: string, packageName: string): boolean {\n  return marketplaceName === DEFAULT_PUBLIC_SOURCE_NAME && packageName === PUBLIC_CATALOGUE_PACKAGE;\n}\n\nfunction carriesNamespace(skillId: string, marketplaceName: string): boolean {\n  return skillId.startsWith(`${marketplaceName}-`);\n}\n\nfunction reservedNameError(marketplaceName: string): string {\n  return (\n    `Marketplace name '${marketplaceName}' is reserved. ` +\n    `'${DEFAULT_PUBLIC_SOURCE_NAME}' is the public catalogue's own namespace, and ` +\n    `'${EXTERNAL_SKILL_NAMESPACE}' and '${LOCAL_SKILL_NAMESPACE}' hold the skills that belong to ` +\n    `no marketplace — publishing under any of them claims skill ids that are not this ` +\n    `marketplace's. Choose a name of your own: set package.json 'name', or pass --name.`\n  );\n}\n\nfunction namespaceViolationError(foreignIds: string[], marketplaceName: string): string {\n  const listed = foreignIds\n    .slice(0, MAX_REPORTED_NAMESPACE_VIOLATIONS)\n    .map((id) => `  ${id} -> ${marketplaceName}-${id}`);\n  const unlisted = foreignIds.length - listed.length;\n\n  return [\n    `Marketplace '${marketplaceName}' ships ${foreignIds.length} skill id(s) outside its own ` +\n      `namespace. Every skill id must begin with the marketplace's name:`,\n    ...listed,\n    ...(unlisted > 0 ? [`  ... and ${unlisted} more`] : []),\n    `Rename each skill directory and the id in its metadata, re-run 'build plugins', then ` +\n      `build the marketplace again.`,\n  ].join(\"\\n\");\n}\n\nexport async function writeMarketplace(\n  outputPath: string,\n  marketplace: Marketplace,\n): Promise<void> {\n  await ensureDir(path.dirname(outputPath));\n  const content = `${JSON.stringify(marketplace, null, 2)}\\n`;\n  await writeFile(outputPath, content);\n}\n\nexport function getMarketplaceStats(marketplace: Marketplace): {\n  total: number;\n  byCategory: Record<string, number>;\n} {\n  return {\n    total: marketplace.plugins.length,\n    byCategory: countBy(marketplace.plugins, (p) => p.category ?? \"uncategorized\"),\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-WDAO3RUY.js → chunk-5F2YR5XV.js}

@@ -4,11 +4,11 @@ import {
 } from "./chunk-TSIU7DME.js";
 import {
   CategoryGrid
-} from "./chunk-ZNDLUWWD.js";
+} from "./chunk-4A4L3YIW.js";
 import {
   buildCategoriesForDomain,
   useWizardStore
-} from "./chunk-HEBPKK5L.js";
+} from "./chunk-F5T6TV4Z.js";
 
 // src/cli/components/wizard/step-build.tsx
 import { Box, useInput } from "ink";
@@ -89,4 +89,4 @@ var StepBuild = ({
 export {
   StepBuild
 };
-//# sourceMappingURL=chunk-WDAO3RUY.js.map
+//# sourceMappingURL=chunk-5F2YR5XV.js.map

package/dist/{chunk-JFAUQDZM.js → chunk-5OKLCVM4.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   isDomain
-} from "./chunk-NXQAY5U7.js";
+} from "./chunk-XAXJWXI4.js";
 import {
   findStack
-} from "./chunk-35VOK7XE.js";
+} from "./chunk-RWOYPOMR.js";
 
 // src/cli/components/wizard/utils.ts
 var DOMAIN_DISPLAY_NAMES = {
@@ -32,4 +32,4 @@ export {
   getDomainDisplayName,
   getStackName
 };
-//# sourceMappingURL=chunk-JFAUQDZM.js.map
+//# sourceMappingURL=chunk-5OKLCVM4.js.map