@webpresso/agent-kit 0.21.0

package/dist/esm/cli/commands/init/scaffolders/vision/interview.js

@@ -0,0 +1,73 @@
+/**
+ * Vision interview — asks the operator a few short questions to seed
+ * `VISION.md` with a tailored north-star instead of the generic template
+ * stub. Runs only on a fresh consumer (no existing `VISION.md`) when
+ * `process.stdin.isTTY` and no `--yes` was passed.
+ *
+ * Matches the existing `node:readline/promises` pattern used by
+ * Tier-3 skill selection — no new prompt-library dependency.
+ *
+ * Every answer is optional. Skipped fields fall back to the template's
+ * prose stubs so the audit (`wp audit vision`) still passes minimally.
+ */
+import { createInterface } from 'node:readline/promises';
+/**
+ * Returns answers to interpolate into the template, or `null` if the
+ * interview should not run (non-TTY, --yes, or VISION.md already exists).
+ */
+export async function maybeRunVisionInterview(input) {
+    if (input.visionExists)
+        return null;
+    if (input.yesFlag)
+        return null;
+    if (!input.isTTY)
+        return null;
+    const rl = createInterface({
+        input: input.inputStream ?? process.stdin,
+        output: input.outputStream ?? process.stdout,
+    });
+    const out = input.outputStream ?? process.stdout;
+    try {
+        out.write(`\n📜 Seeding VISION.md for ${input.repoName} (press Enter to skip any line)\n\n`);
+        const oneLiner = await ask(rl, '  In one sentence, what does this repo do? ');
+        const tagline = await ask(rl, '  North-star tagline (the sticker — short!): ');
+        const problem = await ask(rl, '  What pain does this solve? (1-2 sentences): ');
+        const inScopeRaw = await ask(rl, '  In scope (comma-separated, blank to skip): ');
+        const outOfScopeRaw = await ask(rl, '  Out of scope (comma-separated; mention where they belong): ');
+        const principlesRaw = await askMultiline(rl, '  Design principles (one per line, blank line to finish):');
+        return {
+            oneLiner,
+            tagline,
+            problem,
+            inScope: splitList(inScopeRaw),
+            outOfScope: splitList(outOfScopeRaw),
+            principles: principlesRaw,
+        };
+    }
+    finally {
+        rl.close();
+    }
+}
+async function ask(rl, prompt) {
+    const answer = (await rl.question(prompt)).trim();
+    return answer;
+}
+async function askMultiline(rl, prompt) {
+    const out = rl.output ?? process.stdout;
+    out.write(`${prompt}\n`);
+    const collected = [];
+    while (true) {
+        const line = (await rl.question('    - ')).trim();
+        if (line.length === 0)
+            break;
+        collected.push(line);
+    }
+    return collected;
+}
+function splitList(raw) {
+    return raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+//# sourceMappingURL=interview.js.map

package/dist/esm/cli/commands/init/scaffolders/workspace-config/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Workspace config scaffolder.
+ *
+ * Creates `~/.agent/workspace.yaml` (user-global, never committed) if absent.
+ * The file lists local repos for cross-repo correlation lookups.
+ *
+ * Runs unconditionally on every `wp setup` — not gated behind a --with flag
+ * since workspace config is always needed for cross-repo correlation.
+ */
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+export declare function defaultWorkspaceConfigPath(): string;
+/**
+ * Creates `~/.agent/workspace.yaml` if absent. Idempotent — second call
+ * returns `existing` without touching the file.
+ */
+export declare function scaffoldWorkspaceConfig(opts?: {
+    /** Override config path for testing. */
+    configPath?: string;
+    /** DI seam for fs.existsSync. */
+    exists?: typeof existsSync;
+    /** DI seam for fs.mkdirSync. */
+    mkdir?: typeof mkdirSync;
+    /** DI seam for fs.writeFileSync. */
+    writeFile?: typeof writeFileSync;
+}): Promise<{
+    action: 'created' | 'existing';
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/cli/commands/init/scaffolders/workspace-config/index.js

@@ -0,0 +1,40 @@
+/**
+ * Workspace config scaffolder.
+ *
+ * Creates `~/.agent/workspace.yaml` (user-global, never committed) if absent.
+ * The file lists local repos for cross-repo correlation lookups.
+ *
+ * Runs unconditionally on every `wp setup` — not gated behind a --with flag
+ * since workspace config is always needed for cross-repo correlation.
+ */
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+const WORKSPACE_YAML_TEMPLATE = `# ~/.agent/workspace.yaml — user-global workspace config
+# Lists local repos for cross-repo correlation lookups
+# Never committed to any repo (gitignored by design)
+repos: []
+  # - path: ~/repos/<org>/<repo-a>
+  # - path: ~/repos/<org>/<repo-b>
+  # - path: ~/repos/<org>/<consumer-repo>
+`;
+export function defaultWorkspaceConfigPath() {
+    return path.join(homedir(), '.agent', 'workspace.yaml');
+}
+/**
+ * Creates `~/.agent/workspace.yaml` if absent. Idempotent — second call
+ * returns `existing` without touching the file.
+ */
+export async function scaffoldWorkspaceConfig(opts) {
+    const configPath = opts?.configPath ?? defaultWorkspaceConfigPath();
+    const _exists = opts?.exists ?? existsSync;
+    const _mkdir = opts?.mkdir ?? mkdirSync;
+    const _writeFile = opts?.writeFile ?? writeFileSync;
+    if (_exists(configPath)) {
+        return { action: 'existing' };
+    }
+    _mkdir(path.dirname(configPath), { recursive: true });
+    _writeFile(configPath, WORKSPACE_YAML_TEMPLATE, 'utf8');
+    return { action: 'created' };
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/cli/commands/lint.d.ts

@@ -0,0 +1,4 @@
+import type { CAC } from 'cac';
+export declare const LINT_COMMAND_HELP: string;
+export declare function registerLintCommand(cli: CAC): void;
+//# sourceMappingURL=lint.d.ts.map

package/dist/esm/cli/commands/lint.js

@@ -0,0 +1,40 @@
+import { runLint } from '#lint/index';
+export const LINT_COMMAND_HELP = [
+    'Lint via the `vp lint` facade.',
+    '',
+    'Examples:',
+    '  wp lint',
+    '  wp lint --fix',
+].join('\n');
+export function registerLintCommand(cli) {
+    cli
+        .command('lint [...files]', LINT_COMMAND_HELP)
+        .option('--fix', 'Apply autofixes via vp lint --fix')
+        .action(async (files, flags) => {
+        const result = await runLint({
+            files: files && files.length > 0 ? files : undefined,
+            fix: Boolean(flags.fix),
+            cwd: process.cwd(),
+        });
+        if (result.spawnError) {
+            console.error(result.spawnError);
+            return result.exitCode || 1;
+        }
+        if (result.parseError) {
+            console.error(`lint output parse error: ${result.parseError}`);
+        }
+        if (result.issues.length > 0) {
+            for (const issue of result.issues) {
+                console.error(`${issue.file}:${issue.line}  [${issue.rule}]  ${issue.message}`);
+            }
+        }
+        if (result.output) {
+            process.stderr.write(result.output);
+        }
+        const verb = result.passed ? 'passed' : 'failed';
+        const detail = result.issues.length > 0 ? ` (${result.issues.length} issue(s))` : '';
+        console.error(`lint ${verb} via vp lint${detail}`);
+        return result.exitCode;
+    });
+}
+//# sourceMappingURL=lint.js.map

package/dist/esm/cli/commands/mcp.d.ts

@@ -0,0 +1,4 @@
+import type { CAC } from 'cac';
+export declare const MCP_COMMAND_HELP: string;
+export declare function registerMcpCommand(cli: CAC): void;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/esm/cli/commands/mcp.js

@@ -0,0 +1,18 @@
+import { runStdioServer } from '#mcp/cli';
+export const MCP_COMMAND_HELP = [
+    'Run the webpresso MCP server (stdio transport).',
+    '',
+    'Speaks the Model Context Protocol over stdin/stdout. Intended to be invoked',
+    'by a Claude Code plugin manifest entry (`mcpServers.webpresso`) or any MCP',
+    'client. Tools are auto-discovered from `dist/esm/mcp/tools/*.js`.',
+    '',
+    'Examples:',
+    '  wp mcp',
+].join('\n');
+export function registerMcpCommand(cli) {
+    cli.command('mcp', MCP_COMMAND_HELP).action(async () => {
+        await runStdioServer();
+        return 0;
+    });
+}
+//# sourceMappingURL=mcp.js.map

package/dist/esm/cli/commands/roadmap.d.ts

@@ -0,0 +1,7 @@
+import type { CAC } from 'cac';
+import type { ShowBlueprintResult } from './blueprint/router.js';
+export declare function getRoadmapHelpText(): string;
+export declare function assertParentRoadmap(result: ShowBlueprintResult): ShowBlueprintResult;
+export declare function formatRoadmapDetails(result: ShowBlueprintResult, childResults: readonly ShowBlueprintResult[]): string;
+export declare function registerRoadmapCommand(cli: CAC): void;
+//# sourceMappingURL=roadmap.d.ts.map

package/dist/esm/cli/commands/roadmap.js

@@ -0,0 +1,79 @@
+import { buildRoadmapModel } from '#local';
+import { listBlueprints, showBlueprint } from './blueprint/router.js';
+import { formatBlueprintDetails, formatBlueprintSummaries, printBlueprintOutput, } from './blueprint/router-output.js';
+const ROADMAP_HELP = ['wp roadmap', '', 'Commands:', '  list [status]', '  show <slug>'].join('\n');
+export function getRoadmapHelpText() {
+    return ROADMAP_HELP;
+}
+export function assertParentRoadmap(result) {
+    if (result.blueprint.type !== 'parent-roadmap') {
+        throw new Error(`Blueprint ${result.slug} is type=${result.blueprint.type}, not type=parent-roadmap. Use 'wp blueprint show ${result.slug}' instead.`);
+    }
+    return result;
+}
+export function formatRoadmapDetails(result, childResults) {
+    const childLines = childResults.length > 0
+        ? childResults.map((child) => `- ${child.slug} status=${child.blueprint.status} tasks=${child.blueprint.tasks.filter((task) => task.status === 'done').length}/${child.blueprint.tasks.length} done`)
+        : ['- No child blueprints declared'];
+    const blockerLines = childResults.flatMap((child) => child.blueprint.tasks
+        .filter((task) => task.status === 'blocked')
+        .map((task) => `- ${child.slug} Task ${task.id}: ${task.blockedReason ?? task.title}`));
+    return [
+        formatBlueprintDetails(result),
+        '',
+        'children:',
+        ...childLines,
+        '',
+        'blockers:',
+        ...(blockerLines.length > 0 ? blockerLines : ['- None']),
+    ].join('\n');
+}
+export function registerRoadmapCommand(cli) {
+    cli
+        .command('roadmap [subcommand] [...args]', 'List or show parent roadmaps')
+        .option('--json', 'Emit JSON output')
+        .option('--project-root <path>', 'Override the project root')
+        .action(async (subcommand, args, options) => {
+        switch (subcommand) {
+            case undefined:
+                printBlueprintOutput(ROADMAP_HELP, false);
+                return;
+            case 'list': {
+                if (args.length > 1) {
+                    throw new Error('Usage: wp roadmap list [status]');
+                }
+                const summaries = await listBlueprints({
+                    json: options.json,
+                    onlyRoadmaps: true,
+                    projectRoot: options.projectRoot,
+                    status: args[0],
+                });
+                printBlueprintOutput(options.json ? summaries : formatBlueprintSummaries(summaries), options.json);
+                return;
+            }
+            case 'show': {
+                const slug = args[0];
+                if (!slug) {
+                    throw new Error('Usage: wp roadmap show <slug>');
+                }
+                const result = assertParentRoadmap(await showBlueprint(slug, { json: options.json, projectRoot: options.projectRoot }));
+                const summaries = await listBlueprints({ projectRoot: options.projectRoot });
+                const model = buildRoadmapModel(summaries);
+                const roadmapNode = model.roadmaps.find((entry) => entry.roadmap.name === result.slug ||
+                    entry.roadmap.name === result.blueprint.name ||
+                    entry.roadmap.name.endsWith(`/${result.slug}`));
+                const childResults = [];
+                for (const child of roadmapNode?.children ?? []) {
+                    childResults.push(await showBlueprint(child.name, { projectRoot: options.projectRoot }));
+                }
+                printBlueprintOutput(options.json
+                    ? { ...result, children: childResults }
+                    : formatRoadmapDetails(result, childResults), options.json);
+                return;
+            }
+            default:
+                throw new Error(`Unknown roadmap subcommand: ${subcommand}\n\nUse one of: list, show`);
+        }
+    });
+}
+//# sourceMappingURL=roadmap.js.map

package/dist/esm/cli/commands/rule.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `wp rule <new|list|show|deprecate>` — thin shim over shared content
+ * dispatch in `src/content/dispatch.ts`. Handles consumer-owned rules at
+ * `<repo>/agent-rules/<slug>.md`.
+ */
+import type { CAC } from 'cac';
+export declare function registerRuleCommand(cli: CAC): void;
+//# sourceMappingURL=rule.d.ts.map

package/dist/esm/cli/commands/rule.js

@@ -0,0 +1,59 @@
+/**
+ * `wp rule <new|list|show|deprecate>` — thin shim over shared content
+ * dispatch in `src/content/dispatch.ts`. Handles consumer-owned rules at
+ * `<repo>/agent-rules/<slug>.md`.
+ */
+import { dispatchContent } from '#content/dispatch';
+import { resolvePackageAsset } from '#utils/package-assets';
+const VALID_SUBS = ['new', 'list', 'show', 'deprecate'];
+function isValidSub(value) {
+    return VALID_SUBS.includes(value);
+}
+function isValidSource(value) {
+    return value === undefined || value === 'canonical' || value === 'consumer';
+}
+export function registerRuleCommand(cli) {
+    cli
+        .command('rule <subcommand> [...args]', 'Manage consumer rules (new|list|show|deprecate)')
+        .option('--source <s>', 'Filter list by source: canonical | consumer')
+        .option('--scope <s>', 'Scope for new: repo | package:<name> | path:<glob>')
+        .option('--title <text>', 'Title for new')
+        .option('--reason <text>', 'Reason for deprecate')
+        .option('--dry-run', 'Plan without writing')
+        .action(async (subcommand, args, options) => {
+        if (!isValidSub(subcommand)) {
+            const err = new Error(`Unknown rule subcommand: ${subcommand}. Use one of: ${VALID_SUBS.join(', ')}.`);
+            err.exitCode = 1;
+            throw err;
+        }
+        if (!isValidSource(options.source)) {
+            const err = new Error(`Invalid --source: ${options.source}. Must be canonical or consumer.`);
+            err.exitCode = 1;
+            throw err;
+        }
+        const result = await dispatchContent({
+            kind: 'rule',
+            sub: subcommand,
+            args,
+            options: {
+                cwd: process.cwd(),
+                catalogDir: resolvePackageAsset('catalog/agent'),
+                ...(options.source ? { source: options.source } : {}),
+                ...(options.scope ? { scope: options.scope } : {}),
+                ...(options.title ? { title: options.title } : {}),
+                ...(options.reason ? { reason: options.reason } : {}),
+                ...(options.dryRun ? { dryRun: options.dryRun } : {}),
+            },
+        });
+        if (result.stdout)
+            console.log(result.stdout);
+        if (result.stderr)
+            console.error(result.stderr);
+        if (result.exitCode !== 0) {
+            const err = new Error(result.stderr || 'rule command failed');
+            err.exitCode = result.exitCode;
+            throw err;
+        }
+    });
+}
+//# sourceMappingURL=rule.js.map

package/dist/esm/cli/commands/skill.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `wp skill <new|list|show|deprecate|install|uninstall>` — thin shim over
+ * shared content dispatch with two extra registry actions:
+ *
+ *   install <name>     — adds <name> to .webpressorc.json#installed.tier3Skills
+ *                        (the skill must exist in the bundled catalog).
+ *                        Idempotent. Registry-only edit; no copy.
+ *   uninstall <name>   — removes <name> from the registry. Idempotent.
+ *
+ * `wp skills` (plural) was renamed to `wp skill` (singular) in 0.4.0. The
+ * old plural is wired separately as a hidden helpful-error stub (see cli.ts).
+ */
+import type { CAC } from 'cac';
+export declare function registerSkillCommand(cli: CAC): void;
+/**
+ * Hidden stub for the renamed `wp skills` (plural). cac will still match
+ * the command, but we just emit a helpful redirect and exit 1.
+ */
+export declare function registerSkillsRenameStub(cli: CAC): void;
+//# sourceMappingURL=skill.d.ts.map

package/dist/esm/cli/commands/skill.js

@@ -0,0 +1,160 @@
+/**
+ * `wp skill <new|list|show|deprecate|install|uninstall>` — thin shim over
+ * shared content dispatch with two extra registry actions:
+ *
+ *   install <name>     — adds <name> to .webpressorc.json#installed.tier3Skills
+ *                        (the skill must exist in the bundled catalog).
+ *                        Idempotent. Registry-only edit; no copy.
+ *   uninstall <name>   — removes <name> from the registry. Idempotent.
+ *
+ * `wp skills` (plural) was renamed to `wp skill` (singular) in 0.4.0. The
+ * old plural is wired separately as a hidden helpful-error stub (see cli.ts).
+ */
+import { dispatchContent } from '#content/dispatch';
+import { loadContent } from '#content/loader';
+import { resolvePackageAsset } from '#utils/package-assets';
+import { findOrphanedSkills, removeOrphanedSkills } from '#compiler/orphans';
+import { defaultConfig, mergeConfig, readConfig, writeConfig, } from './init/config.js';
+const SHARED_SUBS = ['new', 'list', 'show', 'deprecate'];
+const REGISTRY_SUBS = ['install', 'uninstall'];
+const VALID_SUBS = [...SHARED_SUBS, ...REGISTRY_SUBS, 'orphans'];
+function isValidSub(value) {
+    return VALID_SUBS.includes(value);
+}
+function isContentSub(value) {
+    return SHARED_SUBS.includes(value);
+}
+async function handleOrphans(cwd, fix, dryRun) {
+    const orphans = findOrphanedSkills(cwd);
+    if (orphans.length === 0) {
+        console.log('No orphaned skills found.');
+        return;
+    }
+    console.log(`Found ${orphans.length} orphaned skill(s):`);
+    for (const o of orphans) {
+        console.log(`  ${o.runtimeDir}/${o.name}  (${o.path})`);
+    }
+    if (fix) {
+        await removeOrphanedSkills(orphans, dryRun);
+        if (dryRun) {
+            console.log(`[dry-run] Would remove ${orphans.length} orphaned skill(s).`);
+        }
+        else {
+            console.log(`Removed ${orphans.length} orphaned skill(s).`);
+        }
+    }
+}
+function isValidSource(value) {
+    return value === undefined || value === 'canonical' || value === 'consumer';
+}
+function commandError(message, exitCode = 1) {
+    const err = new Error(message);
+    err.exitCode = exitCode;
+    return err;
+}
+function catalogContainsSkill(catalogDir, name) {
+    const result = loadContent({ catalogDir, kinds: ['skill'] });
+    return result.records.some((r) => r.source === 'canonical' && r.slug === name);
+}
+function withRegistry(cwd, mutate) {
+    const existing = readConfig(cwd);
+    const base = existing ?? defaultConfig();
+    const before = [...base.installed.tier3Skills];
+    const next = mutate(before);
+    const incoming = {
+        ...base,
+        installed: { tier3Skills: next.toSorted() },
+    };
+    const merged = existing ? { ...existing, installed: { tier3Skills: next.toSorted() } } : incoming;
+    const changed = before.length !== merged.installed.tier3Skills.length ||
+        before.toSorted().join(',') !== merged.installed.tier3Skills.join(',');
+    writeConfig(cwd, mergeConfig(existing, merged));
+    return { config: merged, changed };
+}
+function handleInstall(name, catalogDir, cwd) {
+    if (!name)
+        throw commandError('Usage: wp skill install <name>');
+    if (!catalogContainsSkill(catalogDir, name)) {
+        throw commandError(`Skill not found in bundled catalog: ${name}. Run \`wp skill list --source canonical\` to see available skills.`);
+    }
+    const { config, changed } = withRegistry(cwd, (skills) => skills.includes(name) ? skills : [...skills, name]);
+    console.log(`${changed ? 'Installed' : 'Already installed'} skill ${name} → .webpressorc.json#installed.tier3Skills`);
+    console.log(`installed.tier3Skills: ${JSON.stringify(config.installed.tier3Skills)}`);
+}
+function handleUninstall(name, cwd) {
+    if (!name)
+        throw commandError('Usage: wp skill uninstall <name>');
+    const { config, changed } = withRegistry(cwd, (skills) => skills.filter((s) => s !== name));
+    console.log(`${changed ? 'Uninstalled' : 'Not installed'} skill ${name} from .webpressorc.json#installed.tier3Skills`);
+    console.log(`installed.tier3Skills: ${JSON.stringify(config.installed.tier3Skills)}`);
+}
+export function registerSkillCommand(cli) {
+    cli
+        .command('skill <subcommand> [...args]', 'Manage consumer skills (new|list|show|deprecate|install|uninstall|orphans)')
+        .option('--source <s>', 'Filter list by source: canonical | consumer')
+        .option('--scope <s>', 'Scope for new: repo | package:<name> | path:<glob>')
+        .option('--title <text>', 'Title for new')
+        .option('--reason <text>', 'Reason for deprecate')
+        .option('--dry-run', 'Plan without writing')
+        .option('--fix', 'Remove orphaned generated skills (for orphans subcommand)')
+        .action(async (subcommand, args, options) => {
+        if (!isValidSub(subcommand)) {
+            throw commandError(`Unknown skill subcommand: ${subcommand}. Use one of: ${VALID_SUBS.join(', ')}.`);
+        }
+        if (!isValidSource(options.source)) {
+            throw commandError(`Invalid --source: ${options.source}. Must be canonical or consumer.`);
+        }
+        const cwd = process.cwd();
+        const catalogDir = resolvePackageAsset('catalog/agent');
+        if (subcommand === 'orphans') {
+            await handleOrphans(cwd, options.fix ?? false, options.dryRun ?? false);
+            return;
+        }
+        if (subcommand === 'install') {
+            handleInstall(args[0] ?? '', catalogDir, cwd);
+            return;
+        }
+        if (subcommand === 'uninstall') {
+            handleUninstall(args[0] ?? '', cwd);
+            return;
+        }
+        if (!isContentSub(subcommand)) {
+            throw commandError(`Unknown skill subcommand: ${subcommand}`);
+        }
+        const result = await dispatchContent({
+            kind: 'skill',
+            sub: subcommand,
+            args,
+            options: {
+                cwd,
+                catalogDir,
+                ...(options.source ? { source: options.source } : {}),
+                ...(options.scope ? { scope: options.scope } : {}),
+                ...(options.title ? { title: options.title } : {}),
+                ...(options.reason ? { reason: options.reason } : {}),
+                ...(options.dryRun ? { dryRun: options.dryRun } : {}),
+            },
+        });
+        if (result.stdout)
+            console.log(result.stdout);
+        if (result.stderr)
+            console.error(result.stderr);
+        if (result.exitCode !== 0) {
+            throw commandError(result.stderr || 'skill command failed', result.exitCode);
+        }
+    });
+}
+/**
+ * Hidden stub for the renamed `wp skills` (plural). cac will still match
+ * the command, but we just emit a helpful redirect and exit 1.
+ */
+export function registerSkillsRenameStub(cli) {
+    cli
+        .command('skills [...args]', 'Removed in 0.4.0 — use `wp skill`')
+        .allowUnknownOptions()
+        .action(() => {
+        throw commandError("'wp skills' was renamed to 'wp skill' in 0.4.0. " +
+            'Use: wp skill <subcommand>. See `wp skill --help`.');
+    });
+}
+//# sourceMappingURL=skill.js.map

package/dist/esm/cli/commands/sync.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `wp sync` — projects the canonical webpresso rule/skill catalog into the
+ * supported host surfaces.
+ *
+ * Projects unified rule + skill content (catalog ∪ consumer) into per-IDE
+ * surfaces according to `DEFAULT_UNIFIED_CONSUMERS`.
+ *
+ * Flags:
+ *   --kind rules|skills   Filter to a single kind (default: both).
+ *   --check               Dry-run; exit 1 on first drift, no writes.
+ */
+import type { CAC } from 'cac';
+export declare function registerSyncCommand(cli: CAC): void;
+//# sourceMappingURL=sync.d.ts.map