@webpresso/agent-kit 0.21.0

package/dist/esm/content/dispatch.js

@@ -0,0 +1,204 @@
+/**
+ * Shared CLI dispatch for `wp rule` and `wp skill` subcommands.
+ *
+ * Subcommands handled here are kind-agnostic — `new | list | show |
+ * deprecate`. Per-kind additions (e.g. `wp skill install`) are implemented
+ * in the thin command shims, not here.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import matter from 'gray-matter';
+import { loadContent } from './loader.js';
+const CONSUMER_DIR_BY_KIND = {
+    rule: 'agent-rules',
+    skill: 'agent-skills',
+};
+function todayIsoDate() {
+    return new Date().toISOString().slice(0, 10);
+}
+function humanizeSlug(slug) {
+    return slug
+        .split('-')
+        .filter((part) => part.length > 0)
+        .map((part) => part[0].toUpperCase() + part.slice(1))
+        .join(' ');
+}
+function consumerFilePath(cwd, kind, slug) {
+    return kind === 'rule'
+        ? join(cwd, CONSUMER_DIR_BY_KIND.rule, `${slug}.md`)
+        : join(cwd, CONSUMER_DIR_BY_KIND.skill, slug, 'SKILL.md');
+}
+function buildFrontmatterDoc(kind, slug, title, scope) {
+    const today = todayIsoDate();
+    return [
+        '---',
+        `type: ${kind}`,
+        `slug: ${slug}`,
+        `title: ${title}`,
+        'status: active',
+        `scope: ${scope}`,
+        'applies_to:',
+        '  - agents',
+        `created: '${today}'`,
+        `last_reviewed: '${today}'`,
+        'related: []',
+        '---',
+        '',
+        `# ${title}`,
+        '',
+        '<!-- Describe the rule or skill here. -->',
+        '',
+    ].join('\n');
+}
+async function handleNew(args) {
+    const slug = args.args[0];
+    if (!slug) {
+        return {
+            exitCode: 1,
+            stdout: '',
+            stderr: `Usage: wp ${args.kind} new <slug> [--title <text>] [--scope <s>]`,
+        };
+    }
+    const title = args.options.title ?? humanizeSlug(slug);
+    const scope = args.options.scope ?? 'repo';
+    const targetPath = consumerFilePath(args.options.cwd, args.kind, slug);
+    const content = buildFrontmatterDoc(args.kind, slug, title, scope);
+    if (args.options.dryRun) {
+        return { exitCode: 0, stdout: `Would create: ${targetPath}`, stderr: '' };
+    }
+    try {
+        mkdirSync(join(targetPath, '..'), { recursive: true });
+        writeFileSync(targetPath, content, { flag: 'wx' });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes('EEXIST')) {
+            return {
+                exitCode: 1,
+                stdout: '',
+                stderr: `File already exists: ${targetPath}`,
+            };
+        }
+        return { exitCode: 1, stdout: '', stderr: message };
+    }
+    return { exitCode: 0, stdout: `Created: ${targetPath}`, stderr: '' };
+}
+function loadAll(args) {
+    const result = loadContent({
+        catalogDir: args.options.catalogDir,
+        consumerRoot: args.options.cwd,
+        kinds: [args.kind],
+    });
+    return result.records;
+}
+function readableFrontmatterTitle(record) {
+    const fm = record.rawFrontmatter;
+    const title = fm['title'];
+    return typeof title === 'string' ? title : record.slug;
+}
+async function handleList(args) {
+    let records = loadAll(args);
+    if (args.options.source) {
+        records = records.filter((r) => r.source === args.options.source);
+    }
+    if (records.length === 0) {
+        return { exitCode: 0, stdout: '(no records)', stderr: '' };
+    }
+    const lines = records.map((r) => `${r.source}\t${r.kind}\t${r.slug}\t${readableFrontmatterTitle(r)}`);
+    return { exitCode: 0, stdout: lines.join('\n'), stderr: '' };
+}
+async function handleShow(args) {
+    const slug = args.args[0];
+    if (!slug) {
+        return {
+            exitCode: 1,
+            stdout: '',
+            stderr: `Usage: wp ${args.kind} show <slug>`,
+        };
+    }
+    const records = loadAll(args);
+    const matches = records.filter((r) => r.slug === slug);
+    if (matches.length === 0) {
+        return {
+            exitCode: 1,
+            stdout: '',
+            stderr: `${args.kind} not found: ${slug}`,
+        };
+    }
+    // Prefer consumer when both exist.
+    const chosen = matches.find((r) => r.source === 'consumer') ?? matches[0];
+    const fm = chosen.rawFrontmatter;
+    const fmLines = Object.entries(fm).map(([key, value]) => `${key}: ${JSON.stringify(value)}`);
+    const stdout = [
+        `# Source: ${chosen.source} (${chosen.filePath})`,
+        '---',
+        ...fmLines,
+        '---',
+        '',
+        chosen.body,
+    ].join('\n');
+    return { exitCode: 0, stdout, stderr: '' };
+}
+async function handleDeprecate(args) {
+    const slug = args.args[0];
+    if (!slug) {
+        return {
+            exitCode: 1,
+            stdout: '',
+            stderr: `Usage: wp ${args.kind} deprecate <slug> [--reason <text>]`,
+        };
+    }
+    const filePath = consumerFilePath(args.options.cwd, args.kind, slug);
+    if (!existsSync(filePath)) {
+        return {
+            exitCode: 1,
+            stdout: '',
+            stderr: `Cannot deprecate ${args.kind} ${slug}: not found in consumer at ${filePath}. ` +
+                `Canonical (catalog) entries are owned by the webpresso package.`,
+        };
+    }
+    const raw = readFileSync(filePath, 'utf8');
+    const parsed = matter(raw);
+    const data = { ...parsed.data };
+    data['status'] = 'deprecated';
+    data['deprecation_date'] = todayIsoDate();
+    data['last_reviewed'] = todayIsoDate();
+    let body = parsed.content;
+    if (args.options.reason && args.options.reason.length > 0) {
+        const note = `\n\n## Deprecation note\n\n${args.options.reason}\n`;
+        body = `${body.trimEnd()}${note}`;
+    }
+    const next = matter.stringify(body, data);
+    writeFileSync(filePath, next);
+    return {
+        exitCode: 0,
+        stdout: `Deprecated ${args.kind} ${slug}: ${filePath}`,
+        stderr: '',
+    };
+}
+export async function dispatchContent(input) {
+    const handlerArgs = {
+        kind: input.kind,
+        args: input.args,
+        options: input.options,
+    };
+    switch (input.sub) {
+        case 'new':
+            return handleNew(handlerArgs);
+        case 'list':
+            return handleList(handlerArgs);
+        case 'show':
+            return handleShow(handlerArgs);
+        case 'deprecate':
+            return handleDeprecate(handlerArgs);
+        default: {
+            const sub = input.sub;
+            return {
+                exitCode: 1,
+                stdout: '',
+                stderr: `Unknown ${input.kind} subcommand: ${sub}. Use one of: new, list, show, deprecate.`,
+            };
+        }
+    }
+}
+//# sourceMappingURL=dispatch.js.map

package/dist/esm/content/loader.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Generic content loader for canonical (catalog) + consumer
+ * (`agent-rules/`, `agent-skills/`) trees.
+ *
+ * Returns a deterministically-sorted, source-tagged list of frontmatter
+ * records. Slug collisions between canonical and consumer are surfaced as a
+ * separate `collisions` array — the caller decides how to merge or pick a
+ * winner.
+ *
+ * NOTE: `parsedFrontmatter` is intentionally typed as `unknown` here. The
+ * real schema lives in `src/content/schema.ts` (Task 1.2, runs in parallel).
+ * Once that lands, Task 2.x will swap the stub `RawFrontmatter` type below
+ * for the schema-validated record. Until then, the loader returns the raw
+ * gray-matter object in both `rawFrontmatter` and `parsedFrontmatter` so the
+ * shape stays stable for downstream callers writing tests against it.
+ */
+export type ContentKind = 'rule' | 'skill';
+export type ContentSource = 'canonical' | 'consumer';
+/**
+ * Stub raw frontmatter type. Replaced with schema output in Task 2.x.
+ */
+type RawFrontmatter = Record<string, unknown>;
+export interface ContentRecord {
+    readonly kind: ContentKind;
+    readonly slug: string;
+    readonly source: ContentSource;
+    readonly filePath: string;
+    readonly rawFrontmatter: RawFrontmatter;
+    readonly parsedFrontmatter: unknown;
+    readonly body: string;
+    readonly assetPaths: readonly string[];
+}
+export interface ContentCollision {
+    readonly slug: string;
+    readonly kind: ContentKind;
+    readonly canonical: string;
+    readonly consumer: string;
+}
+export interface LoadResult {
+    readonly records: readonly ContentRecord[];
+    readonly collisions: readonly ContentCollision[];
+}
+export interface LoadOptions {
+    readonly catalogDir: string;
+    readonly consumerRoot?: string;
+    readonly kinds?: readonly ContentKind[];
+}
+export declare function loadContent(options: LoadOptions): LoadResult;
+export {};
+//# sourceMappingURL=loader.d.ts.map

package/dist/esm/content/loader.js

@@ -0,0 +1,166 @@
+/**
+ * Generic content loader for canonical (catalog) + consumer
+ * (`agent-rules/`, `agent-skills/`) trees.
+ *
+ * Returns a deterministically-sorted, source-tagged list of frontmatter
+ * records. Slug collisions between canonical and consumer are surfaced as a
+ * separate `collisions` array — the caller decides how to merge or pick a
+ * winner.
+ *
+ * NOTE: `parsedFrontmatter` is intentionally typed as `unknown` here. The
+ * real schema lives in `src/content/schema.ts` (Task 1.2, runs in parallel).
+ * Once that lands, Task 2.x will swap the stub `RawFrontmatter` type below
+ * for the schema-validated record. Until then, the loader returns the raw
+ * gray-matter object in both `rawFrontmatter` and `parsedFrontmatter` so the
+ * shape stays stable for downstream callers writing tests against it.
+ */
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import matter from 'gray-matter';
+const DEFAULT_KINDS = ['rule', 'skill'];
+const CONSUMER_DIR_BY_KIND = {
+    rule: 'agent-rules',
+    skill: 'agent-skills',
+};
+const CATALOG_DIR_BY_KIND = {
+    rule: 'rules',
+    skill: 'skills',
+};
+export function loadContent(options) {
+    const { catalogDir, consumerRoot, kinds = DEFAULT_KINDS } = options;
+    if (!existsSync(catalogDir)) {
+        throw new Error(`loadContent: catalogDir does not exist: ${catalogDir}. ` +
+            `Catalog dir is required (this is a misconfiguration, not a graceful path).`);
+    }
+    // Absorb pnpm `.pnpm/<version>/` instability — pin to the realpath once.
+    const resolvedCatalog = realpathSync(catalogDir);
+    const resolvedConsumer = consumerRoot !== undefined && existsSync(consumerRoot) ? realpathSync(consumerRoot) : undefined;
+    const records = [];
+    const collisions = [];
+    for (const kind of kinds) {
+        const canonicalRecords = readKind({
+            kind,
+            root: join(resolvedCatalog, CATALOG_DIR_BY_KIND[kind]),
+            source: 'canonical',
+        });
+        const consumerRecords = resolvedConsumer !== undefined
+            ? readKind({
+                kind,
+                root: join(resolvedConsumer, CONSUMER_DIR_BY_KIND[kind]),
+                source: 'consumer',
+            })
+            : [];
+        const canonicalBySlug = new Map(canonicalRecords.map((r) => [r.slug, r]));
+        for (const consumerRec of consumerRecords) {
+            const canonicalRec = canonicalBySlug.get(consumerRec.slug);
+            if (canonicalRec !== undefined) {
+                collisions.push({
+                    slug: consumerRec.slug,
+                    kind,
+                    canonical: canonicalRec.filePath,
+                    consumer: consumerRec.filePath,
+                });
+            }
+        }
+        records.push(...canonicalRecords, ...consumerRecords);
+    }
+    records.sort((a, b) => {
+        if (a.kind !== b.kind)
+            return a.kind < b.kind ? -1 : 1;
+        if (a.slug !== b.slug)
+            return a.slug < b.slug ? -1 : 1;
+        // Stable secondary key: canonical before consumer for same slug.
+        if (a.source !== b.source)
+            return a.source === 'canonical' ? -1 : 1;
+        return 0;
+    });
+    return { records, collisions };
+}
+function readKind(args) {
+    const { kind, root, source } = args;
+    if (!existsSync(root))
+        return [];
+    const stat = statSync(root);
+    if (!stat.isDirectory())
+        return [];
+    return kind === 'rule' ? readRules(root, source) : readSkills(root, source);
+}
+function readRules(root, source) {
+    const out = [];
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        if (!entry.isFile())
+            continue;
+        if (!entry.name.endsWith('.md'))
+            continue;
+        // Skip directory-documentation files. README.md exists in both the
+        // canonical catalog and the consumer-owned agent-rules/ scaffolder
+        // surface; treating it as a rule would produce a spurious slug
+        // collision and would also try to project it into per-IDE surfaces.
+        if (entry.name === 'README.md')
+            continue;
+        const filePath = realpathSync(join(root, entry.name));
+        const slug = entry.name.replace(/\.md$/, '');
+        const parsed = matter(readFileSync(filePath, 'utf8'));
+        const raw = { ...parsed.data };
+        out.push({
+            kind: 'rule',
+            slug,
+            source,
+            filePath,
+            rawFrontmatter: raw,
+            parsedFrontmatter: raw,
+            body: parsed.content.trimStart(),
+            assetPaths: [],
+        });
+    }
+    return out;
+}
+function readSkills(root, source) {
+    const out = [];
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const skillDir = join(root, entry.name);
+        const skillFile = join(skillDir, 'SKILL.md');
+        if (!existsSync(skillFile))
+            continue;
+        const filePath = realpathSync(skillFile);
+        const parsed = matter(readFileSync(filePath, 'utf8'));
+        const raw = { ...parsed.data };
+        const assetPaths = collectSkillAssets(skillDir);
+        out.push({
+            kind: 'skill',
+            slug: entry.name,
+            source,
+            filePath,
+            rawFrontmatter: raw,
+            parsedFrontmatter: raw,
+            body: parsed.content.trimStart(),
+            assetPaths,
+        });
+    }
+    return out;
+}
+function collectSkillAssets(skillDir) {
+    const resolvedDir = realpathSync(skillDir);
+    const assets = [];
+    walk(resolvedDir, (absPath) => {
+        if (absPath === join(resolvedDir, 'SKILL.md'))
+            return;
+        assets.push(relative(resolvedDir, absPath));
+    });
+    assets.sort();
+    return assets;
+}
+function walk(dir, visit) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const abs = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walk(abs, visit);
+        }
+        else if (entry.isFile()) {
+            visit(abs);
+        }
+    }
+}
+//# sourceMappingURL=loader.js.map

package/dist/esm/content/schema.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Zod schemas for consumer-rule + consumer-skill content frontmatter.
+ *
+ * Single discriminated union on `type` with two variants — `rule` and `skill`.
+ * Built-in normalization for the legacy `paths` frontmatter shape:
+ * an array of glob strings collapses to a single `scope: 'path:<joined>'`
+ * value at parse time (multiple entries joined with `,`). See refinement
+ * finding F12 in the consumer-content extraction plan.
+ *
+ * Cross-field rule: `deprecation_date` is required iff `status === 'deprecated'`,
+ * forbidden otherwise.
+ */
+import { z } from 'zod';
+/**
+ * Document type — narrows the discriminated union below.
+ */
+export declare const contentTypeSchema: z.ZodEnum<{
+    rule: "rule";
+    skill: "skill";
+}>;
+/**
+ * Lifecycle status. New content is `active`; once retired it is `deprecated`
+ * and MUST carry a `deprecation_date`.
+ */
+export declare const contentStatusSchema: z.ZodEnum<{
+    deprecated: "deprecated";
+    active: "active";
+}>;
+/**
+ * Audience markers — at least one entry is required.
+ */
+export declare const appliesToSchema: z.ZodEnum<{
+    agents: "agents";
+    humans: "humans";
+}>;
+/**
+ * Rule frontmatter — `type: 'rule'` plus the shared shape.
+ */
+export declare const ruleFrontmatterSchema: z.ZodPreprocess<z.ZodObject<{
+    slug: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        deprecated: "deprecated";
+        active: "active";
+    }>>;
+    scope: z.ZodDefault<z.ZodString>;
+    applies_to: z.ZodArray<z.ZodEnum<{
+        agents: "agents";
+        humans: "humans";
+    }>>;
+    related: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    created: z.ZodString;
+    last_reviewed: z.ZodString;
+    deprecation_date: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"rule">;
+}, z.core.$strip>>;
+/**
+ * Skill frontmatter — `type: 'skill'` plus the shared shape.
+ */
+export declare const skillFrontmatterSchema: z.ZodPreprocess<z.ZodObject<{
+    slug: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        deprecated: "deprecated";
+        active: "active";
+    }>>;
+    scope: z.ZodDefault<z.ZodString>;
+    applies_to: z.ZodArray<z.ZodEnum<{
+        agents: "agents";
+        humans: "humans";
+    }>>;
+    related: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    created: z.ZodString;
+    last_reviewed: z.ZodString;
+    deprecation_date: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"skill">;
+}, z.core.$strip>>;
+/**
+ * Discriminated union on `type` — pre-processes legacy `paths` first so the
+ * inner discriminator only sees the canonical shape.
+ */
+export declare const contentFrontmatterSchema: z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    slug: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        deprecated: "deprecated";
+        active: "active";
+    }>>;
+    scope: z.ZodDefault<z.ZodString>;
+    applies_to: z.ZodArray<z.ZodEnum<{
+        agents: "agents";
+        humans: "humans";
+    }>>;
+    related: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    created: z.ZodString;
+    last_reviewed: z.ZodString;
+    deprecation_date: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"rule">;
+}, z.core.$strip>, z.ZodObject<{
+    slug: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        deprecated: "deprecated";
+        active: "active";
+    }>>;
+    scope: z.ZodDefault<z.ZodString>;
+    applies_to: z.ZodArray<z.ZodEnum<{
+        agents: "agents";
+        humans: "humans";
+    }>>;
+    related: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    created: z.ZodString;
+    last_reviewed: z.ZodString;
+    deprecation_date: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"skill">;
+}, z.core.$strip>], "type">>;
+/**
+ * Inferred TypeScript types — both per-variant and the union.
+ */
+export type RuleFrontmatter = z.infer<typeof ruleFrontmatterSchema>;
+export type SkillFrontmatter = z.infer<typeof skillFrontmatterSchema>;
+export type ContentFrontmatter = z.infer<typeof contentFrontmatterSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/esm/content/schema.js

@@ -0,0 +1,125 @@
+/**
+ * Zod schemas for consumer-rule + consumer-skill content frontmatter.
+ *
+ * Single discriminated union on `type` with two variants — `rule` and `skill`.
+ * Built-in normalization for the legacy `paths` frontmatter shape:
+ * an array of glob strings collapses to a single `scope: 'path:<joined>'`
+ * value at parse time (multiple entries joined with `,`). See refinement
+ * finding F12 in the consumer-content extraction plan.
+ *
+ * Cross-field rule: `deprecation_date` is required iff `status === 'deprecated'`,
+ * forbidden otherwise.
+ */
+import { z } from 'zod';
+/**
+ * Document type — narrows the discriminated union below.
+ */
+export const contentTypeSchema = z.enum(['rule', 'skill']);
+/**
+ * Lifecycle status. New content is `active`; once retired it is `deprecated`
+ * and MUST carry a `deprecation_date`.
+ */
+export const contentStatusSchema = z.enum(['active', 'deprecated']);
+/**
+ * Audience markers — at least one entry is required.
+ */
+export const appliesToSchema = z.enum(['agents', 'humans']);
+/**
+ * Slug shape — kebab-case, lowercase letters / digits / hyphens, must start
+ * with a letter or digit.
+ */
+const slugPattern = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+const slugSchema = z
+    .string()
+    .min(1)
+    .regex(slugPattern, 'slug must be kebab-case (lowercase letters, digits, hyphens)');
+/**
+ * ISO calendar date (YYYY-MM-DD).
+ */
+const isoDatePattern = /^\d{4}-\d{2}-\d{2}$/;
+const isoDateSchema = z.string().regex(isoDatePattern, 'date must be ISO YYYY-MM-DD');
+/**
+ * Scope shape — `repo`, `package:<name>`, or `path:<glob>`.
+ */
+const scopePattern = /^(?:repo|package:[^\s]+|path:[^\s]+)$/;
+const scopeSchema = z
+    .string()
+    .regex(scopePattern, 'scope must be repo | package:<name> | path:<glob>');
+/**
+ * Common fields shared by every content variant.
+ */
+const baseShape = {
+    slug: slugSchema,
+    title: z.string().min(1, 'title is required'),
+    status: contentStatusSchema.default('active'),
+    scope: scopeSchema.default('repo'),
+    applies_to: z.array(appliesToSchema).min(1, 'applies_to must be non-empty'),
+    related: z
+        .array(slugSchema)
+        .optional()
+        .default(() => []),
+    created: isoDateSchema,
+    last_reviewed: isoDateSchema,
+    deprecation_date: isoDateSchema.optional(),
+};
+/**
+ * Pre-validation normalization that promotes the legacy `paths: [...]` field
+ * to the canonical `scope: 'path:<joined>'` shape. Runs only when `scope` is
+ * not explicitly set — explicit scope always wins.
+ */
+function normalizeLegacyPaths(input) {
+    if (typeof input !== 'object' || input === null)
+        return input;
+    const record = input;
+    const hasScope = typeof record['scope'] === 'string' && record['scope'].length > 0;
+    const paths = record['paths'];
+    if (hasScope || !Array.isArray(paths) || paths.length === 0)
+        return record;
+    const joined = paths.filter((p) => typeof p === 'string').join(',');
+    if (joined.length === 0)
+        return record;
+    const { paths: _drop, ...rest } = record;
+    return { ...rest, scope: `path:${joined}` };
+}
+/**
+ * Cross-field check for `deprecation_date` ↔ `status`.
+ */
+function refineDeprecationInterlock(data, ctx) {
+    if (data.status === 'deprecated' && !data.deprecation_date) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['deprecation_date'],
+            message: 'deprecation_date is required when status is "deprecated"',
+        });
+    }
+    if (data.status === 'active' && data.deprecation_date) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['deprecation_date'],
+            message: 'deprecation_date is forbidden when status is "active"',
+        });
+    }
+}
+/**
+ * Rule frontmatter — `type: 'rule'` plus the shared shape.
+ */
+export const ruleFrontmatterSchema = z
+    .preprocess(normalizeLegacyPaths, z.object({ type: z.literal('rule'), ...baseShape }))
+    .superRefine((data, ctx) => refineDeprecationInterlock(data, ctx));
+/**
+ * Skill frontmatter — `type: 'skill'` plus the shared shape.
+ */
+export const skillFrontmatterSchema = z
+    .preprocess(normalizeLegacyPaths, z.object({ type: z.literal('skill'), ...baseShape }))
+    .superRefine((data, ctx) => refineDeprecationInterlock(data, ctx));
+/**
+ * Discriminated union on `type` — pre-processes legacy `paths` first so the
+ * inner discriminator only sees the canonical shape.
+ */
+export const contentFrontmatterSchema = z
+    .preprocess(normalizeLegacyPaths, z.discriminatedUnion('type', [
+    z.object({ type: z.literal('rule'), ...baseShape }),
+    z.object({ type: z.literal('skill'), ...baseShape }),
+]))
+    .superRefine((data, ctx) => refineDeprecationInterlock(data, ctx));
+//# sourceMappingURL=schema.js.map

package/dist/esm/dev/dev-link-state.d.ts

@@ -0,0 +1,22 @@
+export declare const STATE_FILE_RELATIVE_PATH = ".webpresso/webpresso-dev-link.json";
+export interface DevLinkState {
+    package: string;
+    linkedFrom: string;
+    linkedAt?: string;
+    webpressoVersion?: string;
+    note?: string;
+}
+/**
+ * Read + validate the dev-link state file from a consumer's repo root.
+ *
+ * Returns `null` when:
+ *   - the file is absent (CI / never linked) — silent no-op path
+ *   - the file is malformed JSON — degrade gracefully, never crash callers
+ *   - required fields (`package`, `linkedFrom`) are missing or wrong type
+ *
+ * Callers MUST treat `null` as "no dev-link active" and proceed silently.
+ * Callers that need fail-loud semantics on degraded state (e.g. the postinstall
+ * restore bin) should layer their own error handling on top.
+ */
+export declare function readDevLinkState(consumerCwd: string): DevLinkState | null;
+//# sourceMappingURL=dev-link-state.d.ts.map