@vibesdotdev/cli 0.0.2 → 1.0.0-rc.2

package/dist/commands/runtime/export/read.js

@@ -0,0 +1,128 @@
+/**
+ * Reading a booted runtime into the export shape.
+ *
+ * Every fact here comes from a live query. `runtime.kindIds()` is the kernel's own
+ * list, `runtime.pluginIds()` is what composition actually selected, and
+ * descriptors come from the query's synchronous projection, which never loads an
+ * implementation. Nothing is recomputed, inferred from a manifest, or read out of
+ * a source tree: a descriptor is listed because the runtime holds it.
+ *
+ * Scope axes use Runtime's JSON reader normalization: optional undefined fields
+ * are omitted, and declared facts remain intact. Descriptor stacks are reported
+ * by identity — id, depth and dynamic status — rather than by their own values,
+ * which may carry private owner data or a live reference.
+ */
+import * as z from 'zod/v4';
+import { CapabilityError } from '@vibesdotdev/kernel';
+import { isJsonObject, JsonValueFromReaderSchema } from '@vibesdotdev/kernel/schemas/json';
+/**
+ * Read this runtime into the export shape.
+ *
+ * A kind with no descriptors is still listed. An empty catalog is evidence about
+ * this boot, and a document that hid it would read as an absence the reader
+ * cannot tell apart from one the export chose not to report.
+ */
+export function exportRuntime(runtime, kind) {
+    const kindIds = kind === undefined ? [...runtime.kindIds()].sort() : [requireKind(runtime, kind)];
+    const pluginIds = runtime.pluginIds();
+    const kinds = [];
+    let descriptorTotal = 0;
+    let loaderTotal = 0;
+    for (const kind of kindIds) {
+        const definition = runtime.getKind(kind);
+        const accessor = runtime.assets(kind);
+        const snapshot = accessor.inventory();
+        const count = accessor.descriptors().length;
+        descriptorTotal += count;
+        loaderTotal += snapshot.loaders.length + snapshot.variantLoaders.length;
+        kinds.push({
+            id: kind,
+            descriptorCount: count,
+            schemaName: schemaNameOf(definition?.descriptorSchema),
+            contexts: definition?.contexts ?? [],
+            hasDefault: definition?.resolveDefault !== undefined || definition?.defaultImplementation !== undefined,
+            hasResolver: definition?.resolve !== undefined,
+            descriptorOwnership: definition?.descriptorOwnership ?? 'shared',
+            snapshot
+        });
+    }
+    return {
+        phase: runtime.phase,
+        disposed: runtime.disposed,
+        declaredScope: exportScope(runtime.declaredScope),
+        effectiveScope: exportScope(runtime.scope),
+        compositionSelections: runtime.compositionSelections,
+        plugins: [...pluginIds].sort(),
+        pluginCount: pluginIds.length,
+        kinds,
+        kindCount: kindIds.length,
+        descriptorCount: descriptorTotal,
+        loaderCount: loaderTotal,
+        generatedAt: new Date().toISOString()
+    };
+}
+/**
+ * The one kind a reader named, or a refusal naming what was asked for.
+ *
+ * A reader who asks for a kind this runtime does not hold gets told so, rather
+ * than a document about a different runtime: an empty section would read as "this
+ * runtime holds nothing here", which is the opposite of the answer.
+ */
+function requireKind(runtime, kind) {
+    if (!runtime.hasKind(kind)) {
+        throw new CapabilityError(`The runtime holds no kind '${kind}'.`, 'NOT_FOUND', {
+            reason: 'kind-not-registered',
+            retryable: false,
+            details: { kind: 'runtime/kind', id: kind }
+        });
+    }
+    return kind;
+}
+/** Descriptors for `kind`, read without loading any implementation. */
+export function exportDescriptors(runtime, kind, limit = Infinity) {
+    if (!runtime.hasKind(kind))
+        return [];
+    return runtime
+        .query(kind)
+        .descriptors()
+        .slice(0, limit)
+        .map((descriptor) => ({
+        kind: descriptor.kind,
+        id: descriptor.id,
+        name: descriptor.name,
+        description: descriptor.description,
+        tags: descriptor.tags ?? [],
+        hardware: descriptor.hardware ?? [],
+        enabled: descriptor.enabled ?? true,
+        priority: descriptor.priority,
+        capabilityId: descriptor.capabilityId
+    }));
+}
+/** The owner's declared scope facts, normalized to its JSON wire contract. */
+function exportScope(scope) {
+    const value = JsonValueFromReaderSchema.parse(scope);
+    if (!isJsonObject(value)) {
+        throw new CapabilityError('Runtime export scope must be a JSON object.', 'INVALID_INPUT', {
+            reason: 'runtime-export-scope-invalid'
+        });
+    }
+    return value;
+}
+/**
+ * A zod schema's published name, when it has one.
+ *
+ * Zod 4 stores the schema's identity under `_zod.def.type`; a schema written by
+ * hand may publish a `description` instead. Either is a stable handle for the
+ * shape, which is what a reader needs; neither changes the export's facts.
+ */
+function schemaNameOf(schema) {
+    const identity = SchemaIdentitySchema.safeParse(schema);
+    if (identity.success)
+        return identity.data._zod?.def?.type;
+    const described = SchemaDescriptionSchema.safeParse(schema);
+    return described.success ? described.data.description : undefined;
+}
+/** Zod 4's published identity for a schema. */
+const SchemaIdentitySchema = z.looseObject({ _zod: z.looseObject({ def: z.looseObject({ type: z.string().optional() }) }).optional() });
+const SchemaDescriptionSchema = z.looseObject({ description: z.string().optional() });
+//# sourceMappingURL=read.js.map

package/dist/commands/runtime/export/read.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.js","sourceRoot":"","sources":["../../../../src/commands/runtime/export/read.ts"],"names":[],"mappings":"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"}

package/dist/commands/runtime/export/reading-notes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * What a reader needs to know before trusting the tables.
+ *
+ * This is prose, not structure, and it is prose on purpose: a reader who assumes
+ * these counts are a catalogue will draw the wrong conclusion from a perfectly
+ * correct document, so the document says what it is before it shows what it says.
+ * It lives apart from the renderer because no code path decides it — only a
+ * writer of it does.
+ */
+export declare const READING_NOTES: readonly string[];
+//# sourceMappingURL=reading-notes.d.ts.map

package/dist/commands/runtime/export/reading-notes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reading-notes.d.ts","sourceRoot":"","sources":["../../../../src/commands/runtime/export/reading-notes.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,aAAa,EAAE,SAAS,MAAM,EAkC1C,CAAC"}

package/dist/commands/runtime/export/reading-notes.js

@@ -0,0 +1,45 @@
+/**
+ * What a reader needs to know before trusting the tables.
+ *
+ * This is prose, not structure, and it is prose on purpose: a reader who assumes
+ * these counts are a catalogue will draw the wrong conclusion from a perfectly
+ * correct document, so the document says what it is before it shows what it says.
+ * It lives apart from the renderer because no code path decides it — only a
+ * writer of it does.
+ */
+export const READING_NOTES = [
+    '## How to read this document',
+    '',
+    'This is a **snapshot of one boot in one workspace**, not a catalogue. Which',
+    'plugins composed, which kinds they registered, and how many descriptors each kind',
+    'holds are all properties of that particular process. A different workspace, a',
+    'different host, or a different day produces a different document.',
+    '',
+    'Regenerate it with:',
+    '',
+    '```sh',
+    'vibes runtime export RUNTIME-REFERENCE.md          # this file, from the workspace root',
+    'vibes runtime export -f json                       # the same facts, for something that diffs them',
+    'vibes runtime export --kind tools/tool             # one kind and every descriptor it holds',
+    'vibes runtime export --no-descriptors               # the counts, without the tables',
+    '```',
+    '',
+    '### Reading the tables',
+    '',
+    '**Plugins** are what the workspace composed, grouped by the composition plane',
+    'that selected them (floor, global, workspace, literal). A plugin that appears',
+    "under `workspace` came from this workspace's own configuration.",
+    '',
+    '**Kinds** are the categories of asset the runtime can hold. `Descriptors` is how',
+    'many this runtime holds for the kind. `Contexts` are the context ids that kind\'s',
+    'implementations receive. `Default` says the kind can answer for a descriptor that',
+    'has no loader of its own; `Resolver` says it encodes its own selection policy.',
+    '`Ownership` is `single-owner` when a second registration of the same id is',
+    'refused, `shared` when candidates layer.',
+    '',
+    '**Descriptors** are the individual assets. Reading them never loads an',
+    'implementation: a descriptor is declarative identity, and resolution is what loads',
+    'behaviour. Each kind shows up to 12 rows; `--kind <id>` shows all of them.',
+    ''
+];
+//# sourceMappingURL=reading-notes.js.map

package/dist/commands/runtime/export/reading-notes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reading-notes.js","sourceRoot":"","sources":["../../../../src/commands/runtime/export/reading-notes.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,CAAC,MAAM,aAAa,GAAsB;IAC/C,8BAA8B;IAC9B,EAAE;IACF,6EAA6E;IAC7E,mFAAmF;IACnF,+EAA+E;IAC/E,mEAAmE;IACnE,EAAE;IACF,qBAAqB;IACrB,EAAE;IACF,OAAO;IACP,yFAAyF;IACzF,oGAAoG;IACpG,6FAA6F;IAC7F,sFAAsF;IACtF,KAAK;IACL,EAAE;IACF,wBAAwB;IACxB,EAAE;IACF,+EAA+E;IAC/E,+EAA+E;IAC/E,iEAAiE;IACjE,EAAE;IACF,kFAAkF;IAClF,mFAAmF;IACnF,mFAAmF;IACnF,gFAAgF;IAChF,4EAA4E;IAC5E,0CAA0C;IAC1C,EAAE;IACF,wEAAwE;IACxE,oFAAoF;IACpF,4EAA4E;IAC5E,EAAE;CACF,CAAC"}

package/dist/commands/runtime/export/register.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The `vibes runtime export` Commander binding.
+ *
+ * Written to a file it reports the path it wrote; with no destination it prints
+ * the body to stdout, so it composes in a pipe. The positional argument and
+ * `--output` name one destination — the positional is the form a person types,
+ * so it is a spelling of the same option, never a second behaviour.
+ */
+import type { Command } from 'commander';
+import type { CommandContext } from '../../../schemas/surface.ts';
+import { type RuntimeExportOptions } from './schemas.ts';
+/**
+ * What Commander collects: its flags as typed, before this command's own schema
+ * reads them. Commander stores an option exactly as the declaration typed it, so
+ * the bag is wider than this command's schema — narrowing it is the schema's job.
+ */
+type FlagBag = Record<string, string | number | boolean | string[] | undefined>;
+/**
+ * One declared argument, as Commander collected it: it stores whatever the
+ * declaration typed, and this command's schema is what decides what it means.
+ */
+type PositionalArgument = string | number | boolean | string[] | undefined;
+/**
+ * Read the command's options, letting the positional supply the destination.
+ *
+ * `raw` is whatever Commander collected — an untyped bag of flags — so it is
+ * parsed here rather than trusted, and a malformed flag narrows to absent instead
+ * of refusing the whole export.
+ */
+export declare function runtimeExportOptions(raw: FlagBag | undefined, positional: PositionalArgument | undefined): RuntimeExportOptions;
+/** Register the binding under a `runtime` group. */
+export declare function registerRuntimeExportCommand(parent: Command, context: CommandContext): Promise<void>;
+export {};
+//# sourceMappingURL=register.d.ts.map

package/dist/commands/runtime/export/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/commands/runtime/export/register.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAGlE,OAAO,EAAuD,KAAK,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAE9G;;;;GAIG;AACH,KAAK,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC;AAEhF;;;GAGG;AACH,KAAK,kBAAkB,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;AAG3E;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,EAAE,UAAU,EAAE,kBAAkB,GAAG,SAAS,GAAG,oBAAoB,CAO/H;AAED,oDAAoD;AACpD,wBAAsB,4BAA4B,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CA2B1G"}

package/dist/commands/runtime/export/register.js

@@ -0,0 +1,57 @@
+/**
+ * The `vibes runtime export` Commander binding.
+ *
+ * Written to a file it reports the path it wrote; with no destination it prints
+ * the body to stdout, so it composes in a pipe. The positional argument and
+ * `--output` name one destination — the positional is the form a person types,
+ * so it is a spelling of the same option, never a second behaviour.
+ */
+import { renderRuntimeExportMarkdown } from "./markdown.js";
+import { exportRuntime } from "./read.js";
+import { ExportDestinationSchema, RuntimeExportOptionsSchema } from "./schemas.js";
+import { resolveExportFormat, writeRuntimeExport } from "./write.js";
+/**
+ * Read the command's options, letting the positional supply the destination.
+ *
+ * `raw` is whatever Commander collected — an untyped bag of flags — so it is
+ * parsed here rather than trusted, and a malformed flag narrows to absent instead
+ * of refusing the whole export.
+ */
+export function runtimeExportOptions(raw, positional) {
+    const flags = RuntimeExportOptionsSchema.parse(raw ?? {});
+    const destination = ExportDestinationSchema.safeParse(positional);
+    // The positional wins because it is the more specific thing a person typed;
+    // with none typed, the flags stand on their own.
+    if (destination.success && destination.data !== undefined)
+        return { ...flags, output: destination.data };
+    return flags;
+}
+/** Register the binding under a `runtime` group. */
+export async function registerRuntimeExportCommand(parent, context) {
+    parent
+        .command('export')
+        .description('Export what this runtime holds: plugins, kinds, descriptors, loaders, scope')
+        .argument('[path]', 'Destination path; relative paths resolve against the workspace root (same as --output)')
+        .option('-o, --output <path>', 'Write to this path (relative paths resolve against the workspace root)')
+        .option('-f, --format <format>', 'Output format: markdown | json (default: from the output extension, else markdown)')
+        .option('-k, --kind <kind>', 'Restrict the descriptor detail to one kind')
+        .option('--no-kinds', 'Omit the kind section')
+        .option('--no-plugins', 'Omit the plugin section')
+        .option('--no-descriptors', 'Omit the descriptor table, keeping the counts')
+        .option('-v, --verbose', 'Enable verbose logging')
+        .action(async (positional, raw) => {
+        const options = runtimeExportOptions(raw, positional);
+        const runtime = context.runtime;
+        const exported = exportRuntime(runtime, options.kind);
+        const body = resolveExportFormat(options) === 'json'
+            ? `${JSON.stringify(exported, null, 2)}\n`
+            : renderRuntimeExportMarkdown(exported, runtime, options);
+        if (options.output === undefined) {
+            context.ui?.info(body);
+            return;
+        }
+        const written = await writeRuntimeExport(runtime, options.output, body);
+        context.ui?.success(`Runtime reference written to ${written}`);
+    });
+}
+//# sourceMappingURL=register.js.map

package/dist/commands/runtime/export/register.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.js","sourceRoot":"","sources":["../../../../src/commands/runtime/export/register.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,uBAAuB,EAAE,0BAA0B,EAA6B,MAAM,cAAc,CAAC;AAc9G,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErE;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAAwB,EAAE,UAA0C;IACxG,MAAM,KAAK,GAAG,0BAA0B,CAAC,KAAK,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC;IAC1D,MAAM,WAAW,GAAG,uBAAuB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;IAClE,4EAA4E;IAC5E,iDAAiD;IACjD,IAAI,WAAW,CAAC,OAAO,IAAI,WAAW,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC;IACzG,OAAO,KAAK,CAAC;AACd,CAAC;AAED,oDAAoD;AACpD,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAAC,MAAe,EAAE,OAAuB;IAC1F,MAAM;SACJ,OAAO,CAAC,QAAQ,CAAC;SACjB,WAAW,CAAC,6EAA6E,CAAC;SAC1F,QAAQ,CAAC,QAAQ,EAAE,wFAAwF,CAAC;SAC5G,MAAM,CAAC,qBAAqB,EAAE,wEAAwE,CAAC;SACvG,MAAM,CAAC,uBAAuB,EAAE,oFAAoF,CAAC;SACrH,MAAM,CAAC,mBAAmB,EAAE,4CAA4C,CAAC;SACzE,MAAM,CAAC,YAAY,EAAE,uBAAuB,CAAC;SAC7C,MAAM,CAAC,cAAc,EAAE,yBAAyB,CAAC;SACjD,MAAM,CAAC,kBAAkB,EAAE,+CAA+C,CAAC;SAC3E,MAAM,CAAC,eAAe,EAAE,wBAAwB,CAAC;SACjD,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE;QACjC,MAAM,OAAO,GAAG,oBAAoB,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QACtD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;QAChC,MAAM,QAAQ,GAAG,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;QACtD,MAAM,IAAI,GACT,mBAAmB,CAAC,OAAO,CAAC,KAAK,MAAM;YACtC,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI;YAC1C,CAAC,CAAC,2BAA2B,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QAC5D,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAClC,OAAO,CAAC,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YACvB,OAAO;QACR,CAAC;QACD,MAAM,OAAO,GAAG,MAAM,kBAAkB,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACxE,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,gCAAgC,OAAO,EAAE,CAAC,CAAC;IAChE,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/commands/runtime/export/schemas.d.ts

@@ -0,0 +1,104 @@
+/**
+ * What `vibes runtime export` publishes, and the options that shape it.
+ *
+ * The shapes are here rather than beside the reader because they are the export's
+ * contract, not an implementation detail of one renderer: the markdown a person
+ * reads and the JSON something diffs carry these same facts, and a third format
+ * added later would carry them too. They are all declared facts — ids, counts,
+ * names and booleans — because the export describes what a runtime holds, and a
+ * descriptor's own value is the owner's, not the document's.
+ */
+import * as z from 'zod/v4';
+import type { AssetAccessorInventory } from '@vibesdotdev/kernel/schemas/asset-accessor';
+/** One kind as this runtime holds it. */
+export type ExportedKind = {
+    readonly id: string;
+    /** How many descriptors this runtime holds for it. */
+    readonly descriptorCount: number;
+    /** The schema's own name, when it publishes one; a stable handle for the shape. */
+    readonly schemaName: string | undefined;
+    /** Context ids this kind's implementations receive. */
+    readonly contexts: readonly string[];
+    /** True when the kind declares `resolveDefault` or a default implementation. */
+    readonly hasDefault: boolean;
+    /** True when the kind declares its own `resolve`, i.e. encodes a selection policy. */
+    readonly hasResolver: boolean;
+    /** `'single-owner'` refuses a second static registration; `'shared'` layers candidates. */
+    readonly descriptorOwnership: 'shared' | 'single-owner';
+    /** The registry shape this runtime holds for the kind. */
+    readonly snapshot: ExportedSnapshot;
+};
+/** One descriptor as this runtime holds it, with only its declared facts. */
+export type ExportedDescriptor = {
+    readonly kind: string;
+    readonly id: string;
+    readonly name: string | undefined;
+    readonly description: string | undefined;
+    readonly tags: readonly string[];
+    readonly hardware: readonly string[];
+    readonly enabled: boolean;
+    readonly priority: number | undefined;
+    /** Cross-surface operation identity, when the descriptor declares one. */
+    readonly capabilityId: string | undefined;
+};
+/**
+ * The registry shape, reduced to what serializes.
+ *
+ * `depth` is the stack size for an id — one means a single registration, more
+ * means a shadowing candidate is layered under it. `dynamic` marks a
+ * registration made at runtime rather than declared, and `candidateCount` is how
+ * many scoped candidates a loader holds.
+ */
+export type ExportedSnapshot = AssetAccessorInventory;
+/**
+ * Runtime's declared scope facts normalized to JSON. Optional undefined object
+ * fields are omitted; admitted values are preserved without a nesting marker.
+ */
+export type ExportedScope = Record<string, ScopeValue>;
+/** One admitted scope fact in the JSON wire contract. */
+export declare const ScopeValueSchema: z.ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>;
+export type ScopeValue = z.output<typeof ScopeValueSchema>;
+/** The whole export. Every section is optional-by-absence, never by emptiness. */
+export type RuntimeExport = {
+    readonly phase: string;
+    readonly disposed: boolean;
+    readonly declaredScope: ExportedScope;
+    readonly effectiveScope: ExportedScope;
+    readonly compositionSelections: Readonly<Record<string, readonly string[]>>;
+    readonly plugins: readonly string[];
+    readonly pluginCount: number;
+    readonly kinds: readonly ExportedKind[];
+    readonly kindCount: number;
+    readonly descriptorCount: number;
+    readonly loaderCount: number;
+    /** When the export was taken, as an ISO string. */
+    readonly generatedAt: string;
+};
+/**
+ * The command's options.
+ *
+ * Every field is read on its own and a malformed one becomes absent, so one bad
+ * flag narrows the document rather than refusing the whole export: a reader who
+ * asked for markdown and mistyped the format still gets a document.
+ */
+export declare const RuntimeExportOptionsSchema: z.ZodObject<{
+    output: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    format: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+        json: "json";
+        markdown: "markdown";
+    }>>>;
+    kind: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    includeDescriptors: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+    includeKinds: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+    includePlugins: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+    noDescriptors: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+    noKinds: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+    noPlugins: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+    verbose: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+/** The positional destination: a path a person typed, or nothing at all. */
+export declare const ExportDestinationSchema: z.ZodOptional<z.ZodString>;
+export type RuntimeExportOptions = z.infer<typeof RuntimeExportOptionsSchema>;
+/** A workspace root when the runtime declares one. */
+export declare const ExportWorkspaceRootSchema: z.ZodString;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/commands/runtime/export/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/commands/runtime/export/schemas.ts"],"names":[],"mappings":"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"}

package/dist/commands/runtime/export/schemas.js

@@ -0,0 +1,38 @@
+/**
+ * What `vibes runtime export` publishes, and the options that shape it.
+ *
+ * The shapes are here rather than beside the reader because they are the export's
+ * contract, not an implementation detail of one renderer: the markdown a person
+ * reads and the JSON something diffs carry these same facts, and a third format
+ * added later would carry them too. They are all declared facts — ids, counts,
+ * names and booleans — because the export describes what a runtime holds, and a
+ * descriptor's own value is the owner's, not the document's.
+ */
+import * as z from 'zod/v4';
+import { JsonValueSchema } from '@vibesdotdev/kernel/schemas/json';
+/** One admitted scope fact in the JSON wire contract. */
+export const ScopeValueSchema = JsonValueSchema;
+/**
+ * The command's options.
+ *
+ * Every field is read on its own and a malformed one becomes absent, so one bad
+ * flag narrows the document rather than refusing the whole export: a reader who
+ * asked for markdown and mistyped the format still gets a document.
+ */
+export const RuntimeExportOptionsSchema = z.object({
+    output: z.string().optional().catch(undefined),
+    format: z.enum(['markdown', 'json']).optional().catch(undefined),
+    kind: z.string().optional().catch(undefined),
+    includeDescriptors: z.boolean().optional().catch(undefined),
+    includeKinds: z.boolean().optional().catch(undefined),
+    includePlugins: z.boolean().optional().catch(undefined),
+    noDescriptors: z.boolean().optional().catch(undefined),
+    noKinds: z.boolean().optional().catch(undefined),
+    noPlugins: z.boolean().optional().catch(undefined),
+    verbose: z.boolean().optional().catch(undefined)
+});
+/** The positional destination: a path a person typed, or nothing at all. */
+export const ExportDestinationSchema = z.string().trim().min(1).optional();
+/** A workspace root when the runtime declares one. */
+export const ExportWorkspaceRootSchema = z.string();
+//# sourceMappingURL=schemas.js.map

package/dist/commands/runtime/export/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../../../src/commands/runtime/export/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAoDnE,yDAAyD;AACzD,MAAM,CAAC,MAAM,gBAAgB,GAAG,eAAe,CAAC;AAoBhD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC;IAClD,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;IAC9C,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;IAChE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;IAC5C,kBAAkB,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;IAC3D,YAAY,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;IACrD,cAAc,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;IACvD,aAAa,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;IACtD,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;IAChD,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;IAClD,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;CAChD,CAAC,CAAC;AAEH,4EAA4E;AAC5E,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;AAI3E,sDAAsD;AACtD,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC"}

package/dist/commands/runtime/export/write.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Where `vibes runtime export` writes, and in what format.
+ *
+ * The destination is the workspace root unless the caller names one, so the
+ * common case — `vibes runtime export RUNTIME-REFERENCE.md` — lands where a
+ * reader will look. Filesystem access goes through the runtime's own adapter
+ * rather than the host's, because the command runs inside a runtime that was
+ * handed one.
+ */
+import type { VibesRuntime } from '@vibesdotdev/kernel/api/runtime';
+import type { RuntimeExportOptions } from './schemas.ts';
+/** The format written: explicit, else the output extension, else markdown. */
+export declare function resolveExportFormat(options: RuntimeExportOptions): 'markdown' | 'json';
+/** Write the export and return the absolute path it wrote. */
+export declare function writeRuntimeExport(runtime: VibesRuntime, path: string, body: string): Promise<string>;
+//# sourceMappingURL=write.d.ts.map

package/dist/commands/runtime/export/write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../../../src/commands/runtime/export/write.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEzD,8EAA8E;AAC9E,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,UAAU,GAAG,MAAM,CAItF;AAED,8DAA8D;AAC9D,wBAAsB,kBAAkB,CACvC,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACV,OAAO,CAAC,MAAM,CAAC,CAOjB"}

package/dist/commands/runtime/export/write.js

@@ -0,0 +1,36 @@
+/**
+ * Where `vibes runtime export` writes, and in what format.
+ *
+ * The destination is the workspace root unless the caller names one, so the
+ * common case — `vibes runtime export RUNTIME-REFERENCE.md` — lands where a
+ * reader will look. Filesystem access goes through the runtime's own adapter
+ * rather than the host's, because the command runs inside a runtime that was
+ * handed one.
+ */
+import { requireRuntimeCwd } from '@vibesdotdev/kernel';
+import { ExportWorkspaceRootSchema } from "./schemas.js";
+import { getRuntimePath } from '@vibesdotdev/paths';
+import { resolveFileSystemAdapter } from '@vibesdotdev/filesystem/client';
+/** The format written: explicit, else the output extension, else markdown. */
+export function resolveExportFormat(options) {
+    if (options.format !== undefined)
+        return options.format;
+    if (options.output?.toLowerCase().endsWith('.json'))
+        return 'json';
+    return 'markdown';
+}
+/** Write the export and return the absolute path it wrote. */
+export async function writeRuntimeExport(runtime, path, body) {
+    const fs = await resolveFileSystemAdapter(runtime, { binding: false });
+    const runtimePath = await getRuntimePath(runtime);
+    const absolute = runtimePath.isAbsolute(path) ? path : runtimePath.join(hostWorkspaceRoot(runtime) ?? requireRuntimeCwd(runtime), path);
+    await fs.mkdir(runtimePath.dirname(absolute), { recursive: true });
+    await fs.writeFile(absolute, body, 'utf8');
+    return absolute;
+}
+/** The workspace the runtime bound, which is where a relative export belongs. */
+function hostWorkspaceRoot(runtime) {
+    const root = ExportWorkspaceRootSchema.safeParse(runtime.declaredScope.workspace?.root);
+    return root.success ? root.data : undefined;
+}
+//# sourceMappingURL=write.js.map

package/dist/commands/runtime/export/write.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"write.js","sourceRoot":"","sources":["../../../../src/commands/runtime/export/write.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAI1E,8EAA8E;AAC9E,MAAM,UAAU,mBAAmB,CAAC,OAA6B;IAChE,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS;QAAE,OAAO,OAAO,CAAC,MAAM,CAAC;IACxD,IAAI,OAAO,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC;QAAE,OAAO,MAAM,CAAC;IACnE,OAAO,UAAU,CAAC;AACnB,CAAC;AAED,8DAA8D;AAC9D,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACvC,OAAqB,EACrB,IAAY,EACZ,IAAY;IAEZ,MAAM,EAAE,GAAG,MAAM,wBAAwB,CAAC,OAAO,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;IACvE,MAAM,WAAW,GAAG,MAAM,cAAc,CAAC,OAAO,CAAC,CAAC;IAClD,MAAM,QAAQ,GAAG,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,iBAAiB,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,CAAC;IACxI,MAAM,EAAE,CAAC,KAAK,CAAC,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACnE,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IAC3C,OAAO,QAAQ,CAAC;AACjB,CAAC;AAED,iFAAiF;AACjF,SAAS,iBAAiB,CAAC,OAAqB;IAC/C,MAAM,IAAI,GAAG,yBAAyB,CAAC,SAAS,CAAC,OAAO,CAAC,aAAa,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IACxF,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;AAC7C,CAAC"}

package/dist/commands/runtime/export.command.impl.d.ts

@@ -0,0 +1,18 @@
+import type { CommandContext, CommandOptions } from '../../schemas/surface.ts';
+/**
+ * `runtime export`: the `cli/command` implementation.
+ *
+ * The export is read from `context.runtime` — the runtime this action runs on,
+ * which after a serve transition is the serve host's. A failure is the typed
+ * refusal `exportRuntime` throws, which the CLI surface reports once.
+ *
+ * The destination may be the first positional argument
+ * (`vibes runtime export RUNTIME-REFERENCE.md`) or `--output`; the two name one
+ * destination, so this reads both and prefers the positional, which is the
+ * spelling the descriptor's example documents.
+ */
+export declare const runtimeExportCommandImpl: import("@vibesdotdev/kernel").RuntimeImplementationWrapper<{
+    execute: (args: CommandOptions, opts: CommandOptions, context: CommandContext) => Promise<void>;
+}>;
+export default runtimeExportCommandImpl;
+//# sourceMappingURL=export.command.impl.d.ts.map

package/dist/commands/runtime/export.command.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.command.impl.d.ts","sourceRoot":"","sources":["../../../src/commands/runtime/export.command.impl.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAU/E;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB;oBAIb,cAAc,QAAQ,cAAc,WAAW,cAAc;EAkBnF,CAAC;AAEH,eAAe,wBAAwB,CAAC"}

package/dist/commands/runtime/export.command.impl.js

@@ -0,0 +1,39 @@
+import { createRuntimeImplementation } from '@vibesdotdev/kernel';
+import { writeStdout } from "../../commands/output.js";
+import { exportRuntime, renderRuntimeExportMarkdown, resolveExportFormat, runtimeExportOptions, writeRuntimeExport } from "./export.js";
+/**
+ * `runtime export`: the `cli/command` implementation.
+ *
+ * The export is read from `context.runtime` — the runtime this action runs on,
+ * which after a serve transition is the serve host's. A failure is the typed
+ * refusal `exportRuntime` throws, which the CLI surface reports once.
+ *
+ * The destination may be the first positional argument
+ * (`vibes runtime export RUNTIME-REFERENCE.md`) or `--output`; the two name one
+ * destination, so this reads both and prefers the positional, which is the
+ * spelling the descriptor's example documents.
+ */
+export const runtimeExportCommandImpl = createRuntimeImplementation({
+    id: 'runtime-export',
+    kind: 'cli/command',
+    implementation: {
+        execute: async (args, opts, context) => {
+            const options = runtimeExportOptions(opts, args.path);
+            const runtime = context.runtime;
+            const exported = exportRuntime(runtime, options.kind);
+            const body = resolveExportFormat(options) === 'json'
+                ? `${JSON.stringify(exported, null, 2)}\n`
+                : renderRuntimeExportMarkdown(exported, runtime, options);
+            if (options.output === undefined) {
+                // No destination: the body is the answer, so it goes to stdout and
+                // nothing else does. A consumer piping this gets the document.
+                await writeStdout(runtime, body);
+                return;
+            }
+            const written = await writeRuntimeExport(runtime, options.output, body);
+            await writeStdout(runtime, `Runtime reference written to ${written}\n`);
+        }
+    }
+});
+export default runtimeExportCommandImpl;
+//# sourceMappingURL=export.command.impl.js.map

package/dist/commands/runtime/export.command.impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.command.impl.js","sourceRoot":"","sources":["../../../src/commands/runtime/export.command.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AAElE,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EACN,aAAa,EACb,2BAA2B,EAC3B,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,EAClB,MAAM,aAAa,CAAC;AAErB;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,2BAA2B,CAAC;IACnE,EAAE,EAAE,gBAAgB;IACpB,IAAI,EAAE,aAAa;IACnB,cAAc,EAAE;QACf,OAAO,EAAE,KAAK,EAAE,IAAoB,EAAE,IAAoB,EAAE,OAAuB,EAAE,EAAE;YACtF,MAAM,OAAO,GAAG,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YACtD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;YAChC,MAAM,QAAQ,GAAG,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;YACtD,MAAM,IAAI,GACT,mBAAmB,CAAC,OAAO,CAAC,KAAK,MAAM;gBACtC,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI;gBAC1C,CAAC,CAAC,2BAA2B,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;YAC5D,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;gBAClC,mEAAmE;gBACnE,+DAA+D;gBAC/D,MAAM,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;gBACjC,OAAO;YACR,CAAC;YACD,MAAM,OAAO,GAAG,MAAM,kBAAkB,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YACxE,MAAM,WAAW,CAAC,OAAO,EAAE,gCAAgC,OAAO,IAAI,CAAC,CAAC;QACzE,CAAC;KACD;CACD,CAAC,CAAC;AAEH,eAAe,wBAAwB,CAAC"}

package/dist/commands/runtime/export.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `vibes runtime export [PATH]` — what this runtime actually holds.
+ *
+ * A runtime is not knowable from its source. Which plugins composed, which kinds
+ * those plugins registered, how many descriptors each kind holds, which loaders
+ * are attached and where each one came from — all of that is a property of a boot,
+ * not of a package manifest. This command reports it from the live runtime the CLI
+ * handed it, so the answer describes the process in front of you.
+ *
+ * It exports to markdown for a document a person or an agent reads, and to JSON
+ * for something that diffs. Both carry the same facts; markdown groups them the
+ * way a reader needs, JSON preserves the exact shape.
+ *
+ * Nothing here recomputes or infers. A descriptor is listed because the runtime
+ * holds it, a loader because the runtime registered it, a plugin because the
+ * runtime composed it. A kind with no descriptors is still listed: an empty
+ * catalog is evidence, not an absence.
+ *
+ * The four parts are one concern each — `schemas.ts` is what the export is,
+ * `read.ts` asks the runtime, `markdown.ts` writes the document, `write.ts` puts
+ * it on disk — and this module is the one name they are all reachable through.
+ */
+export { renderRuntimeExportMarkdown } from './export/markdown.ts';
+export { exportDescriptors, exportRuntime } from './export/read.ts';
+export { registerRuntimeExportCommand, runtimeExportOptions } from './export/register.ts';
+export { ExportDestinationSchema, RuntimeExportOptionsSchema, ScopeValueSchema, type ExportedDescriptor, type ExportedKind, type ExportedScope, type ExportedSnapshot, type RuntimeExport, type RuntimeExportOptions, type ScopeValue } from './export/schemas.ts';
+export { resolveExportFormat, writeRuntimeExport } from './export/write.ts';
+//# sourceMappingURL=export.d.ts.map

package/dist/commands/runtime/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../../src/commands/runtime/export.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EAAE,4BAA4B,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC1F,OAAO,EACN,uBAAuB,EACvB,0BAA0B,EAC1B,gBAAgB,EAChB,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,UAAU,EACf,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC"}