@deftai/directive-core 0.92.0 → 0.94.0

package/dist/review-monitor/l4-owner.js

@@ -0,0 +1,262 @@
+/**
+ * Owner Continuity / L4 owner gate (#3090).
+ *
+ * Exit 0 only when a fresh sticky review-owner lease exists on the PR,
+ * or the caller asserts `review_cycle: done` after Step 6.
+ * Freeform started/pending/initiated values are rejected.
+ * skipped / n/a / parent-retained are process evidence only — they do NOT
+ * satisfy this machine gate when --pr is required (lease-or-done).
+ */
+import { existsSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { resolveRepo } from "../triage/queue/repo.js";
+import { EXIT_CONFIG_ERROR, EXIT_NOT_READY, EXIT_READY } from "./constants.js";
+import { fetchActiveMonitorFromGithub } from "./record.js";
+export const L4_OWNER_HELP = "usage: task verify:l4-owner -- --pr <N> [options]\n" +
+    "\n" +
+    "Owner Continuity / L4 owner gate (#3090): after drive-to:merge-ready /\n" +
+    "babysit / shepherd claims, exit 0 only when a sticky GitHub review-owner\n" +
+    "lease is fresh on the PR, or the caller asserts --review-cycle done\n" +
+    "(Step 6 fail-closed all-of on HEAD). Freeform started/pending/initiated\n" +
+    "are rejected. skipped / n/a / parent-retained do NOT satisfy this machine\n" +
+    "gate (process A/B/C still applies). Silent hold exits 1.\n" +
+    "\n" +
+    "options:\n" +
+    "  -h, --help                 Show this help and exit 0\n" +
+    "  --pr N                     Pull request number (required unless --help)\n" +
+    "  --repo OWNER/REPO          Repository (optional; inferred from origin)\n" +
+    "  --head-sha SHA             Expected HEAD SHA (optional freshness check)\n" +
+    "  --project-root PATH        Project root (default: cwd)\n" +
+    "  --review-cycle VALUE       done | in_progress:<pr>#<ref> | skipped:<reason> | n/a\n" +
+    "  --json                     Emit structured JSON on stdout\n" +
+    "\n" +
+    "exit codes:\n" +
+    "  0  READY       Fresh sticky lease, or --review-cycle done\n" +
+    "  1  NOT READY   Silent hold / illegal evidence / lease missing\n" +
+    "  2  CONFIG      Usage / path / GitHub fetch error\n";
+const FORBIDDEN_FREEFORM = new Set(["started", "pending", "initiated", "start", "in_progress"]);
+export function parseReviewCycleEvidence(raw) {
+    if (raw === null || raw === undefined || raw.trim() === "") {
+        return { ok: true, value: null };
+    }
+    const value = raw.trim();
+    const lower = value.toLowerCase();
+    if (FORBIDDEN_FREEFORM.has(lower)) {
+        return {
+            ok: false,
+            reason: `illegal freeform review_cycle value '${value}' (#3090); ` +
+                "use done | in_progress:<pr>#<ref> | skipped:<reason> | n/a",
+        };
+    }
+    if (value === "done" || value === "n/a") {
+        return { ok: true, value };
+    }
+    if (value.startsWith("in_progress:")) {
+        const rest = value.slice("in_progress:".length);
+        if (!rest.includes("#") || rest.endsWith("#") || rest.startsWith("#")) {
+            return {
+                ok: false,
+                reason: "in_progress requires form in_progress:<pr>#<monitor_or_lease_ref> (#3090)",
+            };
+        }
+        const prPart = rest.slice(0, rest.indexOf("#"));
+        if (!/^\d+$/.test(prPart) || Number(prPart) <= 0) {
+            return {
+                ok: false,
+                reason: "in_progress:<pr> must be a positive integer PR number (#3090)",
+            };
+        }
+        return { ok: true, value: value };
+    }
+    if (value.startsWith("skipped:")) {
+        const rest = value.slice("skipped:".length).trim();
+        if (rest.length === 0) {
+            return { ok: false, reason: "skipped requires a non-empty reason (#3090)" };
+        }
+        return { ok: true, value: value };
+    }
+    return {
+        ok: false,
+        reason: `unknown review_cycle value '${value}' (#3090); ` +
+            "use done | in_progress:<pr>#<ref> | skipped:<reason> | n/a",
+    };
+}
+/** Parse in_progress:<pr>#<ref> into parts; null if not that form. */
+export function parseInProgressEvidence(value) {
+    if (!value.startsWith("in_progress:")) {
+        return null;
+    }
+    const rest = value.slice("in_progress:".length);
+    const hash = rest.indexOf("#");
+    if (hash <= 0) {
+        return null;
+    }
+    const prPart = rest.slice(0, hash);
+    const ref = rest.slice(hash + 1);
+    if (!/^\d+$/.test(prPart) || ref.length === 0) {
+        return null;
+    }
+    return { pr: Number(prPart), ref };
+}
+function oneLine(value) {
+    return value.replace(/\r?\n/g, " ");
+}
+export function evaluateL4OwnerGate(args) {
+    const projectRoot = resolve(args.projectRoot);
+    let isDir = false;
+    try {
+        isDir = existsSync(projectRoot) && statSync(projectRoot).isDirectory();
+    }
+    catch {
+        isDir = false;
+    }
+    if (!isDir) {
+        return {
+            exitCode: EXIT_CONFIG_ERROR,
+            message: `verify_l4_owner: --project-root is not a directory: ${oneLine(projectRoot)}`,
+            monitorRecord: null,
+            reviewCycle: null,
+            path: "config",
+        };
+    }
+    const parsed = parseReviewCycleEvidence(args.reviewCycle);
+    if (!parsed.ok) {
+        return {
+            exitCode: EXIT_NOT_READY,
+            message: `verify_l4_owner: ${oneLine(parsed.reason)}`,
+            monitorRecord: null,
+            reviewCycle: null,
+            path: "illegal",
+        };
+    }
+    // Machine gate is lease-or-done only (#3090). skipped/n/a are handoff enum values
+    // but must not green-light ownership of an open PR without lease or Step 6 done.
+    if (parsed.value === "n/a" || parsed.value?.startsWith("skipped:")) {
+        return {
+            exitCode: EXIT_NOT_READY,
+            message: `verify_l4_owner: review_cycle=${oneLine(parsed.value)} does not satisfy the machine ` +
+                `gate for PR #${args.pr} (#3090). Exit 0 requires a fresh sticky lease or --review-cycle done.`,
+            monitorRecord: null,
+            reviewCycle: parsed.value,
+            path: "none",
+        };
+    }
+    if (parsed.value === "done") {
+        return {
+            exitCode: EXIT_READY,
+            message: `verify_l4_owner: review_cycle=done asserted for PR #${args.pr} (#3090). ` +
+                "Caller MUST have satisfied Step 6 fail-closed all-of on HEAD before this claim.",
+            monitorRecord: null,
+            reviewCycle: "done",
+            path: "done",
+        };
+    }
+    // Validate in_progress PR binding when evidence is present (before lease fetch).
+    if (parsed.value?.startsWith("in_progress:")) {
+        const parts = parseInProgressEvidence(parsed.value);
+        if (parts === null) {
+            return {
+                exitCode: EXIT_NOT_READY,
+                message: `verify_l4_owner: malformed in_progress evidence ${oneLine(parsed.value)} (#3090).`,
+                monitorRecord: null,
+                reviewCycle: parsed.value,
+                path: "illegal",
+            };
+        }
+        if (parts.pr !== args.pr) {
+            return {
+                exitCode: EXIT_NOT_READY,
+                message: `verify_l4_owner: review_cycle PR #${parts.pr} does not match --pr ${args.pr} (#3090). ` +
+                    "Ownership evidence must bind to the target PR.",
+                monitorRecord: null,
+                reviewCycle: parsed.value,
+                path: "none",
+            };
+        }
+    }
+    const repo = resolveRepo(args.repo ?? null, projectRoot);
+    if (repo === null) {
+        return {
+            exitCode: EXIT_CONFIG_ERROR,
+            message: "verify_l4_owner: could not resolve owner/repo — pass --repo OWNER/REPO or run inside a git repo with origin",
+            monitorRecord: null,
+            reviewCycle: parsed.value,
+            path: "config",
+        };
+    }
+    const now = args.now ?? new Date();
+    const githubMonitor = fetchActiveMonitorFromGithub(repo, args.pr, {
+        now,
+        headSha: args.headSha ?? null,
+        seams: args.seams,
+    });
+    if (githubMonitor !== null && typeof githubMonitor === "object" && "error" in githubMonitor) {
+        return {
+            exitCode: EXIT_CONFIG_ERROR,
+            message: `verify_l4_owner: ${oneLine(githubMonitor.error)}`,
+            monitorRecord: null,
+            reviewCycle: parsed.value,
+            path: "config",
+        };
+    }
+    if (githubMonitor !== null) {
+        const ref = parsed.value ??
+            `in_progress:${args.pr}#${githubMonitor.monitor_agent_id}`;
+        return {
+            exitCode: EXIT_READY,
+            message: `verify_l4_owner: active GitHub review-owner lease for PR #${args.pr} ` +
+                `(monitor_agent_id=${oneLine(githubMonitor.monitor_agent_id)}, owner=${oneLine(githubMonitor.owner)}) ` +
+                "— review_cycle path=lease (#3090).",
+            monitorRecord: githubMonitor,
+            reviewCycle: ref,
+            path: "lease",
+        };
+    }
+    // parent-retained is process path B — machine gate cannot verify it (lease-or-done only).
+    if (parsed.value?.startsWith("in_progress:")) {
+        const parts = parseInProgressEvidence(parsed.value);
+        if (parts?.ref === "parent-retained") {
+            return {
+                exitCode: EXIT_NOT_READY,
+                message: `verify_l4_owner: parent-retained for PR #${args.pr} is process path B only (#3090). ` +
+                    "Machine gate requires a sticky <!-- deft:review-owner --> lease or --review-cycle done. " +
+                    "Keep parent dual-source poll/fix; do not emit L4 status:pass as terminal.",
+                monitorRecord: null,
+                reviewCycle: parsed.value,
+                path: "none",
+            };
+        }
+        return {
+            exitCode: EXIT_NOT_READY,
+            message: `verify_l4_owner: review_cycle=${oneLine(parsed.value)} claims in_progress but no sticky ` +
+                `<!-- deft:review-owner --> lease found for PR #${args.pr} (#3090 / #2797).\n` +
+                "  Register: deft review-monitor:register --pr <N> --monitor-agent-id <id> --platform-primitive …",
+            monitorRecord: null,
+            reviewCycle: parsed.value,
+            path: "none",
+        };
+    }
+    return {
+        exitCode: EXIT_NOT_READY,
+        message: `verify_l4_owner: silent hold on PR #${args.pr} — no fresh sticky lease and no ` +
+            "review_cycle=done (#3090 Owner Continuity Gate).\n" +
+            "  Same turn MUST end in A (monitor+lease), B (parent-retained + next dual-source action),\n" +
+            "  or C (explicit BLOCKED/FAILED finish). Check-run SUCCESS alone is not CLEAN.",
+        monitorRecord: null,
+        reviewCycle: null,
+        path: "none",
+    };
+}
+export function l4OwnerResultToJson(result) {
+    return {
+        exit_code: result.exitCode,
+        message: result.message,
+        monitor_agent_id: result.monitorRecord?.monitor_agent_id ?? null,
+        monitor_owner: result.monitorRecord?.owner ?? null,
+        monitor_record: result.monitorRecord,
+        path: result.path,
+        ready: result.exitCode === EXIT_READY,
+        review_cycle: result.reviewCycle,
+    };
+}
+//# sourceMappingURL=l4-owner.js.map

package/dist/slash/emitters.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Per-host native command/prompt emitters (#3053 / epic #55).
+ *
+ * Maps shared thin-wrapper IR from {@link generateThinWrappers} onto each
+ * supported host’s repo-relative path layout. Pure generate-to-path records;
+ * filesystem deposit is init-deposit `writeSlashCommandDeposit` (#3054).
+ *
+ * ## Host id → output directory / file pattern
+ *
+ * | Host id | Relative directory   | Filename pattern   |
+ * |---------|----------------------|--------------------|
+ * | claude  | `.claude/commands/`  | `{hyphen-stem}.md` |
+ * | cursor  | `.cursor/commands/`  | `{hyphen-stem}.md` |
+ * | grok    | `.grok/commands/`    | `{hyphen-stem}.md` |
+ * | codex   | `.codex/prompts/`    | `{hyphen-stem}.md` |
+ *
+ * All four use the shared thin-wrapper markdown template (L5). Adding a host is
+ * an additive layout entry + optional frontmatter reshape — not a new product
+ * name table (L2 lives in product-set / generator only).
+ *
+ * ⊗ Empty stub dirs for “enabled but no emitter” (L6).
+ * ⊗ Native legacy alias files (L3).
+ */
+import { type ThinWrapperIR } from "./generator.js";
+/**
+ * Hosts with a real slash/prompt emitter layout (aligned with hook host ids).
+ * Default enabled set for deposit (#3054) is this list when policy opts in.
+ */
+export declare const SLASH_EMITTER_HOSTS: readonly ["claude", "cursor", "grok", "codex"];
+export type SlashEmitterHostId = (typeof SLASH_EMITTER_HOSTS)[number];
+/** Repo-relative layout for one host’s native command/prompt files. */
+export interface HostCommandLayout {
+    readonly hostId: SlashEmitterHostId;
+    /**
+     * Repo-relative directory (posix, no trailing slash).
+     * Example: `.claude/commands`
+     */
+    readonly relativeDir: string;
+    /** Human-readable file pattern (always `{stem}.md` for v1). */
+    readonly filePattern: string;
+    /**
+     * Kind of native surface the host loads (documentation + deposit policy).
+     * Does not change file contents in v1 — all emit shared thin markdown.
+     */
+    readonly surfaceKind: "commands" | "prompts";
+}
+/**
+ * Documented host id → directory / file pattern mapping (issue #3053 AC).
+ * Frozen; additive registration only.
+ */
+export declare const HOST_COMMAND_LAYOUTS: Readonly<Record<SlashEmitterHostId, HostCommandLayout>>;
+/** One host-native file ready for deposit (#3054) or tests. */
+export interface HostEmittedFile {
+    readonly hostId: SlashEmitterHostId;
+    /** Canonical slash id from the product set. */
+    readonly logicalId: string;
+    /** Hyphen filename stem (L4). */
+    readonly filenameStem: string;
+    /** Basename including `.md`. */
+    readonly filename: string;
+    /** Repo-relative posix path, e.g. `.claude/commands/deft-continue.md`. */
+    readonly relativePath: string;
+    /** Thin-wrapper file contents (frontmatter + body). */
+    readonly contents: string;
+    readonly description: string;
+    readonly dispatchPath: string;
+}
+/** Type guard for {@link SlashEmitterHostId}. */
+export declare function isSlashEmitterHostId(value: string): value is SlashEmitterHostId;
+/** Stable list of hosts that have real emitters (no stubs). */
+export declare function listSlashEmitterHosts(): readonly SlashEmitterHostId[];
+/** Look up the documented layout for a host, or throw. */
+export declare function getHostCommandLayout(hostId: SlashEmitterHostId): HostCommandLayout;
+/**
+ * Build the repo-relative path for one IR entry under a host layout (L4 filenames).
+ */
+export declare function hostRelativePath(hostId: SlashEmitterHostId, filename: string): string;
+/**
+ * Emit host-native file records for one host from shared thin-wrapper IR.
+ *
+ * Does not redefine the L2 product table — defaults to {@link generateThinWrappers}.
+ * Contents stay thin (L5); paths use L4 hyphen names under the host layout.
+ */
+export declare function emitHostCommandFiles(hostId: SlashEmitterHostId, wrappers?: readonly ThinWrapperIR[]): readonly HostEmittedFile[];
+/**
+ * Emit for every host that has a real emitter (default: all of {@link SLASH_EMITTER_HOSTS}).
+ *
+ * Returns a map keyed by host id; each value has count === product set when using
+ * default IR.
+ */
+export declare function emitAllHostCommandFiles(hosts?: readonly SlashEmitterHostId[], wrappers?: readonly ThinWrapperIR[]): ReadonlyMap<SlashEmitterHostId, readonly HostEmittedFile[]>;
+/**
+ * Host-specific markdown reshape hook.
+ *
+ * v1: all hosts share the generator’s host-agnostic `fileMarkdown` (description +
+ * optional argument-hint + thin body). Future hosts may remap frontmatter keys
+ * here without touching the product name table.
+ */
+export declare function renderHostFileContents(_hostId: SlashEmitterHostId, wrapper: ThinWrapperIR): string;
+/** Assert emitted contents remain thin pointers (for tests and deposit validation). */
+export declare function assertThinHostEmission(files: readonly HostEmittedFile[]): void;
+//# sourceMappingURL=emitters.d.ts.map

package/dist/slash/emitters.js

@@ -0,0 +1,148 @@
+/**
+ * Per-host native command/prompt emitters (#3053 / epic #55).
+ *
+ * Maps shared thin-wrapper IR from {@link generateThinWrappers} onto each
+ * supported host’s repo-relative path layout. Pure generate-to-path records;
+ * filesystem deposit is init-deposit `writeSlashCommandDeposit` (#3054).
+ *
+ * ## Host id → output directory / file pattern
+ *
+ * | Host id | Relative directory   | Filename pattern   |
+ * |---------|----------------------|--------------------|
+ * | claude  | `.claude/commands/`  | `{hyphen-stem}.md` |
+ * | cursor  | `.cursor/commands/`  | `{hyphen-stem}.md` |
+ * | grok    | `.grok/commands/`    | `{hyphen-stem}.md` |
+ * | codex   | `.codex/prompts/`    | `{hyphen-stem}.md` |
+ *
+ * All four use the shared thin-wrapper markdown template (L5). Adding a host is
+ * an additive layout entry + optional frontmatter reshape — not a new product
+ * name table (L2 lives in product-set / generator only).
+ *
+ * ⊗ Empty stub dirs for “enabled but no emitter” (L6).
+ * ⊗ Native legacy alias files (L3).
+ */
+import { generateThinWrappers, isThinWrapperMarkdown } from "./generator.js";
+import { PRODUCT_COMMAND_COUNT } from "./product-set.js";
+/**
+ * Hosts with a real slash/prompt emitter layout (aligned with hook host ids).
+ * Default enabled set for deposit (#3054) is this list when policy opts in.
+ */
+export const SLASH_EMITTER_HOSTS = ["claude", "cursor", "grok", "codex"];
+/**
+ * Documented host id → directory / file pattern mapping (issue #3053 AC).
+ * Frozen; additive registration only.
+ */
+export const HOST_COMMAND_LAYOUTS = Object.freeze({
+    claude: Object.freeze({
+        hostId: "claude",
+        relativeDir: ".claude/commands",
+        filePattern: "{stem}.md",
+        surfaceKind: "commands",
+    }),
+    cursor: Object.freeze({
+        hostId: "cursor",
+        relativeDir: ".cursor/commands",
+        filePattern: "{stem}.md",
+        surfaceKind: "commands",
+    }),
+    grok: Object.freeze({
+        hostId: "grok",
+        relativeDir: ".grok/commands",
+        filePattern: "{stem}.md",
+        surfaceKind: "commands",
+    }),
+    codex: Object.freeze({
+        hostId: "codex",
+        relativeDir: ".codex/prompts",
+        filePattern: "{stem}.md",
+        surfaceKind: "prompts",
+    }),
+});
+/** Type guard for {@link SlashEmitterHostId}. */
+export function isSlashEmitterHostId(value) {
+    return SLASH_EMITTER_HOSTS.includes(value);
+}
+/** Stable list of hosts that have real emitters (no stubs). */
+export function listSlashEmitterHosts() {
+    return SLASH_EMITTER_HOSTS;
+}
+/** Look up the documented layout for a host, or throw. */
+export function getHostCommandLayout(hostId) {
+    const layout = HOST_COMMAND_LAYOUTS[hostId];
+    if (layout === undefined) {
+        throw new Error(`No slash emitter layout for host: ${hostId}`);
+    }
+    return layout;
+}
+/**
+ * Build the repo-relative path for one IR entry under a host layout (L4 filenames).
+ */
+export function hostRelativePath(hostId, filename) {
+    const layout = getHostCommandLayout(hostId);
+    // Defensive: refuse path separators in filename so deposit cannot escape relativeDir.
+    if (filename.includes("/") || filename.includes("\\") || filename.includes("..")) {
+        throw new Error(`Invalid command filename for host emit: ${filename}`);
+    }
+    return `${layout.relativeDir}/${filename}`;
+}
+/**
+ * Emit host-native file records for one host from shared thin-wrapper IR.
+ *
+ * Does not redefine the L2 product table — defaults to {@link generateThinWrappers}.
+ * Contents stay thin (L5); paths use L4 hyphen names under the host layout.
+ */
+export function emitHostCommandFiles(hostId, wrappers = generateThinWrappers()) {
+    if (!isSlashEmitterHostId(hostId)) {
+        throw new Error(`Unknown slash emitter host: ${String(hostId)}`);
+    }
+    // Snapshot layout once; additive hosts must register before emit.
+    getHostCommandLayout(hostId);
+    return wrappers.map((w) => {
+        const contents = renderHostFileContents(hostId, w);
+        return {
+            hostId,
+            logicalId: w.logicalId,
+            filenameStem: w.filenameStem,
+            filename: w.filename,
+            relativePath: hostRelativePath(hostId, w.filename),
+            contents,
+            description: w.description,
+            dispatchPath: w.dispatchPath,
+        };
+    });
+}
+/**
+ * Emit for every host that has a real emitter (default: all of {@link SLASH_EMITTER_HOSTS}).
+ *
+ * Returns a map keyed by host id; each value has count === product set when using
+ * default IR.
+ */
+export function emitAllHostCommandFiles(hosts = SLASH_EMITTER_HOSTS, wrappers = generateThinWrappers()) {
+    const out = new Map();
+    for (const hostId of hosts) {
+        out.set(hostId, emitHostCommandFiles(hostId, wrappers));
+    }
+    return out;
+}
+/**
+ * Host-specific markdown reshape hook.
+ *
+ * v1: all hosts share the generator’s host-agnostic `fileMarkdown` (description +
+ * optional argument-hint + thin body). Future hosts may remap frontmatter keys
+ * here without touching the product name table.
+ */
+export function renderHostFileContents(_hostId, wrapper) {
+    return wrapper.fileMarkdown;
+}
+/** Assert emitted contents remain thin pointers (for tests and deposit validation). */
+export function assertThinHostEmission(files) {
+    if (files.length !== PRODUCT_COMMAND_COUNT) {
+        throw new Error(`Expected ${PRODUCT_COMMAND_COUNT} host command files, got ${files.length}`);
+    }
+    for (const f of files) {
+        if (!isThinWrapperMarkdown(f.contents, f.dispatchPath)) {
+            throw new Error(`Non-thin emission for ${f.relativePath}`);
+        }
+    }
+}
+//# sourceMappingURL=emitters.js.map

package/dist/slash/generator.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Host-agnostic thin-wrapper generator for product slash commands (#3052 / epic #55).
+ *
+ * Emits IR + markdown templates that per-host emitters (#3053) format into native
+ * command/prompt/workflow files. Wrappers stay thin (L5): frontmatter description +
+ * short dispatch pointer — never inlined strategy/skill/commands.md bodies.
+ *
+ * ## Token / context budgets (from #55 token design rules)
+ *
+ * | When | Target |
+ * |---|---|
+ * | Idle (user never invokes `/deft…`) | ~0 from command files |
+ * | Catalog (`/` menu: name + description × N) | ≤ ~1k tok for the product set |
+ * | Single invoke | ~40–100 tok thin wrapper body |
+ * | After dispatch | cost of the target strategy/skill (unchanged) |
+ *
+ * Multi-host deposit does not multiply tokens in one session: each host reads only
+ * its own command directory. Real spend is the loaded artifact after invoke.
+ */
+import { logicalIdToFilename, logicalIdToFilenameStem, PRODUCT_COMMAND_COUNT, type ProductCommand } from "./product-set.js";
+/** Rough UTF-8 bytes-per-token estimate (aligned with agents-md-budget). */
+export declare const BYTES_PER_TOKEN_ESTIMATE = 4;
+/** L5: invoke wrapper body budget (≈100 tokens). */
+export declare const MAX_WRAPPER_BODY_TOKENS = 100;
+/** Per-command catalog description hard cap for tests (order-of-magnitude 20–50). */
+export declare const MAX_DESCRIPTION_TOKENS = 50;
+/** Full product-set description catalog budget (≤ ~1k tok). */
+export declare const MAX_CATALOG_TOKENS = 1000;
+/**
+ * Host-agnostic intermediate representation for one thin wrapper.
+ *
+ * Emitters consume this shape without re-listing product names.
+ */
+export interface ThinWrapperIR {
+    /** Canonical slash id, e.g. `/deft:directive:run:interview`. */
+    readonly logicalId: string;
+    /** Hyphen stem without extension. */
+    readonly filenameStem: string;
+    /** On-disk filename including `.md`. */
+    readonly filename: string;
+    /** Catalog description (host frontmatter `description`). */
+    readonly description: string;
+    readonly dispatchKind: ProductCommand["dispatchKind"];
+    /** Content-root-relative primary load path. */
+    readonly dispatchPath: string;
+    readonly argumentHint?: string;
+    /** Body markdown only (no frontmatter). */
+    readonly bodyMarkdown: string;
+    /** Full file: YAML frontmatter + body (host-agnostic template). */
+    readonly fileMarkdown: string;
+    /** Estimated body tokens (UTF-8 bytes / {@link BYTES_PER_TOKEN_ESTIMATE}). */
+    readonly estimatedBodyTokens: number;
+    /** Estimated description tokens. */
+    readonly estimatedDescriptionTokens: number;
+}
+/** Aggregate token budget report for the product set. */
+export interface TokenBudgetReport {
+    readonly commandCount: number;
+    readonly catalogTokens: number;
+    readonly maxBodyTokens: number;
+    readonly maxDescriptionTokens: number;
+    readonly withinBodyBudget: boolean;
+    readonly withinDescriptionBudget: boolean;
+    readonly withinCatalogBudget: boolean;
+    readonly ok: boolean;
+}
+/** Estimate tokens from a UTF-8 string (bytes / 4). */
+export declare function estimateTokens(text: string): number;
+/**
+ * Render the thin body only: short dispatch pointer, no inlined target content.
+ *
+ * Keeps invoke cost in the ~40–100 token band (L5).
+ */
+export declare function renderThinWrapperBody(command: ProductCommand): string;
+/**
+ * Render host-agnostic file markdown: description frontmatter + thin body.
+ *
+ * Per-host emitters may re-shape frontmatter keys; the body semantics stay shared.
+ */
+export declare function renderThinWrapperFile(command: ProductCommand): string;
+/** Build {@link ThinWrapperIR} for one product command. */
+export declare function generateThinWrapper(command: ProductCommand): ThinWrapperIR;
+/**
+ * Generate thin wrappers for the full L2 product set (stable order, count === 13).
+ *
+ * This is the primary API for #3053 emitters.
+ */
+export declare function generateThinWrappers(commands?: readonly ProductCommand[]): readonly ThinWrapperIR[];
+/** Measure catalog + per-wrapper body budgets for the generated set. */
+export declare function measureTokenBudget(wrappers?: readonly ThinWrapperIR[]): TokenBudgetReport;
+/**
+ * Structural check that a wrapper file looks like a thin pointer template.
+ * Used by unit tests and available to emitters for deposit validation.
+ */
+export declare function isThinWrapperMarkdown(fileMarkdown: string, dispatchPath: string): boolean;
+/** Re-export mapping helpers for emitter convenience without a second import path. */
+export { logicalIdToFilename, logicalIdToFilenameStem, PRODUCT_COMMAND_COUNT };
+//# sourceMappingURL=generator.d.ts.map