@audiodn/agent-kit 0.1.0

package/assets/snapshots/sources.json

@@ -0,0 +1,19 @@
+{
+  "openapiVersion": "1.0.0",
+  "generatedBy": "scripts/sync-canonical.mjs",
+  "note": "Seeded from the canonical monorepo openapi.json (ahead of the current public deploy). scripts/sync-canonical.mjs refreshes from https://audiodeliverynetwork.com once redeployed.",
+  "sources": [
+    {
+      "name": "openapi.json",
+      "url": "https://audiodeliverynetwork.com/openapi.json",
+      "fetchedAt": "2026-07-13",
+      "sha256": "e1554673a4d7287a15460bdc2761e0bbc38286b4e101df26b00fc5e9205e2deb"
+    },
+    {
+      "name": "llms-full.txt",
+      "url": "https://audiodeliverynetwork.com/llms-full.txt",
+      "fetchedAt": "2026-07-13",
+      "sha256": "41980ad7654d997132683399b6a4ab38fce87944ebb9c5cf1779daea996d18af"
+    }
+  ]
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import { runInit } from './commands/init.js';
+import { runList } from './commands/list.js';
+import { runUninstall } from './commands/uninstall.js';
+import { runValidate } from './commands/validate.js';
+import { getVersion } from './version.js';
+const VALUE_FLAGS = new Set(['formats', 'cwd', 'severity', 'path']);
+function parseArgs(argv) {
+    const _ = [];
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg.startsWith('--')) {
+            const eq = arg.indexOf('=');
+            if (eq !== -1) {
+                flags[arg.slice(2, eq)] = arg.slice(eq + 1);
+            }
+            else {
+                const key = arg.slice(2);
+                if (VALUE_FLAGS.has(key) && i + 1 < argv.length && !argv[i + 1].startsWith('-')) {
+                    flags[key] = argv[++i];
+                }
+                else {
+                    flags[key] = true;
+                }
+            }
+        }
+        else if (arg.startsWith('-') && arg.length > 1) {
+            for (const ch of arg.slice(1))
+                flags[ch] = true;
+        }
+        else {
+            _.push(arg);
+        }
+    }
+    return { _, flags };
+}
+const HELP = `@audiodn/agent-kit — AudioDN guidance for AI coding agents
+
+Usage:
+  npx @audiodn/agent-kit <command> [options]
+
+Commands:
+  init                 Install AudioDN guidance (merge-safe, idempotent)
+  validate [path]      Scan a project for common AudioDN mistakes
+  uninstall            Remove managed blocks / kit-owned files only
+  list                 Show formats and bundled documentation versions
+
+Options:
+  -y, --yes            Non-interactive; install all formats unless --formats given
+  --formats <ids>      Comma-separated: agents,claude,copilot,cursor,skill (or "all")
+  --dry-run            Report actions without writing
+  --force              Overwrite unmanaged conflicts
+  --cwd <dir>          Target directory (default: current directory)
+  --json               (validate) Output findings as JSON
+  -v, --version        Print version
+  -h, --help           Show this help
+`;
+async function main() {
+    const { _, flags } = parseArgs(process.argv.slice(2));
+    const cmd = _[0];
+    const cwd = flags.cwd || process.cwd();
+    if (flags.version || flags.v) {
+        console.log(getVersion());
+        return 0;
+    }
+    if (!cmd || flags.help || flags.h || cmd === 'help') {
+        console.log(HELP);
+        return 0;
+    }
+    switch (cmd) {
+        case 'init':
+            return runInit({
+                cwd,
+                yes: Boolean(flags.yes || flags.y),
+                dryRun: Boolean(flags['dry-run']),
+                force: Boolean(flags.force),
+                formats: typeof flags.formats === 'string' ? flags.formats : undefined,
+            });
+        case 'validate':
+            return runValidate({ path: _[1] || cwd, json: Boolean(flags.json) });
+        case 'uninstall':
+            return runUninstall({
+                cwd,
+                dryRun: Boolean(flags['dry-run']),
+                formats: typeof flags.formats === 'string' ? flags.formats : undefined,
+            });
+        case 'list':
+            return runList();
+        default:
+            console.error(`Unknown command: ${cmd}\n`);
+            console.log(HELP);
+            return 1;
+    }
+}
+main()
+    .then((code) => process.exit(code))
+    .catch((err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/commands/init.d.ts

@@ -0,0 +1,8 @@
+export interface InitArgs {
+    cwd: string;
+    yes: boolean;
+    dryRun: boolean;
+    force: boolean;
+    formats?: string;
+}
+export declare function runInit(args: InitArgs): Promise<number>;

package/dist/commands/init.js

@@ -0,0 +1,35 @@
+import { ALL_FORMAT_IDS, parseFormatList } from '../core/formats.js';
+import { installFormats } from '../core/install.js';
+import { promptFormats } from '../core/prompt.js';
+import { hasConflicts, printReport } from '../core/report.js';
+import { getVersion } from '../version.js';
+export async function runInit(args) {
+    let ids;
+    if (args.formats) {
+        const { ids: parsed, unknown } = parseFormatList(args.formats);
+        if (unknown.length) {
+            console.error(`Unknown format(s): ${unknown.join(', ')}. Valid: ${ALL_FORMAT_IDS.join(', ')}, all`);
+            return 1;
+        }
+        ids = parsed.length ? parsed : [...ALL_FORMAT_IDS];
+    }
+    else if (args.yes) {
+        ids = [...ALL_FORMAT_IDS];
+    }
+    else {
+        ids = await promptFormats();
+    }
+    if (ids.length === 0) {
+        console.log('No formats selected. Nothing to do.');
+        return 0;
+    }
+    const entries = installFormats({
+        cwd: args.cwd,
+        version: getVersion(),
+        formats: ids,
+        dryRun: args.dryRun,
+        force: args.force,
+    });
+    printReport(entries, { dryRun: args.dryRun });
+    return hasConflicts(entries) && !args.force ? 2 : 0;
+}

package/dist/commands/list.d.ts

@@ -0,0 +1 @@
+export declare function runList(): number;

package/dist/commands/list.js

@@ -0,0 +1,28 @@
+import { join } from 'node:path';
+import { FORMATS } from '../core/formats.js';
+import { readIfExists } from '../core/fsutil.js';
+import { SNAPSHOTS_DIR } from '../paths.js';
+import { getVersion } from '../version.js';
+export function runList() {
+    console.log(`@audiodn/agent-kit v${getVersion()}`);
+    console.log('\nFormats:');
+    for (const f of FORMATS) {
+        const target = f.kind === 'skill' ? `${f.target}/` : f.target;
+        console.log(`  ${f.id.padEnd(8)} -> ${target}  (${f.label})`);
+    }
+    const raw = readIfExists(join(SNAPSHOTS_DIR, 'sources.json'));
+    if (raw) {
+        try {
+            const s = JSON.parse(raw);
+            console.log('\nBundled canonical snapshots:');
+            console.log(`  OpenAPI version: ${s.openapiVersion ?? 'unknown'}`);
+            for (const src of s.sources ?? []) {
+                console.log(`  - ${src.name} (${src.url}) fetched ${src.fetchedAt ?? 'unknown'}`);
+            }
+        }
+        catch {
+            /* ignore malformed snapshot manifest */
+        }
+    }
+    return 0;
+}

package/dist/commands/uninstall.d.ts

@@ -0,0 +1,6 @@
+export interface UninstallArgs {
+    cwd: string;
+    dryRun: boolean;
+    formats?: string;
+}
+export declare function runUninstall(args: UninstallArgs): number;

package/dist/commands/uninstall.js

@@ -0,0 +1,20 @@
+import { ALL_FORMAT_IDS, parseFormatList } from '../core/formats.js';
+import { uninstallFormats } from '../core/install.js';
+import { printReport } from '../core/report.js';
+export function runUninstall(args) {
+    let ids;
+    if (args.formats) {
+        const { ids: parsed, unknown } = parseFormatList(args.formats);
+        if (unknown.length) {
+            console.error(`Unknown format(s): ${unknown.join(', ')}.`);
+            return 1;
+        }
+        ids = parsed.length ? parsed : [...ALL_FORMAT_IDS];
+    }
+    else {
+        ids = [...ALL_FORMAT_IDS];
+    }
+    const entries = uninstallFormats({ cwd: args.cwd, formats: ids, dryRun: args.dryRun });
+    printReport(entries, { dryRun: args.dryRun });
+    return 0;
+}

package/dist/commands/validate.d.ts

@@ -0,0 +1,5 @@
+export interface ValidateArgs {
+    path: string;
+    json: boolean;
+}
+export declare function runValidate(args: ValidateArgs): Promise<number>;

package/dist/commands/validate.js

@@ -0,0 +1,18 @@
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { SKILL_DIR } from '../paths.js';
+// The validator implementation lives in the portable Skill payload so it can be
+// run standalone (without the kit) once installed. We import it here to avoid
+// duplicating the rule logic.
+export async function runValidate(args) {
+    const validatorUrl = pathToFileURL(join(SKILL_DIR, 'scripts', 'validate.mjs')).href;
+    const mod = await import(validatorUrl);
+    const result = await mod.runValidation(resolve(args.path), {});
+    if (args.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        mod.printFindings(result);
+    }
+    return result.errorCount > 0 ? 1 : 0;
+}

package/dist/core/formats.d.ts

@@ -0,0 +1,23 @@
+export type FormatId = 'agents' | 'claude' | 'copilot' | 'cursor' | 'skill';
+export interface BlockFormat {
+    id: Exclude<FormatId, 'skill'>;
+    label: string;
+    kind: 'block';
+    target: string;
+    appendIfUnmanaged: boolean;
+    preambleOnCreate?: string;
+}
+export interface SkillFormat {
+    id: 'skill';
+    label: string;
+    kind: 'skill';
+    target: string;
+}
+export type Format = BlockFormat | SkillFormat;
+export declare const FORMATS: Format[];
+export declare const ALL_FORMAT_IDS: FormatId[];
+export declare function resolveFormats(ids: FormatId[]): Format[];
+export declare function parseFormatList(value: string): {
+    ids: FormatId[];
+    unknown: string[];
+};

package/dist/core/formats.js

@@ -0,0 +1,43 @@
+const CURSOR_FRONTMATTER = `---
+description: AudioDN integration guidance for AI coding agents (auth, upload flow, processing readiness, playback, security).
+globs:
+alwaysApply: false
+---`;
+export const FORMATS = [
+    { id: 'agents', label: 'AGENTS.md', kind: 'block', target: 'AGENTS.md', appendIfUnmanaged: true },
+    { id: 'claude', label: 'CLAUDE.md', kind: 'block', target: 'CLAUDE.md', appendIfUnmanaged: true },
+    {
+        id: 'copilot',
+        label: 'GitHub Copilot',
+        kind: 'block',
+        target: '.github/copilot-instructions.md',
+        appendIfUnmanaged: true,
+    },
+    {
+        id: 'cursor',
+        label: 'Cursor rule',
+        kind: 'block',
+        target: '.cursor/rules/audiodn.mdc',
+        appendIfUnmanaged: false,
+        preambleOnCreate: CURSOR_FRONTMATTER,
+    },
+    { id: 'skill', label: 'AudioDN Skill', kind: 'skill', target: '.agents/skills/audiodn' },
+];
+export const ALL_FORMAT_IDS = FORMATS.map((f) => f.id);
+export function resolveFormats(ids) {
+    return FORMATS.filter((f) => ids.includes(f.id));
+}
+export function parseFormatList(value) {
+    const ids = [];
+    const unknown = [];
+    for (const raw of value.split(',').map((s) => s.trim()).filter(Boolean)) {
+        if (raw === 'all') {
+            return { ids: [...ALL_FORMAT_IDS], unknown: [] };
+        }
+        if (ALL_FORMAT_IDS.includes(raw))
+            ids.push(raw);
+        else
+            unknown.push(raw);
+    }
+    return { ids, unknown };
+}

package/dist/core/fsutil.d.ts

@@ -0,0 +1,5 @@
+export declare function sha256(input: string | Buffer): string;
+export declare function readIfExists(path: string): string | null;
+export declare function writeFileEnsuringDir(path: string, content: string): void;
+export declare function listFilesRecursive(root: string): string[];
+export declare function relativeFiles(root: string): string[];

package/dist/core/fsutil.js

@@ -0,0 +1,34 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+export function sha256(input) {
+    return createHash('sha256').update(input).digest('hex');
+}
+export function readIfExists(path) {
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+export function writeFileEnsuringDir(path, content) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content, 'utf8');
+}
+export function listFilesRecursive(root) {
+    const out = [];
+    if (!existsSync(root))
+        return out;
+    for (const name of readdirSync(root)) {
+        const full = join(root, name);
+        if (statSync(full).isDirectory())
+            out.push(...listFilesRecursive(full));
+        else
+            out.push(full);
+    }
+    return out;
+}
+export function relativeFiles(root) {
+    return listFilesRecursive(root).map((f) => relative(root, f).split('\\').join('/'));
+}

package/dist/core/install.d.ts

@@ -0,0 +1,16 @@
+import type { FormatId } from './formats.js';
+import type { ReportEntry } from './report.js';
+export interface InstallOptions {
+    cwd: string;
+    version: string;
+    formats: FormatId[];
+    dryRun?: boolean;
+    force?: boolean;
+}
+export declare function installFormats(opts: InstallOptions): ReportEntry[];
+export interface UninstallOptions {
+    cwd: string;
+    formats: FormatId[];
+    dryRun?: boolean;
+}
+export declare function uninstallFormats(opts: UninstallOptions): ReportEntry[];

package/dist/core/install.js

@@ -0,0 +1,76 @@
+import { rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { FORMATS } from './formats.js';
+import { readIfExists, writeFileEnsuringDir } from './fsutil.js';
+import { mergeBlock, removeBlock } from './merge.js';
+import { buildGuidanceBody } from './render.js';
+import { installSkill, uninstallSkill } from './skill.js';
+export function installFormats(opts) {
+    const body = buildGuidanceBody();
+    const entries = [];
+    const selected = FORMATS.filter((f) => opts.formats.includes(f.id));
+    for (const fmt of selected) {
+        if (fmt.kind === 'skill') {
+            entries.push(...installSkill(opts.cwd, opts.version, { dryRun: opts.dryRun, force: opts.force }));
+            continue;
+        }
+        const target = join(opts.cwd, fmt.target);
+        const existing = readIfExists(target);
+        const result = mergeBlock(existing, opts.version, body, {
+            preambleOnCreate: fmt.preambleOnCreate,
+            appendIfUnmanaged: fmt.appendIfUnmanaged,
+        });
+        if (result.action === 'conflict') {
+            const fresh = mergeBlock(null, opts.version, body, {
+                preambleOnCreate: fmt.preambleOnCreate,
+                appendIfUnmanaged: fmt.appendIfUnmanaged,
+            }).content;
+            if (opts.force) {
+                if (!opts.dryRun)
+                    writeFileEnsuringDir(target, fresh);
+                entries.push({ path: fmt.target, action: 'update', note: 'forced overwrite' });
+            }
+            else {
+                if (!opts.dryRun)
+                    writeFileEnsuringDir(`${target}.audiodn.new`, fresh);
+                entries.push({ path: fmt.target, action: 'conflict', note: 'wrote .audiodn.new' });
+            }
+            continue;
+        }
+        if (result.content !== null && result.action !== 'unchanged' && !opts.dryRun) {
+            writeFileEnsuringDir(target, result.content);
+        }
+        entries.push({ path: fmt.target, action: result.action });
+    }
+    return entries;
+}
+export function uninstallFormats(opts) {
+    const entries = [];
+    const selected = FORMATS.filter((f) => opts.formats.includes(f.id));
+    for (const fmt of selected) {
+        if (fmt.kind === 'skill') {
+            entries.push(...uninstallSkill(opts.cwd, { dryRun: opts.dryRun }));
+            continue;
+        }
+        const target = join(opts.cwd, fmt.target);
+        const existing = readIfExists(target);
+        if (existing === null)
+            continue;
+        const { content, changed } = removeBlock(existing);
+        if (!changed) {
+            entries.push({ path: fmt.target, action: 'skipped', note: 'no managed block' });
+            continue;
+        }
+        if (content.trim() === '') {
+            if (!opts.dryRun)
+                rmSync(target);
+            entries.push({ path: fmt.target, action: 'removed' });
+        }
+        else {
+            if (!opts.dryRun)
+                writeFileEnsuringDir(target, content);
+            entries.push({ path: fmt.target, action: 'removed', note: 'kept your content' });
+        }
+    }
+    return entries;
+}

package/dist/core/markers.d.ts

@@ -0,0 +1,5 @@
+export declare const END_MARKER = "<!-- AUDIODN:END -->";
+export declare const BLOCK_RE: RegExp;
+export declare function beginMarker(version: string): string;
+export declare function buildBlock(version: string, body: string): string;
+export declare function hasBlock(content: string): boolean;

package/dist/core/markers.js

@@ -0,0 +1,13 @@
+export const END_MARKER = '<!-- AUDIODN:END -->';
+// Matches a managed block regardless of the version recorded in the BEGIN marker.
+export const BLOCK_RE = /<!-- AUDIODN:BEGIN[\s\S]*?<!-- AUDIODN:END -->/;
+export function beginMarker(version) {
+    return `<!-- AUDIODN:BEGIN v${version} (managed by @audiodn/agent-kit — do not edit inside) -->`;
+}
+export function buildBlock(version, body) {
+    return `${beginMarker(version)}\n${body.trim()}\n${END_MARKER}`;
+}
+export function hasBlock(content) {
+    BLOCK_RE.lastIndex = 0;
+    return BLOCK_RE.test(content);
+}

package/dist/core/merge.d.ts

@@ -0,0 +1,21 @@
+export type MergeAction = 'create' | 'update' | 'unchanged' | 'append' | 'conflict';
+export interface MergeResult {
+    content: string | null;
+    action: MergeAction;
+}
+export interface MergeOptions {
+    preambleOnCreate?: string;
+    appendIfUnmanaged: boolean;
+}
+/**
+ * Merge a managed block into (possibly existing) file content without ever
+ * clobbering user content outside the block.
+ */
+export declare function mergeBlock(existing: string | null, version: string, body: string, opts: MergeOptions): MergeResult;
+/**
+ * Remove the managed block. Returns changed=false if there was no block.
+ */
+export declare function removeBlock(existing: string): {
+    content: string;
+    changed: boolean;
+};

package/dist/core/merge.js

@@ -0,0 +1,38 @@
+import { BLOCK_RE, buildBlock, hasBlock } from './markers.js';
+/**
+ * Merge a managed block into (possibly existing) file content without ever
+ * clobbering user content outside the block.
+ */
+export function mergeBlock(existing, version, body, opts) {
+    const block = buildBlock(version, body);
+    if (existing === null) {
+        const preamble = opts.preambleOnCreate ? `${opts.preambleOnCreate.replace(/\n*$/, '')}\n\n` : '';
+        return { content: `${preamble}${block}\n`, action: 'create' };
+    }
+    if (hasBlock(existing)) {
+        const replaced = existing.replace(BLOCK_RE, block);
+        if (replaced === existing)
+            return { content: existing, action: 'unchanged' };
+        return { content: replaced, action: 'update' };
+    }
+    if (opts.appendIfUnmanaged) {
+        const sep = existing.endsWith('\n') ? '\n' : '\n\n';
+        return { content: `${existing}${sep}${block}\n`, action: 'append' };
+    }
+    return { content: null, action: 'conflict' };
+}
+/**
+ * Remove the managed block. Returns changed=false if there was no block.
+ */
+export function removeBlock(existing) {
+    if (!hasBlock(existing))
+        return { content: existing, changed: false };
+    let out = existing.replace(BLOCK_RE, '');
+    // Tidy the whitespace left behind.
+    out = out.replace(/\n{3,}/g, '\n\n').replace(/^\s+/, '');
+    if (out.trim().length > 0)
+        out = out.replace(/\s+$/, '') + '\n';
+    else
+        out = '';
+    return { content: out, changed: true };
+}

package/dist/core/prompt.d.ts

@@ -0,0 +1,2 @@
+import { type FormatId } from './formats.js';
+export declare function promptFormats(): Promise<FormatId[]>;

package/dist/core/prompt.js

@@ -0,0 +1,23 @@
+import { createInterface } from 'node:readline';
+import { ALL_FORMAT_IDS, FORMATS } from './formats.js';
+export async function promptFormats() {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const question = (q) => new Promise((res) => rl.question(q, res));
+    console.log('AudioDN Agent Kit — select formats to install:');
+    FORMATS.forEach((f, i) => console.log(`  ${i + 1}. ${f.id.padEnd(8)} ${f.label}`));
+    const ans = (await question('Enter comma-separated ids or numbers [all]: ')).trim();
+    rl.close();
+    if (!ans || ans.toLowerCase() === 'all')
+        return [...ALL_FORMAT_IDS];
+    const ids = [];
+    for (const token of ans.split(',').map((s) => s.trim()).filter(Boolean)) {
+        const num = Number(token);
+        if (Number.isInteger(num) && num >= 1 && num <= FORMATS.length) {
+            ids.push(FORMATS[num - 1].id);
+        }
+        else if (ALL_FORMAT_IDS.includes(token)) {
+            ids.push(token);
+        }
+    }
+    return [...new Set(ids)];
+}

package/dist/core/render.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Build the canonical guidance body shared by all block-format outputs. Single
+ * source of truth: assets/content/instructions.md with {{PARTIALS}} expanded.
+ */
+export declare function buildGuidanceBody(): string;

package/dist/core/render.js

@@ -0,0 +1,21 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CONTENT_DIR } from '../paths.js';
+const PARTIAL_ORDER = [
+    'auth',
+    'upload',
+    'processing',
+    'playback',
+    'webhooks',
+    'security',
+    'compatibility',
+];
+/**
+ * Build the canonical guidance body shared by all block-format outputs. Single
+ * source of truth: assets/content/instructions.md with {{PARTIALS}} expanded.
+ */
+export function buildGuidanceBody() {
+    const instructions = readFileSync(join(CONTENT_DIR, 'instructions.md'), 'utf8');
+    const partials = PARTIAL_ORDER.map((name) => readFileSync(join(CONTENT_DIR, 'partials', `${name}.md`), 'utf8').trim()).join('\n\n');
+    return instructions.replace('{{PARTIALS}}', partials).trim();
+}

package/dist/core/report.d.ts

@@ -0,0 +1,10 @@
+export type Action = 'create' | 'update' | 'unchanged' | 'append' | 'conflict' | 'removed' | 'skipped';
+export interface ReportEntry {
+    path: string;
+    action: Action;
+    note?: string;
+}
+export declare function printReport(entries: ReportEntry[], opts?: {
+    dryRun?: boolean;
+}): void;
+export declare function hasConflicts(entries: ReportEntry[]): boolean;

package/dist/core/report.js

@@ -0,0 +1,35 @@
+const SYMBOL = {
+    create: '+ created ',
+    update: '~ updated ',
+    append: '~ appended',
+    unchanged: '= unchanged',
+    conflict: '! conflict',
+    removed: '- removed ',
+    skipped: '. skipped ',
+};
+export function printReport(entries, opts = {}) {
+    const prefix = opts.dryRun ? '[dry-run] ' : '';
+    if (entries.length === 0) {
+        console.log(`${prefix}Nothing to do.`);
+        return;
+    }
+    for (const e of entries) {
+        const label = SYMBOL[e.action] ?? e.action;
+        const note = e.note ? `  (${e.note})` : '';
+        console.log(`${prefix}${label}  ${e.path}${note}`);
+    }
+    const counts = entries.reduce((acc, e) => {
+        acc[e.action] = (acc[e.action] ?? 0) + 1;
+        return acc;
+    }, {});
+    const summary = Object.entries(counts)
+        .map(([k, v]) => `${v} ${k}`)
+        .join(', ');
+    console.log(`${prefix}Summary: ${summary}`);
+    if (counts.conflict) {
+        console.log(`${prefix}Conflicts were written as *.audiodn.new — review and merge, or re-run with --force.`);
+    }
+}
+export function hasConflicts(entries) {
+    return entries.some((e) => e.action === 'conflict');
+}

package/dist/core/skill.d.ts

@@ -0,0 +1,13 @@
+import type { ReportEntry } from './report.js';
+export declare const SKILL_TARGET_DIR = ".agents/skills/audiodn";
+interface SkillOptions {
+    dryRun?: boolean;
+    force?: boolean;
+}
+/**
+ * Install the Skill payload directory. Kit-owned files are tracked in a
+ * manifest so re-runs are idempotent and user edits are never clobbered.
+ */
+export declare function installSkill(cwd: string, version: string, opts?: SkillOptions): ReportEntry[];
+export declare function uninstallSkill(cwd: string, opts?: SkillOptions): ReportEntry[];
+export {};