@shrkcrft/inspector 0.1.0-alpha.1

package/dist/scaffold-patterns.js

@@ -0,0 +1,282 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+/**
+ * Scaffold pattern registry + loader.
+ *
+ * Resolves scaffold patterns from packs (and the local config when supplied)
+ * into a single in-memory list. Patterns are data; this module never executes
+ * shell commands or evaluates pack code beyond a dynamic import.
+ */
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { isRecognizedScaffoldStrategy, } from '@shrkcrft/plugin-api';
+export async function loadScaffoldPatternsFromFile(file) {
+    if (!existsSync(file))
+        return { patterns: [], warnings: [`scaffold pattern file missing: ${file}`] };
+    try {
+        const mod = (await import(__rewriteRelativeImportExtension(pathToFileURL(file).href + '?t=' + Date.now())));
+        const raw = mod.default ?? mod;
+        if (!Array.isArray(raw)) {
+            return {
+                patterns: [],
+                warnings: [`scaffold pattern file did not default-export an array: ${file}`],
+            };
+        }
+        const out = [];
+        const warnings = [];
+        for (const candidate of raw) {
+            if (!candidate || typeof candidate !== 'object') {
+                warnings.push(`scaffold pattern entry is not an object in ${file}`);
+                continue;
+            }
+            const p = candidate;
+            if (!p.id || typeof p.id !== 'string') {
+                warnings.push(`scaffold pattern missing id in ${file}`);
+                continue;
+            }
+            if (!p.templateId || typeof p.templateId !== 'string') {
+                warnings.push(`scaffold pattern "${p.id}" missing templateId in ${file}`);
+                continue;
+            }
+            if (!Array.isArray(p.matchPaths) || p.matchPaths.length === 0) {
+                warnings.push(`scaffold pattern "${p.id}" must declare matchPaths in ${file}`);
+                continue;
+            }
+            out.push(p);
+        }
+        return { patterns: out, warnings };
+    }
+    catch (e) {
+        return {
+            patterns: [],
+            warnings: [`failed to import scaffold pattern file ${file}: ${e.message}`],
+        };
+    }
+}
+/**
+ * Walk the inspection's discovered packs and load every `scaffoldPatternFiles`
+ * entry. Returns the patterns + source map.
+ */
+export async function loadScaffoldPatternsFromInspection(inspection) {
+    const seen = new Map();
+    const warnings = [];
+    // Also load a local sharkcraft/scaffold-patterns.ts when present.
+    if (inspection.sharkcraftDir) {
+        const local = nodePath.join(inspection.sharkcraftDir, 'scaffold-patterns.ts');
+        if (existsSync(local)) {
+            const r = await loadScaffoldPatternsFromFile(local);
+            warnings.push(...r.warnings);
+            for (const p of r.patterns) {
+                if (seen.has(p.id)) {
+                    warnings.push(`scaffold pattern "${p.id}" duplicated — local version skipped`);
+                    continue;
+                }
+                seen.set(p.id, {
+                    pattern: p,
+                    source: { type: 'local', file: local },
+                });
+            }
+        }
+    }
+    for (const pack of inspection.packs.validPacks) {
+        const c = pack.manifest.contributions;
+        for (const rel of c.scaffoldPatternFiles ?? []) {
+            const full = nodePath.resolve(pack.packageRoot, rel);
+            const r = await loadScaffoldPatternsFromFile(full);
+            warnings.push(...r.warnings);
+            for (const p of r.patterns) {
+                if (seen.has(p.id)) {
+                    warnings.push(`scaffold pattern "${p.id}" duplicated — pack version skipped`);
+                    continue;
+                }
+                seen.set(p.id, {
+                    pattern: p,
+                    source: {
+                        type: 'pack',
+                        packageName: pack.packageName,
+                        packageVersion: pack.packageVersion,
+                        file: full,
+                    },
+                });
+                if (pack.resolvedCounts) {
+                    pack.resolvedCounts.scaffoldPatterns =
+                        (pack.resolvedCounts.scaffoldPatterns ?? 0) + 1;
+                }
+            }
+        }
+    }
+    return { patterns: [...seen.values()], warnings };
+}
+export function doctorScaffoldPatterns(patterns, inspection) {
+    const issues = [];
+    const knownTemplateIds = new Set(inspection.templateRegistry.list().map((t) => t.id));
+    for (const { pattern: p } of patterns) {
+        if (!p.title) {
+            issues.push({ patternId: p.id, field: 'title', severity: 'warning', message: 'missing title' });
+        }
+        if (!p.description) {
+            issues.push({
+                patternId: p.id,
+                field: 'description',
+                severity: 'warning',
+                message: 'missing description',
+            });
+        }
+        if (!Array.isArray(p.appliesWhen) || p.appliesWhen.length === 0) {
+            issues.push({
+                patternId: p.id,
+                field: 'appliesWhen',
+                severity: 'warning',
+                message: 'appliesWhen is empty — pattern will not be consulted by any lifecycle hook',
+            });
+        }
+        if (p.confidence !== 'high' && p.confidence !== 'medium' && p.confidence !== 'low') {
+            issues.push({
+                patternId: p.id,
+                field: 'confidence',
+                severity: 'error',
+                message: `confidence must be high|medium|low (got "${String(p.confidence)}")`,
+            });
+        }
+        for (const m of p.matchPaths) {
+            if (typeof m !== 'string' || m.length === 0) {
+                issues.push({
+                    patternId: p.id,
+                    field: 'matchPaths',
+                    severity: 'error',
+                    message: `matchPaths entry must be a non-empty string`,
+                });
+            }
+        }
+        if (!knownTemplateIds.has(p.templateId)) {
+            issues.push({
+                patternId: p.id,
+                field: 'templateId',
+                severity: 'warning',
+                message: `template "${p.templateId}" is not registered in this project`,
+            });
+        }
+        for (const v of p.variables ?? []) {
+            if (!isRecognizedScaffoldStrategy(String(v.from))) {
+                issues.push({
+                    patternId: p.id,
+                    field: `variables.${v.name}.from`,
+                    severity: 'warning',
+                    message: `unrecognized extraction strategy "${String(v.from)}"`,
+                });
+            }
+        }
+    }
+    return issues;
+}
+/**
+ * Convert a glob-like pattern (only `*` and `**` are recognized) into a
+ * RegExp. Kept tiny — we don't depend on `minimatch`.
+ */
+export function globToRegExp(glob) {
+    let re = '^';
+    for (let i = 0; i < glob.length; i += 1) {
+        const c = glob[i];
+        if (c === '*' && glob[i + 1] === '*' && glob[i + 2] === '/') {
+            // `**/` matches zero or more path segments. We also consume the slash so
+            // that the segment-separator isn't required by the rest of the pattern.
+            re += '(?:.*/)?';
+            i += 2;
+        }
+        else if (c === '*' && glob[i + 1] === '*') {
+            re += '.*';
+            i += 1;
+        }
+        else if (c === '*') {
+            re += '[^/]*';
+        }
+        else if (c === '?') {
+            re += '[^/]';
+        }
+        else if ('.+()[]{}|^$\\'.includes(c)) {
+            re += '\\' + c;
+        }
+        else {
+            re += c;
+        }
+    }
+    re += '$';
+    return new RegExp(re);
+}
+export function matchScaffoldPattern(pattern, relativePath) {
+    const path = relativePath.split(nodePath.sep).join('/');
+    for (const x of pattern.excludePaths ?? []) {
+        if (globToRegExp(x).test(path))
+            return false;
+    }
+    for (const m of pattern.matchPaths) {
+        if (globToRegExp(m).test(path))
+            return true;
+    }
+    return false;
+}
+export function extractVariablesForFile(pattern, filePath, inspection) {
+    const warnings = [];
+    const values = {};
+    const base = nodePath.basename(filePath).replace(/\.(tsx?|jsx?)$/i, '');
+    const dirSegments = filePath.split(/[\\/]/).slice(0, -1);
+    const dir = dirSegments[dirSegments.length - 1] ?? '';
+    for (const v of pattern.variables) {
+        const strat = String(v.from);
+        let value = '';
+        if (strat === 'filename.kebab') {
+            value = base
+                .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+                .replace(/_+/g, '-')
+                .toLowerCase();
+        }
+        else if (strat === 'filename.pascal') {
+            value = base
+                .split(/[-_.]/)
+                .filter(Boolean)
+                .map((s) => s[0].toUpperCase() + s.slice(1))
+                .join('');
+        }
+        else if (strat === 'className') {
+            value = pascal(base);
+        }
+        else if (strat.startsWith('className.stripPrefix:')) {
+            const prefix = strat.slice('className.stripPrefix:'.length);
+            const pascalName = pascal(base);
+            value = pascalName.startsWith(prefix) ? pascalName.slice(prefix.length) : pascalName;
+        }
+        else if (strat === 'functionName') {
+            value = camel(base);
+        }
+        else if (strat === 'directoryName') {
+            value = dir;
+        }
+        else if (strat === 'nearestPackageName') {
+            value = inspection.workspace.packageName ?? '';
+        }
+        else {
+            warnings.push(`unrecognized extraction strategy "${strat}" for variable "${v.name}"`);
+        }
+        if (value)
+            values[v.name] = value;
+    }
+    return { values, warnings };
+}
+function pascal(s) {
+    return s
+        .split(/[-_.]/)
+        .filter(Boolean)
+        .map((p) => p[0].toUpperCase() + p.slice(1))
+        .join('');
+}
+function camel(s) {
+    const p = pascal(s);
+    return p ? p[0].toLowerCase() + p.slice(1) : '';
+}

package/dist/schema-inventory.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Schema version inventory.
+ *
+ * SharkCraft ships ~200 internal `sharkcraft.<id>/v<N>` envelope schemas
+ * plus ~36 hand-written JSON schemas under `shrk schemas list`. Several
+ * envelope schemas have been versioned over time (e.g.
+ * `self-config-doctor/v1` → v2). The inventory is a small, curated,
+ * read-only surface that:
+ *
+ *   - lists every schema id known to the engine,
+ *   - lists every version that has ever shipped,
+ *   - names the current default version,
+ *   - flags `deprecated` / `backcompat-only` versions,
+ *   - gives a one-line "what this schema describes" hint.
+ *
+ * Purpose: an agent can answer "is there a newer version of this
+ * schema?" in one command instead of grepping.
+ *
+ * The inventory is curated — adding a new schema or bumping a version
+ * means updating this file. Tests assert the inventory stays in sync
+ * with the engine.
+ */
+export declare const SCHEMA_INVENTORY_SCHEMA = "sharkcraft.schema-inventory/v1";
+export declare enum SchemaStatus {
+    Current = "current",
+    Deprecated = "deprecated",
+    Backcompat = "backcompat-only"
+}
+export interface ISchemaVersion {
+    readonly version: string;
+    readonly status: SchemaStatus;
+    /** Optional note: when v1 is kept around for downstream consumers. */
+    readonly note?: string;
+}
+export interface ISchemaInventoryEntry {
+    readonly id: string;
+    readonly versions: ReadonlyArray<ISchemaVersion>;
+    readonly currentVersion: string;
+    readonly summary: string;
+    /** CLI command that emits this schema (best-effort). */
+    readonly emittedBy?: string;
+    /** Documentation file in `docs/`, if any. */
+    readonly docs?: string;
+}
+export interface ISchemaInventoryReport {
+    readonly schema: typeof SCHEMA_INVENTORY_SCHEMA;
+    readonly entries: ReadonlyArray<ISchemaInventoryEntry>;
+    readonly multiVersionIds: ReadonlyArray<string>;
+}
+export declare function buildSchemaInventory(): ISchemaInventoryReport;
+export declare function renderSchemaInventoryText(report: ISchemaInventoryReport): string;
+export declare function renderSchemaInventoryMarkdown(report: ISchemaInventoryReport): string;
+/** Lookup: returns the entry for one schema id, or null. */
+export declare function findSchemaInventoryEntry(id: string): ISchemaInventoryEntry | null;
+//# sourceMappingURL=schema-inventory.d.ts.map

package/dist/schema-inventory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-inventory.d.ts","sourceRoot":"","sources":["../src/schema-inventory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,eAAO,MAAM,uBAAuB,mCAAmC,CAAC;AAExE,oBAAY,YAAY;IACtB,OAAO,YAAY;IACnB,UAAU,eAAe;IACzB,UAAU,oBAAoB;CAC/B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,sEAAsE;IACtE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IACjD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,wDAAwD;IACxD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,6CAA6C;IAC7C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,OAAO,uBAAuB,CAAC;IAChD,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,qBAAqB,CAAC,CAAC;IACvD,QAAQ,CAAC,eAAe,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACjD;AAmOD,wBAAgB,oBAAoB,IAAI,sBAAsB,CAQ7D;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAehF;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,sBAAsB,GAAG,MAAM,CAiBpF;AAED,4DAA4D;AAC5D,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAEjF"}

package/dist/schema-inventory.js

@@ -0,0 +1,301 @@
+/**
+ * Schema version inventory.
+ *
+ * SharkCraft ships ~200 internal `sharkcraft.<id>/v<N>` envelope schemas
+ * plus ~36 hand-written JSON schemas under `shrk schemas list`. Several
+ * envelope schemas have been versioned over time (e.g.
+ * `self-config-doctor/v1` → v2). The inventory is a small, curated,
+ * read-only surface that:
+ *
+ *   - lists every schema id known to the engine,
+ *   - lists every version that has ever shipped,
+ *   - names the current default version,
+ *   - flags `deprecated` / `backcompat-only` versions,
+ *   - gives a one-line "what this schema describes" hint.
+ *
+ * Purpose: an agent can answer "is there a newer version of this
+ * schema?" in one command instead of grepping.
+ *
+ * The inventory is curated — adding a new schema or bumping a version
+ * means updating this file. Tests assert the inventory stays in sync
+ * with the engine.
+ */
+export const SCHEMA_INVENTORY_SCHEMA = 'sharkcraft.schema-inventory/v1';
+export var SchemaStatus;
+(function (SchemaStatus) {
+    SchemaStatus["Current"] = "current";
+    SchemaStatus["Deprecated"] = "deprecated";
+    SchemaStatus["Backcompat"] = "backcompat-only";
+})(SchemaStatus || (SchemaStatus = {}));
+const SCHEMA_ENTRIES = [
+    {
+        id: 'sharkcraft.self-config-doctor',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Backcompat, note: 'kept for downstream consumers; opt out via --schema v1' },
+            { version: 'v2', status: SchemaStatus.Current, note: 'rich finding shape with sourceKind/targetKind/relation' },
+        ],
+        currentVersion: 'v2',
+        summary: 'Cross-reference doctor over the sharkcraft/ registries (knowledge, search-tuning, agent-tests, routing, packs).',
+        emittedBy: 'shrk self-config doctor',
+    },
+    {
+        id: 'sharkcraft.architecture-map',
+        versions: [
+            { version: 'v2', status: SchemaStatus.Current, note: 'layers + public API + boundary rules' },
+        ],
+        currentVersion: 'v2',
+        summary: 'Layered architecture map with public API and boundary-rule wiring.',
+        emittedBy: 'shrk architecture map',
+    },
+    {
+        id: 'sharkcraft.impact-analysis',
+        versions: [
+            { version: 'v2', status: SchemaStatus.Current, note: 'symbol-aware impact analysis' },
+        ],
+        currentVersion: 'v2',
+        summary: 'Architecture impact analysis for a task / file / plan / bundle.',
+        emittedBy: 'shrk impact',
+    },
+    {
+        id: 'sharkcraft.plan',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Backcompat, note: 'simple saved plan (templateId + variables)' },
+            { version: 'v2', status: SchemaStatus.Current, note: 'plan-v2 with explicit operation kinds (file/folder/...)' },
+        ],
+        currentVersion: 'v2',
+        summary: 'Generator saved plan (the only artifact `shrk apply` consumes).',
+        emittedBy: 'shrk gen --save-plan',
+        docs: 'docs/security.md',
+    },
+    {
+        id: 'sharkcraft.universal-search',
+        versions: [
+            { version: 'v2', status: SchemaStatus.Current, note: 'ranked search across all registries' },
+        ],
+        currentVersion: 'v2',
+        summary: 'Cross-registry search results (knowledge, rules, templates, playbooks, ...).',
+        emittedBy: 'shrk search',
+    },
+    {
+        id: 'sharkcraft.inferred-template-candidate',
+        versions: [
+            { version: 'v2', status: SchemaStatus.Current },
+        ],
+        currentVersion: 'v2',
+        summary: 'Inferred template draft candidate emitted by onboarding.',
+        emittedBy: 'shrk onboard',
+    },
+    {
+        id: 'sharkcraft.feedback-actions',
+        versions: [
+            { version: 'v2', status: SchemaStatus.Current, note: 'typed action shapes' },
+        ],
+        currentVersion: 'v2',
+        summary: 'Feedback ingestion → typed actions (convert-to-backlog / suppress / ...).',
+        emittedBy: 'shrk feedback actions',
+    },
+    {
+        id: 'sharkcraft.pack-manifest',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Current },
+        ],
+        currentVersion: 'v1',
+        summary: 'Pack manifest envelope (signed). Consumed by `shrk packs *`.',
+        emittedBy: 'shrk packs build',
+        docs: 'docs/security.md',
+    },
+    {
+        id: 'sharkcraft.agent-contract',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Current },
+        ],
+        currentVersion: 'v1',
+        summary: 'Agent contract — declares risk, files, gates an agent commits to.',
+        emittedBy: 'shrk contract',
+    },
+    {
+        id: 'sharkcraft.changes-summary',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Current, note: 'grouped diff + risk verdict' },
+        ],
+        currentVersion: 'v1',
+        summary: 'Grouped diff summary with risk verdict + suggested validation commands.',
+        emittedBy: 'shrk changes summary',
+    },
+    {
+        id: 'sharkcraft.acceptance-replay',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Current, note: 'picks previous validation commands to re-run' },
+        ],
+        currentVersion: 'v1',
+        summary: 'Acceptance-command replay: which validation commands should re-run given a change set.',
+        emittedBy: 'shrk changes acceptance-replay',
+    },
+    {
+        id: 'sharkcraft.area-explore',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Current, note: 'workspace-aware explain-this-directory' },
+        ],
+        currentVersion: 'v1',
+        summary: 'Workspace-aware explanation for one directory (modules / tests / commands / risks).',
+        emittedBy: 'shrk explore <path>',
+    },
+    {
+        id: 'sharkcraft.entrypoint-matrix',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Current, note: 'entrypoint classification' },
+        ],
+        currentVersion: 'v1',
+        summary: 'Curated entrypoint classification (human-interactive / agent-mcp / machine-json / debug).',
+        emittedBy: 'shrk commands entrypoints',
+    },
+    {
+        id: 'sharkcraft.command-taxonomy',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Current },
+        ],
+        currentVersion: 'v1',
+        summary: 'Curated grouping of every shrk command into start-here / daily / ... buckets.',
+        emittedBy: 'shrk commands taxonomy',
+    },
+    {
+        id: 'sharkcraft.changed-boundary-report',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Current, note: 'changed-only boundary report' },
+        ],
+        currentVersion: 'v1',
+        summary: 'Boundary violations filtered to the changed file set.',
+        emittedBy: 'shrk check boundaries --changed-only',
+    },
+    {
+        id: 'sharkcraft.changed-preflight',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Current, note: 'changed-only preflight orchestrator' },
+        ],
+        currentVersion: 'v1',
+        summary: 'Read-only preflight gate plan derived from the changed-file set.',
+        emittedBy: 'shrk preflight',
+    },
+    {
+        id: 'sharkcraft.safety-audit',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Current },
+        ],
+        currentVersion: 'v1',
+        summary: 'Safety audit envelope — MCP read-only enforcement, signing, write paths.',
+        emittedBy: 'shrk safety audit',
+        docs: 'docs/security.md',
+    },
+    {
+        id: 'sharkcraft.compliance',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Current },
+        ],
+        currentVersion: 'v1',
+        summary: 'Compliance profile + check envelope.',
+        emittedBy: 'shrk compliance check',
+    },
+    {
+        id: 'sharkcraft.review-packet',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Backcompat, note: 'compat with the legacy review pipeline' },
+            { version: 'v2', status: SchemaStatus.Current, note: 'review packet v2 — risk + missing tests + intent' },
+        ],
+        currentVersion: 'v2',
+        summary: 'PR review packet — changed files, affected rules, missing tests, risk.',
+        emittedBy: 'shrk review packet',
+    },
+    {
+        id: 'sharkcraft.adoption-state',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Current },
+        ],
+        currentVersion: 'v1',
+        summary: 'Adoption-plan state envelope.',
+        emittedBy: 'shrk onboard adopt status',
+    },
+    {
+        id: 'sharkcraft.dev-cycle',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Current },
+        ],
+        currentVersion: 'v1',
+        summary: 'Dev-cycle gate plan (sequence of read-only validation gates).',
+        emittedBy: 'shrk dev cycle --explain',
+    },
+    {
+        id: 'sharkcraft.apply-dispatch-trace',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Current, note: 'dispatch trace' },
+        ],
+        currentVersion: 'v1',
+        summary: 'Apply-dispatch trace — which dispatch path apply would take.',
+        emittedBy: 'shrk apply --explain-dispatch',
+    },
+    {
+        id: 'sharkcraft.doctor-suppressions',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Current },
+        ],
+        currentVersion: 'v1',
+        summary: 'Doctor suppressions / acknowledgements registry.',
+        emittedBy: 'shrk doctor acknowledge',
+    },
+    {
+        id: 'sharkcraft.dev-session',
+        versions: [
+            { version: 'v1', status: SchemaStatus.Current },
+        ],
+        currentVersion: 'v1',
+        summary: 'Dev session state under .sharkcraft/sessions/.',
+        emittedBy: 'shrk dev start',
+    },
+];
+export function buildSchemaInventory() {
+    const sorted = [...SCHEMA_ENTRIES].sort((a, b) => a.id.localeCompare(b.id));
+    const multiVersionIds = sorted.filter((e) => e.versions.length > 1).map((e) => e.id);
+    return {
+        schema: SCHEMA_INVENTORY_SCHEMA,
+        entries: sorted,
+        multiVersionIds,
+    };
+}
+export function renderSchemaInventoryText(report) {
+    const lines = [];
+    lines.push(`=== Schema inventory (${report.entries.length} ids, ${report.multiVersionIds.length} multi-version) ===`);
+    for (const e of report.entries) {
+        const versionsText = e.versions
+            .map((v) => `${v.version}${v.status === SchemaStatus.Current ? '*' : v.status === SchemaStatus.Backcompat ? '(compat)' : '(deprecated)'}`)
+            .join(' ');
+        lines.push(`  ${e.id.padEnd(46)} ${versionsText.padEnd(22)} — ${e.summary}`);
+        if (e.emittedBy)
+            lines.push(`     emitted by: ${e.emittedBy}`);
+        if (e.docs)
+            lines.push(`     docs:       ${e.docs}`);
+        for (const v of e.versions) {
+            if (v.note)
+                lines.push(`     ${v.version}: ${v.note}`);
+        }
+    }
+    return lines.join('\n') + '\n';
+}
+export function renderSchemaInventoryMarkdown(report) {
+    const lines = [];
+    lines.push('# SharkCraft schema inventory');
+    lines.push('');
+    lines.push(`${report.entries.length} schemas tracked; ${report.multiVersionIds.length} have multiple versions.`);
+    lines.push('');
+    lines.push('| Schema id | Current | All versions | Emitted by | Summary |');
+    lines.push('| --- | --- | --- | --- | --- |');
+    for (const e of report.entries) {
+        const versions = e.versions
+            .map((v) => `${v.version} (${v.status})`)
+            .join('<br/>');
+        lines.push(`| \`${e.id}\` | ${e.currentVersion} | ${versions} | ${e.emittedBy ? `\`${e.emittedBy}\`` : '—'} | ${e.summary} |`);
+    }
+    return lines.join('\n') + '\n';
+}
+/** Lookup: returns the entry for one schema id, or null. */
+export function findSchemaInventoryEntry(id) {
+    return SCHEMA_ENTRIES.find((e) => e.id === id) ?? null;
+}