@shrkcrft/cli 0.1.0-alpha.1

package/dist/commands/search.command.js

@@ -0,0 +1,275 @@
+import { buildSearchIndex, entrypointBanner, explainSearchTuning, inspectSharkcraft, loadConstructs, loadPlaybooks, loadSearchTuning, renderSearchText, renderTuningExplainHtml, renderTuningExplainMarkdown, searchIndex, SearchKind, SearchSource, } from '@shrkcrft/inspector';
+import { flagBool, flagNumber, flagString, flagList, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+const VALID_KINDS = new Set(Object.values(SearchKind));
+const VALID_SOURCES = new Set(Object.values(SearchSource));
+function parseKinds(args) {
+    const list = flagList(args, 'type').concat(flagList(args, 'kind'));
+    if (list.length === 0)
+        return undefined;
+    const out = [];
+    for (const v of list) {
+        if (VALID_KINDS.has(v))
+            out.push(v);
+    }
+    return out;
+}
+function parseSources(args) {
+    const list = flagList(args, 'source');
+    if (list.length === 0)
+        return undefined;
+    const out = [];
+    for (const v of list) {
+        if (VALID_SOURCES.has(v))
+            out.push(v);
+    }
+    return out;
+}
+export const searchCommand = {
+    name: 'search',
+    description: 'Universal search across commands, MCP tools, knowledge, rules, paths, conventions, templates, helpers, playbooks, constructs, policies, decisions, scaffold patterns, contract templates, migration profiles, plugin lifecycle profiles, feedback rules, task routing hints, docs, recent reports. Default emits the 7-section unified output; pass --legacy for the flat output.',
+    usage: 'shrk search <query> [--kind <kind>] [--source local|pack|...] [--limit N] [--explain] [--commands-only] [--actions-only] [--format text|markdown|json] [--legacy]',
+    async run(args) {
+        // Sub-dispatch for `shrk search tuning [list|doctor]`.
+        if (args.positional[0] === 'tuning') {
+            const sliced = { ...args, positional: args.positional.slice(1) };
+            return searchTuningListCommand.run(sliced);
+        }
+        const query = args.positional.join(' ').trim();
+        if (!query) {
+            process.stderr.write('Usage: shrk search <query> [--kind ...] [--limit N] [--commands-only] [--actions-only] [--format text|markdown|json] | shrk search tuning [list|doctor]\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        // Universal search v2 is the default. Pass --legacy to get the
+        // flat output.
+        if (!flagBool(args, 'legacy')) {
+            const { buildUniversalSearch, renderUniversalSearchText, renderUniversalSearchMarkdown, } = await import('@shrkcrft/inspector');
+            const kindFilter = flagString(args, 'kind');
+            const sourceFilter = flagString(args, 'source');
+            const limit = flagNumber(args, 'limit');
+            const opts = {};
+            if (kindFilter)
+                opts.kind = kindFilter;
+            if (sourceFilter)
+                opts.source = sourceFilter;
+            if (limit)
+                opts.limit = limit;
+            if (flagBool(args, 'commands-only'))
+                opts.commandsOnly = true;
+            if (flagBool(args, 'actions-only'))
+                opts.actionsOnly = true;
+            const report = await buildUniversalSearch(inspection, query, opts);
+            const format = flagString(args, 'format') ?? 'text';
+            if (flagBool(args, 'json') || format === 'json') {
+                process.stdout.write(asJson(report) + '\n');
+                return 0;
+            }
+            if (format === 'markdown') {
+                process.stdout.write(renderUniversalSearchMarkdown(report));
+                return 0;
+            }
+            // Banner so the operator sees `search` is the registry-search
+            // entrypoint, not "what should I do?".
+            process.stdout.write(`(${entrypointBanner('search')})\n\n`);
+            // Text mode is summary-only by default (top 3 of each non-empty
+            // section). Pass `--verbose` / `--full` for the full 7-section bundle.
+            const verbose = flagBool(args, 'verbose') || flagBool(args, 'full');
+            if (verbose) {
+                process.stdout.write(renderUniversalSearchText(report));
+            }
+            else {
+                process.stdout.write(renderUniversalSearchSummary(report, flagNumber(args, 'top') ?? 3));
+            }
+            return 0;
+        }
+        // Warm registries so search includes constructs / playbooks / tuning.
+        await loadConstructs(inspection);
+        await loadPlaybooks(inspection);
+        await loadSearchTuning(inspection);
+        const index = buildSearchIndex(inspection);
+        const opts = { query };
+        const kinds = parseKinds(args);
+        if (kinds)
+            opts.kinds = kinds;
+        const sources = parseSources(args);
+        if (sources)
+            opts.sources = sources;
+        const limit = flagNumber(args, 'limit');
+        if (limit)
+            opts.limit = limit;
+        if (flagBool(args, 'explain'))
+            opts.explain = true;
+        const result = searchIndex(index, opts, inspection);
+        if (flagBool(args, 'json')) {
+            // Stable serialization: convert the grouped Map to an object.
+            const grouped = {};
+            for (const [k, v] of result.grouped)
+                grouped[k] = v;
+            process.stdout.write(asJson({
+                query: result.query,
+                total: result.total,
+                truncated: result.truncated,
+                hits: result.hits,
+                grouped,
+            }) + '\n');
+            return 0;
+        }
+        // Same banner on the legacy text path.
+        process.stdout.write(`(${entrypointBanner('search')})\n\n`);
+        process.stdout.write(renderSearchText(result));
+        return 0;
+    },
+};
+export const searchTuningListCommand = {
+    name: 'tuning',
+    description: 'List, doctor, or explain search-tuning entries (local + pack).',
+    usage: 'shrk search tuning list|doctor|explain <query> [--format markdown|html|json]',
+    async run(args) {
+        const sub = args.positional[0];
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        if (sub === 'explain') {
+            const query = args.positional.slice(1).join(' ').trim();
+            if (!query) {
+                process.stderr.write('Usage: shrk search tuning explain <query> [--kind <kind>] [--source <source>] [--limit N] [--format markdown|html|json]\n');
+                return 2;
+            }
+            const limit = flagNumber(args, 'limit');
+            const kindFilter = flagString(args, 'kind');
+            const sourceFilter = flagString(args, 'source');
+            let report = await explainSearchTuning(inspection, query, typeof limit === 'number' ? { topN: limit } : {});
+            if (kindFilter) {
+                report = { ...report, topResults: report.topResults.filter((r) => r.kind === kindFilter) };
+            }
+            if (sourceFilter) {
+                report = {
+                    ...report,
+                    loadedTunings: report.loadedTunings.filter((t) => t.source === sourceFilter || t.packageName === sourceFilter),
+                };
+            }
+            const format = flagString(args, 'format') ?? (flagBool(args, 'json') ? 'json' : 'text');
+            if (format === 'json') {
+                process.stdout.write(asJson(report) + '\n');
+                return 0;
+            }
+            if (format === 'markdown') {
+                process.stdout.write(renderTuningExplainMarkdown(report));
+                return 0;
+            }
+            if (format === 'html') {
+                process.stdout.write(renderTuningExplainHtml(report));
+                return 0;
+            }
+            // text default
+            process.stdout.write(`Tuning explain for "${report.query}"\n`);
+            process.stdout.write(`Tokens: ${report.tokens.join(', ') || '(none)'}\n`);
+            process.stdout.write(`Loaded tunings: ${report.loadedTunings.length}\n`);
+            for (const t of report.loadedTunings) {
+                process.stdout.write(`  - ${t.id} (${t.source}${t.packageName ? '/' + t.packageName : ''})\n`);
+            }
+            if (report.topResults.length > 0) {
+                process.stdout.write('Top deltas:\n');
+                for (const r of report.topResults) {
+                    process.stdout.write(`  ${r.docId.padEnd(40)} ${r.baselineScore.toString().padStart(6)} → ${r.tunedScore.toString().padStart(6)} (Δ${r.delta})\n`);
+                    for (const reason of r.reasons.slice(0, 3))
+                        process.stdout.write(`      ${reason}\n`);
+                }
+            }
+            else {
+                process.stdout.write('No matching tunings affect the top results.\n');
+            }
+            return 0;
+        }
+        const { entries, issues } = await loadSearchTuning(inspection);
+        if (sub === 'doctor') {
+            if (flagBool(args, 'json')) {
+                process.stdout.write(asJson({ entries: entries.length, issues }) + '\n');
+                return issues.some((i) => i.severity === 'error') ? 1 : 0;
+            }
+            process.stdout.write(`Tuning entries: ${entries.length}\n`);
+            if (issues.length === 0) {
+                process.stdout.write('No issues.\n');
+                return 0;
+            }
+            for (const i of issues) {
+                process.stdout.write(`  ${i.severity.toUpperCase().padEnd(8)} ${i.code.padEnd(20)} ${i.message}${i.tuningId ? `  (${i.tuningId})` : ''}\n`);
+            }
+            return issues.some((i) => i.severity === 'error') ? 1 : 0;
+        }
+        // Default: list.
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(entries) + '\n');
+            return 0;
+        }
+        process.stdout.write(`Search tuning (${entries.length} entries)\n`);
+        for (const e of entries) {
+            process.stdout.write(`  ${e.id.padEnd(36)} ${e.source}${e.packageName ? ` (${e.packageName})` : ''}\n`);
+        }
+        return 0;
+    },
+};
+void flagString;
+/**
+ * Compact text renderer for the default `shrk search` output. Shows
+ * up to `topN` items from each non-empty section, then a short "details:
+ * pass --verbose" footer. Keeps the universal-search banner + confidence.
+ */
+function renderUniversalSearchSummary(report, topN) {
+    const lines = [];
+    lines.push(`=== shrk search "${report.query}" (summary) ===`);
+    lines.push('');
+    const best = report.sections.bestActions.slice(0, topN);
+    if (best.length > 0) {
+        lines.push(`▶ Best actions (top ${best.length})`);
+        for (const h of best) {
+            const cmd = h.nextCommand ?? h.command ?? h.action ?? '';
+            const inline = cmd ? `  →  ${cmd}` : '';
+            lines.push(`   • ${h.title}${inline}`);
+        }
+        lines.push('');
+    }
+    const cmds = report.sections.commands.slice(0, topN);
+    if (cmds.length > 0) {
+        lines.push(`▶ Command matches (top ${cmds.length})`);
+        for (const h of cmds) {
+            const inline = h.nextCommand ? `  →  ${h.nextCommand}` : '';
+            lines.push(`   • ${h.id} — ${h.title}${inline}`);
+        }
+        lines.push('');
+    }
+    const contrib = report.sections.contributions.slice(0, topN);
+    if (contrib.length > 0) {
+        lines.push(`▶ Pack contributions (top ${contrib.length})`);
+        for (const h of contrib)
+            lines.push(`   • [${h.kind}] ${h.id} — ${h.title}`);
+        lines.push('');
+    }
+    const know = report.sections.knowledge.slice(0, topN);
+    if (know.length > 0) {
+        lines.push(`▶ Knowledge / docs (top ${know.length})`);
+        for (const h of know)
+            lines.push(`   • ${h.id} — ${h.title}`);
+        lines.push('');
+    }
+    lines.push(`▶ Uncertainty: ${report.uncertainty.confidence.toUpperCase()} (safe fallback: ${report.uncertainty.safeFallbackCommand})`);
+    lines.push('');
+    lines.push('(text mode is summary-only — pass --verbose / --full for the 7-section bundle, --json for machine output.)');
+    return lines.join('\n') + '\n';
+}
+/**
+ * Top-level `shrk search-tuning <verb>` alias.
+ *
+ * Lets users invoke `shrk search-tuning explain "<query>"` without
+ * remembering the nested `shrk search tuning explain ...` form. Routes
+ * directly through the existing handler to avoid drift.
+ */
+export const searchTuningTopLevelCommand = {
+    name: 'search-tuning',
+    description: 'Alias — `shrk search-tuning <list|doctor|explain>` (delegates to `shrk search tuning ...`).',
+    usage: 'shrk search-tuning <list|doctor|explain> [<query>] [--kind <kind>] [--source <source>] [--limit N] [--format text|markdown|html|json]',
+    async run(args) {
+        return searchTuningListCommand.run(args);
+    },
+};

package/dist/commands/self-config.command.d.ts

@@ -0,0 +1,7 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const selfConfigDoctorCommand: ICommandHandler;
+export declare const selfConfigGraphCommand: ICommandHandler;
+export declare const selfConfigBrokenLinksCommand: ICommandHandler;
+export declare const selfConfigReportCommand: ICommandHandler;
+export declare const selfConfigCommand: ICommandHandler;
+//# sourceMappingURL=self-config.command.d.ts.map

package/dist/commands/self-config.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"self-config.command.d.ts","sourceRoot":"","sources":["../../src/commands/self-config.command.ts"],"names":[],"mappings":"AAgBA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAGhC,eAAO,MAAM,uBAAuB,EAAE,eAwCrC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eA6BpC,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,eAsB1C,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eAuCrC,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,eAc/B,CAAC"}

package/dist/commands/self-config.command.js

@@ -0,0 +1,156 @@
+/**
+ * `shrk self-config doctor|graph|broken-links|report` — cross-reference
+ * walker. Read-only; `report` writes to `.sharkcraft/reports/`.
+ */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { buildSelfConfigDoctorReport, buildSelfConfigDoctorReportV2, buildSelfConfigGraph, inspectSharkcraft, renderSelfConfigDoctorMarkdown, renderSelfConfigDoctorText, renderSelfConfigDoctorV2Markdown, renderSelfConfigDoctorV2Text, } from '@shrkcrft/inspector';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+export const selfConfigDoctorCommand = {
+    name: 'doctor',
+    description: 'Self-config cross-reference doctor — validates the graph of refs. Defaults to v2 schema; pass --schema v1 for the legacy shape.',
+    usage: 'shrk self-config doctor [--schema v1|v2] [--format text|markdown|json] [--strict]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const strict = flagBool(args, 'strict');
+        const format = flagString(args, 'format') ?? 'text';
+        const wantJson = flagBool(args, 'json') || format === 'json';
+        const schemaArg = flagString(args, 'schema');
+        const useV1 = schemaArg === 'v1';
+        if (useV1) {
+            const report = await buildSelfConfigDoctorReport(inspection);
+            if (wantJson) {
+                process.stdout.write(asJson(report) + '\n');
+            }
+            else if (format === 'markdown') {
+                process.stdout.write(renderSelfConfigDoctorMarkdown(report));
+            }
+            else {
+                process.stdout.write(renderSelfConfigDoctorText(report));
+            }
+            if (strict && (report.verdict === 'warnings' || report.verdict === 'errors'))
+                return 1;
+            return report.verdict === 'errors' ? 1 : 0;
+        }
+        // Default: v2 graph validation.
+        const report = await buildSelfConfigDoctorReportV2(inspection);
+        if (wantJson) {
+            process.stdout.write(asJson(report) + '\n');
+        }
+        else if (format === 'markdown') {
+            process.stdout.write(renderSelfConfigDoctorV2Markdown(report));
+        }
+        else {
+            process.stdout.write(renderSelfConfigDoctorV2Text(report));
+        }
+        if (strict && (report.verdict === 'warnings' || report.verdict === 'errors'))
+            return 1;
+        return report.verdict === 'errors' ? 1 : 0;
+    },
+};
+export const selfConfigGraphCommand = {
+    name: 'graph',
+    description: 'Render the self-config reference graph as JSON or DOT/mermaid.',
+    usage: 'shrk self-config graph [--format json|mermaid|dot]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const graph = await buildSelfConfigGraph(inspection);
+        const format = flagString(args, 'format') ?? 'json';
+        if (format === 'mermaid') {
+            const lines = ['graph TD'];
+            for (const e of graph.edges) {
+                lines.push(`  ${e.from.kind}_${e.from.id} --> ${e.to.kind}_${e.to.id}`);
+            }
+            process.stdout.write(lines.join('\n') + '\n');
+            return 0;
+        }
+        if (format === 'dot') {
+            const lines = ['digraph G {'];
+            for (const e of graph.edges) {
+                lines.push(`  "${e.from.kind}/${e.from.id}" -> "${e.to.kind}/${e.to.id}";`);
+            }
+            lines.push('}');
+            process.stdout.write(lines.join('\n') + '\n');
+            return 0;
+        }
+        process.stdout.write(asJson(graph) + '\n');
+        return 0;
+    },
+};
+export const selfConfigBrokenLinksCommand = {
+    name: 'broken-links',
+    description: 'List only the broken (unresolved) references.',
+    usage: 'shrk self-config broken-links [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const graph = await buildSelfConfigGraph(inspection);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({ brokenEdges: graph.brokenEdges }) + '\n');
+            return graph.brokenEdges.length === 0 ? 0 : 1;
+        }
+        if (graph.brokenEdges.length === 0) {
+            process.stdout.write('No broken references. ✓\n');
+            return 0;
+        }
+        process.stdout.write(`=== Broken self-config references (${graph.brokenEdges.length}) ===\n`);
+        for (const e of graph.brokenEdges.slice(0, 100)) {
+            process.stdout.write(`  • ${e.from.kind}:${e.from.id} -> ${e.to.kind}:${e.to.id}\n`);
+        }
+        return 1;
+    },
+};
+export const selfConfigReportCommand = {
+    name: 'report',
+    description: 'Write the self-config doctor + graph reports under .sharkcraft/reports/.',
+    usage: 'shrk self-config report [--output <dir>]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const schemaArg = flagString(args, 'schema');
+        const useV1 = schemaArg === 'v1';
+        const graph = await buildSelfConfigGraph(inspection);
+        const outArg = flagString(args, 'output');
+        const outDir = outArg
+            ? (nodePath.isAbsolute(outArg) ? outArg : nodePath.resolve(cwd, outArg))
+            : nodePath.join(cwd, '.sharkcraft', 'reports');
+        mkdirSync(outDir, { recursive: true });
+        const base = 'self-config-doctor';
+        if (useV1) {
+            const report = await buildSelfConfigDoctorReport(inspection);
+            writeFileSync(nodePath.join(outDir, `${base}.json`), JSON.stringify(report, null, 2) + '\n', 'utf8');
+            writeFileSync(nodePath.join(outDir, `${base}.md`), renderSelfConfigDoctorMarkdown(report), 'utf8');
+            writeFileSync(nodePath.join(outDir, `${base}-graph.json`), JSON.stringify(graph, null, 2) + '\n', 'utf8');
+            process.stdout.write(`Wrote ${nodePath.relative(cwd, outDir)}/${base}.{json,md} (v1) and ${base}-graph.json\n`);
+            return report.verdict === 'errors' ? 1 : 0;
+        }
+        const report = await buildSelfConfigDoctorReportV2(inspection);
+        writeFileSync(nodePath.join(outDir, `${base}.json`), JSON.stringify(report, null, 2) + '\n', 'utf8');
+        writeFileSync(nodePath.join(outDir, `${base}.md`), renderSelfConfigDoctorV2Markdown(report), 'utf8');
+        writeFileSync(nodePath.join(outDir, `${base}-graph.json`), JSON.stringify(graph, null, 2) + '\n', 'utf8');
+        process.stdout.write(`Wrote ${nodePath.relative(cwd, outDir)}/${base}.{json,md} (v2) and ${base}-graph.json\n`);
+        return report.verdict === 'errors' ? 1 : 0;
+    },
+};
+export const selfConfigCommand = {
+    name: 'self-config',
+    description: 'Cross-reference doctor over SharkCraft self-config + pack contributions.',
+    usage: 'shrk self-config doctor|graph|broken-links|report ...',
+    async run(args) {
+        const sub = args.positional[0];
+        args.positional = args.positional.slice(1);
+        if (sub === 'doctor')
+            return selfConfigDoctorCommand.run(args);
+        if (sub === 'graph')
+            return selfConfigGraphCommand.run(args);
+        if (sub === 'broken-links')
+            return selfConfigBrokenLinksCommand.run(args);
+        if (sub === 'report')
+            return selfConfigReportCommand.run(args);
+        process.stderr.write('Usage: shrk self-config doctor|graph|broken-links|report ...\n');
+        return 2;
+    },
+};

package/dist/commands/self.command.d.ts

@@ -0,0 +1,3 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const selfAuditCommand: ICommandHandler;
+//# sourceMappingURL=self.command.d.ts.map

package/dist/commands/self.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"self.command.d.ts","sourceRoot":"","sources":["../../src/commands/self.command.ts"],"names":[],"mappings":"AAYA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA0EhC,eAAO,MAAM,gBAAgB,EAAE,eAiE9B,CAAC"}

package/dist/commands/self.command.js

@@ -0,0 +1,117 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { buildSelfAudit, detectSharkcraftRepo, inspectSharkcraft, buildReleaseReadiness, buildDocsCheck, buildExamplesCheck, renderSelfAuditText, } from '@shrkcrft/inspector';
+import { flagBool, flagNumber, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+function tail(s, n = 12) {
+    return s.split(/\r?\n/).slice(-n).join('\n');
+}
+function runCheck(input) {
+    try {
+        const result = spawnSync(input.bin, input.args, {
+            cwd: input.cwd,
+            env: { ...process.env, NO_COLOR: '1' },
+            encoding: 'utf8',
+            timeout: input.timeoutMs,
+            stdio: 'pipe',
+        });
+        const exit = result.status ?? null;
+        return {
+            ok: exit === 0,
+            exitCode: exit,
+            stdoutTail: tail(result.stdout ?? ''),
+            stderrTail: tail(result.stderr ?? ''),
+        };
+    }
+    catch (e) {
+        return { ok: false, exitCode: null, stdoutTail: '', stderrTail: e.message };
+    }
+}
+async function runInternalChecks(cwd, cliEntry, timeoutMs) {
+    const durations = {};
+    const cycle = (id, args) => {
+        const start = Date.now();
+        const r = runCheck({ bin: 'bun', args: [cliEntry, ...args], cwd, timeoutMs });
+        durations[id] = Date.now() - start;
+        return r;
+    };
+    const commandsDoctor = cycle('commands-doctor', ['commands', 'doctor']);
+    const runtimeDoctor = cycle('runtime-doctor', ['runtime', 'doctor']);
+    const safetyAudit = cycle('safety-audit', ['safety', 'audit']);
+    const packsDoctor = cycle('packs-doctor', ['packs', 'doctor', '--release']);
+    const demoValidate = cycle('demo-validate', ['demo', 'package', '--validate', '--scenario', 'pr-review']);
+    return {
+        commandsDoctorOk: commandsDoctor.ok,
+        runtimeDoctorOk: runtimeDoctor.ok,
+        safetyAuditOk: safetyAudit.ok,
+        packsDoctorOk: packsDoctor.ok,
+        demoPackageValidateOk: demoValidate.ok,
+        perCheckDurations: durations,
+    };
+}
+export const selfAuditCommand = {
+    name: 'audit',
+    description: 'Run the SharkCraft self-dogfood audit (only meaningful inside the SharkCraft repo). Read-only.',
+    usage: 'shrk self audit [--json] [--report] [--run] [--timeout-ms <n>]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const isRepo = detectSharkcraftRepo(cwd);
+        if (!isRepo) {
+            const report = buildSelfAudit(cwd);
+            if (flagBool(args, 'json'))
+                process.stdout.write(asJson(report) + '\n');
+            else
+                process.stdout.write(renderSelfAuditText(report));
+            return 0;
+        }
+        const inspection = await inspectSharkcraft({ cwd });
+        const readiness = await buildReleaseReadiness(inspection, {
+            includeDocsCheck: true,
+            includeExamplesCheck: true,
+        });
+        const docsCheck = buildDocsCheck(cwd);
+        const examplesCheck = buildExamplesCheck(cwd);
+        let extra = null;
+        let cliEntry = nodePath.join(cwd, 'packages', 'cli', 'src', 'main.ts');
+        if (!existsSync(cliEntry))
+            cliEntry = 'shrk';
+        if (flagBool(args, 'run')) {
+            const timeoutMs = flagNumber(args, 'timeout-ms') ?? 90_000;
+            extra = await runInternalChecks(cwd, cliEntry, timeoutMs);
+        }
+        const report = buildSelfAudit(cwd, {
+            releaseReadinessReady: readiness.ready,
+            releaseReadinessBlockers: readiness.blockers.length,
+            releaseReadinessWarnings: readiness.warnings.length,
+            mcpAuditWriteToolCount: 0,
+            docsCheckOk: docsCheck.ok,
+            examplesCheckOk: examplesCheck.ok,
+            ...(extra
+                ? {
+                    commandsDoctorErrors: extra.commandsDoctorOk ? 0 : 1,
+                    runtimeDoctorOk: extra.runtimeDoctorOk,
+                    packsDoctorOk: extra.packsDoctorOk,
+                    demoPackageValidateOk: extra.demoPackageValidateOk,
+                }
+                : {}),
+        });
+        if (flagBool(args, 'report')) {
+            const outDir = nodePath.join(cwd, '.sharkcraft', 'reports');
+            mkdirSync(outDir, { recursive: true });
+            writeFileSync(nodePath.join(outDir, 'self-audit.json'), JSON.stringify({ ...report, extra }, null, 2) + '\n', 'utf8');
+        }
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({ ...report, extra }) + '\n');
+            return report.ok ? 0 : 1;
+        }
+        process.stdout.write(renderSelfAuditText(report));
+        if (extra) {
+            process.stdout.write('\nRan internal checks:\n');
+            for (const [k, v] of Object.entries(extra.perCheckDurations)) {
+                process.stdout.write(`  ${k.padEnd(24)} ${v}ms\n`);
+            }
+        }
+        return report.ok ? 0 : 1;
+    },
+};

package/dist/commands/simulate.command.d.ts

@@ -0,0 +1,3 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const simulateCommand: ICommandHandler;
+//# sourceMappingURL=simulate.command.d.ts.map

package/dist/commands/simulate.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulate.command.d.ts","sourceRoot":"","sources":["../../src/commands/simulate.command.ts"],"names":[],"mappings":"AAQA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAGhC,eAAO,MAAM,eAAe,EAAE,eAmD7B,CAAC"}

package/dist/commands/simulate.command.js

@@ -0,0 +1,54 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { inspectSharkcraft, OrchestrationMode, renderWorkflowSimulationText, simulateWorkflow, } from '@shrkcrft/inspector';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+export const simulateCommand = {
+    name: 'simulate',
+    description: 'Predict what a workflow would do without executing anything. Read-only. Optionally takes a playbook or pipeline id.',
+    usage: 'shrk simulate "<task>" [--playbook <id>] [--pipeline <id>] [--bundle] [--mode conservative|balanced|aggressive] [--json] [--output <file>]',
+    async run(args) {
+        const task = args.positional.join(' ').trim();
+        if (!task) {
+            process.stderr.write('Usage: shrk simulate "<task>"\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const playbookId = flagString(args, 'playbook');
+        const pipelineId = flagString(args, 'pipeline');
+        const modeRaw = (flagString(args, 'mode') ?? '').toLowerCase();
+        const mode = modeRaw === 'conservative'
+            ? OrchestrationMode.Conservative
+            : modeRaw === 'aggressive'
+                ? OrchestrationMode.Aggressive
+                : OrchestrationMode.Balanced;
+        const sim = await simulateWorkflow(task, inspection, {
+            ...(playbookId ? { playbookId } : {}),
+            ...(pipelineId ? { pipelineId } : {}),
+            mode,
+        });
+        const output = flagString(args, 'output');
+        if (flagBool(args, 'json')) {
+            const body = asJson(sim) + '\n';
+            if (output) {
+                const abs = nodePath.isAbsolute(output) ? output : nodePath.resolve(cwd, output);
+                mkdirSync(nodePath.dirname(abs), { recursive: true });
+                writeFileSync(abs, body, 'utf8');
+                process.stdout.write(`Wrote ${abs}\n`);
+                return 0;
+            }
+            process.stdout.write(body);
+            return 0;
+        }
+        if (output) {
+            const abs = nodePath.isAbsolute(output) ? output : nodePath.resolve(cwd, output);
+            mkdirSync(nodePath.dirname(abs), { recursive: true });
+            writeFileSync(abs, renderWorkflowSimulationText(sim), 'utf8');
+            process.stdout.write(`Wrote ${abs}\n`);
+            return 0;
+        }
+        process.stdout.write(renderWorkflowSimulationText(sim));
+        return 0;
+    },
+};

package/dist/commands/spec.command.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `shrk spec` surface.
+ *
+ *   - `spec create "<title>"` — ground a new spec under .sharkcraft/specs/.
+ *   - `spec review <id>`      — structural + cross-registry validation.
+ *   - `spec implement <id>`   — compose proposedTemplates into a signed plan.
+ *   - `spec verify <id>`      — run trusted verification commands + checks.
+ *   - `spec list`             — list every spec.
+ *   - `spec show <id>`        — print spec contents.
+ *   - `spec status <id>`      — read/transition status.
+ *   - `spec lint <id>`        — fast structural-only lint.
+ *
+ * Preview-first everywhere. `--write` / `--apply` opt-in.
+ */
+import { SPEC_LIST_SCHEMA } from '@shrkcrft/inspector';
+import { type ICommandHandler } from '../command-registry.js';
+export declare const SPEC_IMPLEMENT_SCHEMA = "sharkcraft.spec-implement/v1";
+export declare const SPEC_VERIFICATION_SCHEMA = "sharkcraft.spec-verification/v1";
+export declare const specCreateCommand: ICommandHandler;
+export declare const specReviewCommand: ICommandHandler;
+export declare const specLintCommand: ICommandHandler;
+export declare const specListCommand: ICommandHandler;
+export declare const specShowCommand: ICommandHandler;
+export declare const specStatusCommand: ICommandHandler;
+export declare const specImplementCommand: ICommandHandler;
+export declare const specVerifyCommand: ICommandHandler;
+export declare const specParentCommand: ICommandHandler;
+export { SPEC_LIST_SCHEMA };
+//# sourceMappingURL=spec.command.d.ts.map

package/dist/commands/spec.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec.command.d.ts","sourceRoot":"","sources":["../../src/commands/spec.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AA0CH,OAAO,EASL,gBAAgB,EAIjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAShC,eAAO,MAAM,qBAAqB,iCAAiC,CAAC;AACpE,eAAO,MAAM,wBAAwB,oCAAoC,CAAC;AAY1E,eAAO,MAAM,iBAAiB,EAAE,eA2K/B,CAAC;AAcF,eAAO,MAAM,iBAAiB,EAAE,eAiE/B,CAAC;AAqBF,eAAO,MAAM,eAAe,EAAE,eAmC7B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,eA8B7B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,eA2C7B,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,eAoE/B,CAAC;AASF,eAAO,MAAM,oBAAoB,EAAE,eAsRlC,CAAC;AAyDF,eAAO,MAAM,iBAAiB,EAAE,eAsL/B,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,eA4B/B,CAAC;AAkBF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}