@baselane/packs 0.1.0

package/dist/materialize-harness.d.ts

@@ -0,0 +1,15 @@
+import type { WorkflowPack } from "./types.ts";
+import { type HarnessManifest, type Resolution } from "./manifest.ts";
+export declare function sha256Hex(content: string): string;
+export interface MaterializeInput {
+    manifest: HarnessManifest;
+    resolvedPacks: Record<string, WorkflowPack>;
+    currentFiles: Record<string, string | null>;
+    resolutions?: Record<string, Resolution>;
+}
+export interface MaterializeResult {
+    files: Record<string, string>;
+    collisions: string[];
+    manifest: HarnessManifest;
+}
+export declare function materializeHarness(input: MaterializeInput): MaterializeResult;

package/dist/materialize-harness.js

@@ -0,0 +1,48 @@
+import { createHash } from "node:crypto";
+import { isEntryFile, extractManagedRegions } from "./merge-region.js";
+import { renderRolloutFiles } from "./render/rollout-files.js";
+import { renderBundleUnion } from "./render/bundle-union.js";
+import { validateManifest } from "./manifest.js";
+export function sha256Hex(content) {
+    return createHash("sha256").update(content, "utf8").digest("hex");
+}
+const MACHINE_SETTINGS_PATH = "settings.json";
+export function materializeHarness(input) {
+    const names = Object.keys(input.manifest.packs);
+    const packs = names.map((name) => {
+        const pack = input.resolvedPacks[name];
+        if (!pack)
+            throw new Error(`materialize: pack "${name}" was not resolved`);
+        return pack;
+    });
+    const rendered = input.manifest.target.kind === "repo"
+        ? renderRolloutFiles(input.currentFiles, packs)
+        : renderBundleUnion(packs);
+    const vendored = [];
+    const managedRegions = [];
+    for (const [path, content] of Object.entries(rendered.files).sort(([a], [b]) => a.localeCompare(b))) {
+        if (input.manifest.target.kind === "machine" && path === MACHINE_SETTINGS_PATH)
+            continue;
+        if (isEntryFile(path)) {
+            const regions = extractManagedRegions(content).map((r) => ({
+                packId: r.packId,
+                version: r.version,
+                sha256: sha256Hex(r.body),
+            }));
+            managedRegions.push({ path, regions });
+        }
+        else {
+            vendored.push({ path, sha256: sha256Hex(content) });
+        }
+    }
+    const manifest = validateManifest({
+        ...input.manifest,
+        materialized: {
+            vendored,
+            managedRegions,
+            derivedCommitted: [],
+            resolutions: input.resolutions ?? {},
+        },
+    });
+    return { files: rendered.files, collisions: rendered.collisions, manifest };
+}

package/dist/merge-region.d.ts

@@ -0,0 +1,60 @@
+/** The human-facing files a pack renders that get region-merged into a developer's own content. */
+export declare const ENTRY_FILES: readonly string[];
+export declare function isEntryFile(renderedPath: string): boolean;
+export declare const END_MARKER = "<!-- baselane:end -->";
+export declare function buildStartMarker(packId: string, version: string): string;
+export interface ManagedRegion {
+    packId: string;
+    version: string;
+    body: string;
+}
+/**
+ * Reads every managed region present in an entry file's content — the read-side twin of
+ * mergeManagedRegion/buildStartMarker, built for inventory (drift detection, and
+ * union-rollout's strippedManagedPackIds, which is just `.map(r => r.packId)` on this)
+ * rather than merging. Shares mergeManagedRegion's exact boundary rules: a dangling
+ * opener with no closer, or a region whose true end is ambiguous because the body
+ * contains a stray end-marker literal before the next pack's start (or EOF), is skipped
+ * entirely rather than guessed at — fail safe, same as the merge path.
+ */
+export declare function extractManagedRegions(content: string): ManagedRegion[];
+/**
+ * Merge this pack's managed markdown block into a developer's existing entry file
+ * (AGENTS.md, CLAUDE.md, GEMINI.md, copilot-instructions.md), preserving everything
+ * they wrote by hand — and everything any OTHER pack has already put there.
+ *
+ * - No existing content → the block alone.
+ * - Existing content with a valid region for THIS packId (any version of it) →
+ *   replace just that region, byte-for-byte preserving text before and after it.
+ *   A different pack's region elsewhere in the file is untouched, so multiple packs
+ *   can coexist in the same entry file.
+ * - Existing content with no valid region for this pack — including a malformed
+ *   half-marker with no matching close, or a region whose boundaries are
+ *   unparseable because the body contains a stray end-marker literal — → append a
+ *   fresh block below, never deleting or truncating their content.
+ */
+export declare function mergeManagedRegion(existing: string | null, managedBody: string, packId: string, version: string): string;
+/**
+ * Removes the complete existing region for `packId` (any version), leaving everything else
+ * byte-for-byte untouched — the inverse of what `mergeManagedRegion` inserts. Joins the
+ * surrounding content with a single blank line where both sides remain non-empty, matching
+ * the spacing `mergeManagedRegion` itself produces around a region.
+ *
+ * Returns `content` unchanged when there's no region to remove: absent, a half marker with no
+ * matching close, or an ambiguous boundary (a stray END_MARKER inside the matched body before
+ * the next pack's start) — the exact same fail-safe guard `mergeManagedRegion` uses. Never
+ * guesses; an ambiguous match means don't slice.
+ *
+ * Reconcile note: a sibling in-flight branch is adding a canonical `extractManagedRegions()`
+ * scanner to this file. Once merged, this function's single-region removal could likely derive
+ * from that scanner's output instead of its own `buildRegionRe` match — not done here to avoid
+ * coupling two branches landing in the same file concurrently; left as a follow-up.
+ */
+export declare function stripManagedRegion(content: string, packId: string): string;
+/**
+ * Every packId with a start marker present in `content`, in first-seen order, deduped. Used by
+ * the rollout renderer to know which packs' regions to strip before folding in the current
+ * effective set — safe to call even on a malformed/half-marker region, since `stripManagedRegion`
+ * itself is a no-op when it can't confidently remove one.
+ */
+export declare function strippedManagedPackIds(content: string): string[];

package/dist/merge-region.js

@@ -0,0 +1,166 @@
+/** The human-facing files a pack renders that get region-merged into a developer's own content. */
+export const ENTRY_FILES = ["AGENTS.md", "CLAUDE.md", "GEMINI.md", ".github/copilot-instructions.md"];
+export function isEntryFile(renderedPath) {
+    return ENTRY_FILES.includes(renderedPath);
+}
+// The single source of truth for the managed-region marker format. The AI merge path
+// (ai-merge.ts) imports these so it validates against the exact same literals the
+// mechanical merger writes — a format change here can never silently desync the two.
+export const END_MARKER = "<!-- baselane:end -->";
+export function buildStartMarker(packId, version) {
+    return `<!-- baselane:start ${packId}@${version} — managed region, do not edit inside -->`;
+}
+// Matches ANY pack's opening marker line, used only to bound where the OTHER pack's
+// region ends (so we don't misread a neighboring pack's region as part of ours).
+const START_MARKER_ANY_RE = /<!-- baselane:start [^\n]*? — managed region, do not edit inside -->/;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// Matches a complete existing region for THIS pack id — any version of it — from its
+// opening marker through the next closing marker. The packId is fixed; only the version
+// is a wildcard, so a version bump of the SAME pack still replaces in place, but another
+// pack's region (different packId) never matches. Non-greedy so it stops at the first
+// close, and requires both markers to be present; a dangling opener with no closer
+// won't match.
+function buildRegionRe(packId) {
+    return new RegExp(`<!-- baselane:start ${escapeRegExp(packId)}@[^\\n]*? — managed region, do not edit inside -->\\n[\\s\\S]*?${escapeRegExp(END_MARKER)}`);
+}
+// managedBody is pack-controlled content, not user content — it must never itself
+// contain a marker literal (e.g. pack docs that show marker syntax as an example).
+// If it did, buildBlock would produce a block containing what looks like a second
+// region boundary, corrupting every merge downstream. Fail loudly at the source.
+function assertNoMarkersIn(managedBody) {
+    if (managedBody.includes(END_MARKER) || START_MARKER_ANY_RE.test(managedBody)) {
+        throw new Error("managedBody must not contain a baselane:start or baselane:end marker literal");
+    }
+}
+function buildBlock(managedBody, packId, version) {
+    assertNoMarkersIn(managedBody);
+    const startMarker = buildStartMarker(packId, version);
+    return `${startMarker}\n${managedBody.trim()}\n${END_MARKER}`;
+}
+// Index of the next pack start marker (any pack) at or after `fromIndex`, or the end
+// of the string if there isn't one. Used to bound how far we look for a stray end
+// marker without accidentally reading into a genuinely separate, later region.
+function indexOfNextStartMarker(text, fromIndex) {
+    const re = new RegExp(START_MARKER_ANY_RE.source, "g");
+    re.lastIndex = fromIndex;
+    const found = re.exec(text);
+    return found ? found.index : text.length;
+}
+// Captures every pack's opening marker with its packId/version split at the "@" that
+// buildStartMarker joins them with — the read-side twin of that function. Global so
+// extractManagedRegions can walk every region present in one pass.
+const START_MARKER_CAPTURE_RE = /<!-- baselane:start ([^\n@]+)@([^\n]*?) — managed region, do not edit inside -->/g;
+/**
+ * Reads every managed region present in an entry file's content — the read-side twin of
+ * mergeManagedRegion/buildStartMarker, built for inventory (drift detection, and
+ * union-rollout's strippedManagedPackIds, which is just `.map(r => r.packId)` on this)
+ * rather than merging. Shares mergeManagedRegion's exact boundary rules: a dangling
+ * opener with no closer, or a region whose true end is ambiguous because the body
+ * contains a stray end-marker literal before the next pack's start (or EOF), is skipped
+ * entirely rather than guessed at — fail safe, same as the merge path.
+ */
+export function extractManagedRegions(content) {
+    const regions = [];
+    const startRe = new RegExp(START_MARKER_CAPTURE_RE.source, "g");
+    let match;
+    while ((match = startRe.exec(content)) !== null) {
+        const packId = match[1];
+        const version = match[2];
+        const bodyStart = match.index + match[0].length;
+        const boundary = indexOfNextStartMarker(content, bodyStart);
+        const endIdx = content.indexOf(END_MARKER, bodyStart);
+        if (endIdx === -1 || endIdx >= boundary)
+            continue; // dangling opener — no valid close before the next region (or EOF)
+        const regionIsAmbiguous = content.slice(endIdx + END_MARKER.length, boundary).includes(END_MARKER);
+        if (regionIsAmbiguous)
+            continue; // embedded end-marker literal — true boundary unknowable, fail safe
+        regions.push({ packId, version, body: content.slice(bodyStart, endIdx).trim() });
+    }
+    return regions;
+}
+/**
+ * Merge this pack's managed markdown block into a developer's existing entry file
+ * (AGENTS.md, CLAUDE.md, GEMINI.md, copilot-instructions.md), preserving everything
+ * they wrote by hand — and everything any OTHER pack has already put there.
+ *
+ * - No existing content → the block alone.
+ * - Existing content with a valid region for THIS packId (any version of it) →
+ *   replace just that region, byte-for-byte preserving text before and after it.
+ *   A different pack's region elsewhere in the file is untouched, so multiple packs
+ *   can coexist in the same entry file.
+ * - Existing content with no valid region for this pack — including a malformed
+ *   half-marker with no matching close, or a region whose boundaries are
+ *   unparseable because the body contains a stray end-marker literal — → append a
+ *   fresh block below, never deleting or truncating their content.
+ */
+export function mergeManagedRegion(existing, managedBody, packId, version) {
+    const block = buildBlock(managedBody, packId, version);
+    if (existing === null || existing.trim() === "") {
+        return `${block}\n`;
+    }
+    const match = existing.match(buildRegionRe(packId));
+    if (match && match.index !== undefined) {
+        const matchEnd = match.index + match[0].length;
+        // The non-greedy region regex stops at the FIRST end marker. If the "body" we
+        // just matched contains another end marker further down before the next pack's
+        // start (or EOF), that first marker was actually embedded content, not the real
+        // boundary — our match is bogus and slicing on it would orphan the true
+        // remainder as loose text. Fail safe instead of guessing.
+        const boundary = indexOfNextStartMarker(existing, matchEnd);
+        const regionIsAmbiguous = existing.slice(matchEnd, boundary).includes(END_MARKER);
+        if (!regionIsAmbiguous) {
+            return existing.slice(0, match.index) + block + existing.slice(matchEnd);
+        }
+    }
+    return `${existing.replace(/\s+$/, "")}\n\n${block}\n`;
+}
+// Matches a start marker line, capturing the packId (everything before the first "@" —
+// packIds are kebab-case slugs and never contain "@", so this split is unambiguous).
+const START_MARKER_WITH_ID_RE = /<!-- baselane:start (.+?)@[^@\n]*? — managed region, do not edit inside -->/g;
+/**
+ * Removes the complete existing region for `packId` (any version), leaving everything else
+ * byte-for-byte untouched — the inverse of what `mergeManagedRegion` inserts. Joins the
+ * surrounding content with a single blank line where both sides remain non-empty, matching
+ * the spacing `mergeManagedRegion` itself produces around a region.
+ *
+ * Returns `content` unchanged when there's no region to remove: absent, a half marker with no
+ * matching close, or an ambiguous boundary (a stray END_MARKER inside the matched body before
+ * the next pack's start) — the exact same fail-safe guard `mergeManagedRegion` uses. Never
+ * guesses; an ambiguous match means don't slice.
+ *
+ * Reconcile note: a sibling in-flight branch is adding a canonical `extractManagedRegions()`
+ * scanner to this file. Once merged, this function's single-region removal could likely derive
+ * from that scanner's output instead of its own `buildRegionRe` match — not done here to avoid
+ * coupling two branches landing in the same file concurrently; left as a follow-up.
+ */
+export function stripManagedRegion(content, packId) {
+    const match = content.match(buildRegionRe(packId));
+    if (!match || match.index === undefined)
+        return content;
+    const matchEnd = match.index + match[0].length;
+    const boundary = indexOfNextStartMarker(content, matchEnd);
+    const regionIsAmbiguous = content.slice(matchEnd, boundary).includes(END_MARKER);
+    if (regionIsAmbiguous)
+        return content;
+    const before = content.slice(0, match.index).replace(/\n+$/, "");
+    const after = content.slice(matchEnd).replace(/^\n+/, "");
+    if (before === "")
+        return after;
+    if (after === "")
+        return `${before}\n`;
+    return `${before}\n\n${after}`;
+}
+/**
+ * Every packId with a start marker present in `content`, in first-seen order, deduped. Used by
+ * the rollout renderer to know which packs' regions to strip before folding in the current
+ * effective set — safe to call even on a malformed/half-marker region, since `stripManagedRegion`
+ * itself is a no-op when it can't confidently remove one.
+ */
+export function strippedManagedPackIds(content) {
+    const seen = new Set();
+    for (const m of content.matchAll(START_MARKER_WITH_ID_RE))
+        seen.add(m[1]);
+    return [...seen];
+}

package/dist/overlap.d.ts

@@ -0,0 +1,32 @@
+import type { SkillBlock, WorkflowPack } from "./types.ts";
+/**
+ * #23 overlap detection: near-duplicate packs and pack↔skill pairs ship with no cross-link, so a
+ * user installs both and gets overlapping capabilities. This pure module finds those overlaps by
+ * name so the catalog can surface a "related to X" note, a maintainer-audit lint can list them, and
+ * the dashboard AI check can review them. Reused by all three — kept dependency-free.
+ */
+export interface SkillOverlap {
+    packId: string;
+    skillName: string;
+    /** Which surface of the pack the skill collided with. */
+    via: "pack-id" | "agent" | "command" | "attached-skill";
+    /** The pack-side name that matched (pre-normalization), for display. */
+    matchedName: string;
+}
+/**
+ * Normalize a hyphen/underscore/space-separated name to a comparable stem so different word forms
+ * of the same concept collapse together. Per word: strip a trailing gerund `-ing`, then a trailing
+ * `e`, then a trailing plural `-s`, then join. So `brainstorm`≈`brainstorming`,
+ * `write-plan`≈`writing-plans`, `execute-plan`≈`executing-plans`, and `systematic-debugging`
+ * matches itself — the exact and word-form cases the #23 finding cites. Deliberately conservative:
+ * it catches obvious variants, not arbitrary synonyms; genuinely fuzzy relationships are declared
+ * explicitly (the `relatedTo` field) rather than guessed here.
+ */
+export declare function normalizeName(name: string): string;
+/**
+ * For every (pack, skill) pair whose names collapse to the same stem, emit one overlap. At most one
+ * overlap per pair even when several of the pack's surfaces match — the finding is "these two
+ * overlap", not "this skill matches three of the pack's names". The first matching surface (in
+ * id → agent → command → attached-skill order) is reported as the reason.
+ */
+export declare function computeSkillOverlaps(packs: WorkflowPack[], skills: SkillBlock[]): SkillOverlap[];

package/dist/overlap.js

@@ -0,0 +1,49 @@
+/**
+ * Normalize a hyphen/underscore/space-separated name to a comparable stem so different word forms
+ * of the same concept collapse together. Per word: strip a trailing gerund `-ing`, then a trailing
+ * `e`, then a trailing plural `-s`, then join. So `brainstorm`≈`brainstorming`,
+ * `write-plan`≈`writing-plans`, `execute-plan`≈`executing-plans`, and `systematic-debugging`
+ * matches itself — the exact and word-form cases the #23 finding cites. Deliberately conservative:
+ * it catches obvious variants, not arbitrary synonyms; genuinely fuzzy relationships are declared
+ * explicitly (the `relatedTo` field) rather than guessed here.
+ */
+export function normalizeName(name) {
+    return name
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((w) => w.length > 0)
+        .map((w) => w.replace(/ing$/, "").replace(/e$/, "").replace(/s$/, ""))
+        .join("");
+}
+/** Every name a pack "provides" — its id, agents, commands, and attached skills — as normalizable surfaces. */
+function packSurfaces(pack) {
+    return [
+        { via: "pack-id", name: pack.id },
+        ...pack.agents.map((a) => ({ via: "agent", name: a.name })),
+        ...pack.commands.map((c) => ({ via: "command", name: c.name })),
+        ...(pack.skills ?? []).map((s) => ({ via: "attached-skill", name: s.name })),
+    ];
+}
+/**
+ * For every (pack, skill) pair whose names collapse to the same stem, emit one overlap. At most one
+ * overlap per pair even when several of the pack's surfaces match — the finding is "these two
+ * overlap", not "this skill matches three of the pack's names". The first matching surface (in
+ * id → agent → command → attached-skill order) is reported as the reason.
+ */
+export function computeSkillOverlaps(packs, skills) {
+    const overlaps = [];
+    for (const pack of packs) {
+        const byStem = new Map();
+        for (const surface of packSurfaces(pack)) {
+            const stem = normalizeName(surface.name);
+            if (stem.length > 0 && !byStem.has(stem))
+                byStem.set(stem, surface);
+        }
+        for (const skill of skills) {
+            const hit = byStem.get(normalizeName(skill.name));
+            if (hit)
+                overlaps.push({ packId: pack.id, skillName: skill.name, via: hit.via, matchedName: hit.name });
+        }
+    }
+    return overlaps;
+}

package/dist/pack-from-fileset.d.ts

@@ -0,0 +1,13 @@
+import type { WorkflowPack } from "./types.ts";
+export interface PackFromFilesetResult {
+    pack: WorkflowPack;
+    derived: boolean;
+    sources: string[];
+    skipped: string[];
+}
+export declare function packFromFileset(files: Record<string, string>, opts: {
+    repoName: string;
+    ref: string;
+    sha: string;
+    onlySkill?: string;
+}): Promise<PackFromFilesetResult>;

package/dist/pack-from-fileset.js

@@ -0,0 +1,133 @@
+import { validatePack } from "./validate.js";
+import { ingestHarness } from "./ingest.js";
+const VERSION_TAG_RE = /^v?(\d+\.\d+\.\d+)$/;
+const ONE_LEVEL_SKILL_RE = /^skills\/([^/]+)\/SKILL\.md$/;
+const TWO_LEVEL_SKILL_RE = /^skills\/([^/]+)\/([^/]+)\/SKILL\.md$/;
+const AGENTS_SKILL_RE = /^\.agents\/skills\/([^/]+)\/SKILL\.md$/;
+const ROOT_SKILL_PATH = "SKILL.md";
+function stampVersion(ref, sha) {
+    const m = VERSION_TAG_RE.exec(ref);
+    return m ? m[1] : `0.0.0+${sha.slice(0, 7)}`;
+}
+function rootSkillName(repoName) {
+    const segs = repoName.split("/");
+    return (segs[segs.length - 1] || repoName).toLowerCase();
+}
+/** Recognizes every npx-skills-convention layout for a SKILL.md: root single-skill repo,
+ * `skills/<name>/SKILL.md`, two-level `skills/<category>/<name>/SKILL.md` (category dirs include
+ * dot-dirs like `.curated`/`.experimental`/`.system`), and `.agents/skills/<name>/SKILL.md`. */
+function findSkillMatches(paths, repoName) {
+    const matches = [];
+    for (const path of paths) {
+        let name = null;
+        let sourceDir = "";
+        if (path === ROOT_SKILL_PATH) {
+            name = rootSkillName(repoName);
+            sourceDir = "";
+        }
+        else {
+            const oneLevel = ONE_LEVEL_SKILL_RE.exec(path);
+            const twoLevel = !oneLevel ? TWO_LEVEL_SKILL_RE.exec(path) : null;
+            const agentsLevel = !oneLevel && !twoLevel ? AGENTS_SKILL_RE.exec(path) : null;
+            if (oneLevel) {
+                name = oneLevel[1];
+                sourceDir = `skills/${oneLevel[1]}`;
+            }
+            else if (twoLevel) {
+                name = twoLevel[2];
+                sourceDir = `skills/${twoLevel[1]}/${twoLevel[2]}`;
+            }
+            else if (agentsLevel) {
+                name = agentsLevel[1];
+                sourceDir = `.agents/skills/${agentsLevel[1]}`;
+            }
+        }
+        if (name === null)
+            continue;
+        matches.push({ path, name, sourceDir, depth: path.split("/").length - 1 });
+    }
+    return matches;
+}
+/** Shallow-shadows-deep: when the same skill name appears at multiple depths, the shallowest
+ * SKILL.md wins. At equal depth, the first path in sorted order wins (deterministic tie-break). */
+function pickWinners(matches) {
+    const byName = new Map();
+    for (const m of matches) {
+        const arr = byName.get(m.name) ?? [];
+        arr.push(m);
+        byName.set(m.name, arr);
+    }
+    const winners = new Map();
+    for (const [name, arr] of byName) {
+        const sorted = [...arr].sort((a, b) => a.depth - b.depth || a.path.localeCompare(b.path));
+        winners.set(name, sorted[0]);
+    }
+    return winners;
+}
+/** Remaps every winning skills-corpus layout onto the `.claude/skills/<name>/...` surface that
+ * `ingestHarness` already knows how to read — the ONLY place layout knowledge lives. Sibling files
+ * (references, scripts) one level under a winning skill dir travel with it, under the same name.
+ * Shadowed SKILL.md's (and their siblings) are left at their original path, unremapped, so
+ * `ingestHarness` never sees them. Files not part of any skill layout pass through untouched. */
+function remapSkillsLayout(files, repoName) {
+    const paths = Object.keys(files);
+    const winners = [...pickWinners(findSkillMatches(paths, repoName)).values()];
+    const winnersByPath = new Map(winners.map((w) => [w.path, w]));
+    const winningDirs = winners.filter((w) => w.sourceDir !== "").map((w) => ({ prefix: `${w.sourceDir}/`, name: w.name }));
+    const remapped = {};
+    for (const [path, content] of Object.entries(files)) {
+        const direct = winnersByPath.get(path);
+        if (direct) {
+            remapped[`.claude/skills/${direct.name}/SKILL.md`] = content;
+            continue;
+        }
+        const sibling = winningDirs.find((d) => path.startsWith(d.prefix) && !path.slice(d.prefix.length).includes("/"));
+        if (sibling) {
+            remapped[`.claude/skills/${sibling.name}/${path.slice(sibling.prefix.length)}`] = content;
+            continue;
+        }
+        remapped[path] = content;
+    }
+    return remapped;
+}
+/** Narrows an already-validated pack to a single named skill (the `@skill` selector). Throws
+ * naming every available skill name when `onlySkill` doesn't match any of them. */
+function filterOnlySkill(pack, onlySkill) {
+    if (!onlySkill)
+        return pack;
+    const skills = pack.skills ?? [];
+    const match = skills.find((s) => s.name === onlySkill);
+    if (!match) {
+        const available = skills.map((s) => s.name).join(", ") || "(none)";
+        throw new Error(`pack-from-fileset: no skill named "${onlySkill}" — available: ${available}`);
+    }
+    return { ...pack, skills: [match] };
+}
+export async function packFromFileset(files, opts) {
+    if (typeof files["pack.json"] === "string") {
+        let raw;
+        try {
+            raw = JSON.parse(files["pack.json"]);
+        }
+        catch (err) {
+            throw new Error(`pack-from-fileset: pack.json is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const pack = filterOnlySkill(validatePack(raw), opts.onlySkill);
+        return { pack, derived: false, sources: ["pack.json"], skipped: [] };
+    }
+    // Skills-corpus layouts (plugin-repo skills/, two-level catalog dirs, .agents/skills/, root
+    // single-skill SKILL.md) → the .claude layout ingest knows.
+    const remapped = remapSkillsLayout(files, opts.repoName);
+    const input = {
+        repoName: opts.repoName,
+        listFiles: async () => Object.keys(remapped),
+        readFile: async (path) => remapped[path] ?? null,
+    };
+    const result = await ingestHarness(input);
+    const hasHarness = Object.keys(remapped).some((p) => p === "AGENTS.md" || p.startsWith(".claude/"));
+    if (!hasHarness) {
+        throw new Error(`pack-from-fileset: nothing installable — no root pack.json (native pack) and no AGENTS.md/.claude/skills content to ingest. See the pack format docs.`);
+    }
+    const pack = filterOnlySkill(validatePack({ ...result.pack, version: stampVersion(opts.ref, opts.sha) }), opts.onlySkill);
+    return { pack, derived: true, sources: result.sources, skipped: result.skipped };
+}

package/dist/render/adapters.d.ts

@@ -0,0 +1,6 @@
+import type { WorkflowPack } from "../types.ts";
+/** Copilot: no import syntax, no agent/command/hook surface — inline everything as prose. */
+export declare function renderCopilot(pack: WorkflowPack): string;
+/** Gemini CLI resolves @file imports like Claude Code — one-line pointer, plus full skill bodies
+ * appended (Gemini has no native skill mechanism). Byte-identical to the old pointer when no skills. */
+export declare function renderGemini(pack: WorkflowPack): string;

package/dist/render/adapters.js

@@ -0,0 +1,43 @@
+/** Full skill bodies inlined for surfaces with no native skill mechanism (Option A). Empty when the
+ * pack has no skills, so callers stay byte-identical for skill-less packs. */
+function skillBodiesSection(pack) {
+    if (!pack.skills || pack.skills.length === 0)
+        return [];
+    const out = ["## Skills", ""];
+    for (const s of pack.skills) {
+        out.push(`### ${s.name}`, "", s.description, "", s.body.trimEnd(), "");
+    }
+    return out;
+}
+/** Copilot: no import syntax, no agent/command/hook surface — inline everything as prose. */
+export function renderCopilot(pack) {
+    const parts = ["# Copilot instructions", "", pack.context.markdown.trimEnd(), ""];
+    parts.push(`## Workflow pack: ${pack.title}`, "", pack.summary, "");
+    if (pack.agents.length > 0) {
+        for (const a of pack.agents) {
+            parts.push(`When acting as the ${a.name} role: ${a.prompt}`, "");
+        }
+    }
+    if (pack.commands.length > 0) {
+        parts.push("Workflow steps:", "");
+        for (const c of pack.commands)
+            parts.push(`- ${c.name}: ${c.prompt}`);
+        parts.push("");
+    }
+    if (pack.hooks.length > 0) {
+        for (const h of pack.hooks)
+            parts.push(`- ${h.action === "print-reminder" ? h.message : h.description}`);
+        parts.push("");
+    }
+    parts.push(...skillBodiesSection(pack));
+    return parts.join("\n");
+}
+/** Gemini CLI resolves @file imports like Claude Code — one-line pointer, plus full skill bodies
+ * appended (Gemini has no native skill mechanism). Byte-identical to the old pointer when no skills. */
+export function renderGemini(pack) {
+    const base = "# GEMINI.md\n\n@AGENTS.md\n";
+    const bodies = skillBodiesSection(pack);
+    if (bodies.length === 0)
+        return base;
+    return `${base}\n${bodies.join("\n")}`;
+}

package/dist/render/agents-md.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowPack } from "../types.ts";
+/** Canonical AGENTS.md: context verbatim, then the pack as tool-agnostic sections. */
+export declare function renderAgentsMd(pack: WorkflowPack): string;

package/dist/render/agents-md.js

@@ -0,0 +1,49 @@
+import { renderCapabilities } from "./capabilities.js";
+const FOOTER = "Tool-specific implementations live alongside this file (see `CLAUDE.md` for the " +
+    "Claude Code implementation). Tools without a native subagent/command surface should " +
+    "treat the sections above as operating instructions.";
+/** Canonical AGENTS.md: context verbatim, then the pack as tool-agnostic sections. */
+export function renderAgentsMd(pack) {
+    const a = pack.attribution;
+    const parts = [
+        "# AGENTS.md",
+        "",
+        `<!-- generated from workflow-pack ${pack.id} v${pack.version} -->`,
+        ...(a ? [`<!-- adapted from ${a.source} (${a.license}) — ${a.url} -->`] : []),
+        "",
+        pack.context.markdown.trimEnd(),
+        "",
+    ];
+    const { section } = renderCapabilities(pack);
+    if (section)
+        parts.push(section, "");
+    parts.push(`## Workflow pack: ${pack.title}`, "", pack.summary, "");
+    if (pack.agents.length > 0) {
+        parts.push("### Roles", "");
+        for (const a of pack.agents)
+            parts.push(`- **${a.name}** — ${a.description}`);
+        parts.push("");
+    }
+    if (pack.commands.length > 0) {
+        parts.push("### Commands", "");
+        for (const c of pack.commands) {
+            parts.push(`- **/${c.name}** \`${c.argument_hint}\` — ${c.description}`);
+            parts.push(`  - How it runs: ${c.prompt}`);
+        }
+        parts.push("");
+    }
+    if (pack.hooks.length > 0) {
+        parts.push("### Guardrails", "");
+        for (const h of pack.hooks)
+            parts.push(`- ${h.description}`);
+        parts.push("");
+    }
+    if (pack.skills && pack.skills.length > 0) {
+        parts.push("### Skills", "");
+        for (const s of pack.skills)
+            parts.push(`- **${s.name}** — ${s.description}`);
+        parts.push("");
+    }
+    parts.push(FOOTER, "");
+    return parts.join("\n");
+}

package/dist/render/bundle-union.d.ts

@@ -0,0 +1,10 @@
+import type { FileMap, WorkflowPack } from "../types.ts";
+export interface BundleUnion {
+    files: FileMap;
+    collisions: string[];
+}
+/** Unions the machine-level bundle files of an ordered (most-specific-first) effective pack set.
+ * settings.json hooks concatenate per event; capabilities manifests dedup; every other path is
+ * first-writer-wins with a collisions note on a differing later write. `renderBundleUnion([p])`
+ * byte-equals `renderBundleFiles(p)`. */
+export declare function renderBundleUnion(packs: WorkflowPack[]): BundleUnion;