@deftai/directive-core 0.92.0 → 0.93.0

package/dist/init-deposit/slash-deposit.js

@@ -0,0 +1,174 @@
+/**
+ * Multi-host init/update deposit for native slash command files (#3054 / epic #55).
+ *
+ * Wires #3053 emitters into the init/update deposit path:
+ * - Default enabled set = hosts with real emitters (L6)
+ * - Per-host opt-out via `plan.policy.hostSlashCommands`
+ * - Idempotent managed rewrite (no duplicate pile-up)
+ * - Prefer commit of **managed product paths only** (L8) — exact allowlist, not whole dirs
+ *
+ * Parallel to agent-hooks deposit; does not touch hook JSON configs.
+ *
+ * Ownership: only create/update/remove files that are missing or still look like
+ * Directive thin wrappers (`isThinWrapperMarkdown`). Consumer-customized content
+ * at a product filename is left untouched.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { assertDepositContained } from "../deposit/contain.js";
+import { containedWrite } from "../fs/contained-write.js";
+import { isHostSlashCommandDepositEnabled, loadHostSlashCommandsPolicyFromProject, } from "../policy/host-slash-commands.js";
+import { emitHostCommandFiles, getHostCommandLayout, isThinWrapperMarkdown, listSlashEmitterHosts, } from "../slash/index.js";
+import { listProductCommands, logicalIdToFilename } from "../slash/product-set.js";
+/**
+ * Write thin-wrapper command/prompt files for every policy-enabled host.
+ *
+ * Idempotent: skips files whose on-disk bytes already match emission.
+ * Ownership-safe: never overwrites non-thin consumer customizations at product paths.
+ * Opt-out: removes managed thin wrappers only (leaves user customizations alone).
+ */
+export function writeSlashCommandDeposit(projectRoot, io = { printf: () => undefined }, policy = loadHostSlashCommandsPolicyFromProject(projectRoot)) {
+    const rootAbs = resolve(projectRoot);
+    const writtenPaths = [];
+    const removedPaths = [];
+    const preservedCustomPaths = [];
+    const depositedHosts = [];
+    const skippedHosts = [];
+    for (const hostId of listSlashEmitterHosts()) {
+        if (!isHostSlashCommandDepositEnabled(hostId, policy)) {
+            skippedHosts.push(hostId);
+            removedPaths.push(...stripManagedHostCommandFiles(rootAbs, hostId));
+            continue;
+        }
+        depositedHosts.push(hostId);
+        const files = emitHostCommandFiles(hostId);
+        for (const file of files) {
+            const outcome = writeHostCommandFileIfChanged(rootAbs, file);
+            if (outcome === "written")
+                writtenPaths.push(file.relativePath);
+            if (outcome === "preserved")
+                preservedCustomPaths.push(file.relativePath);
+        }
+    }
+    if (writtenPaths.length > 0) {
+        const hostSummary = depositedHosts.join(", ");
+        io.printf(`Installed Directive slash commands for hosts [${hostSummary}]: ${writtenPaths.length} file(s)\n`);
+    }
+    if (preservedCustomPaths.length > 0) {
+        io.printf(`Preserved non-managed slash command customizations: ${preservedCustomPaths.join(", ")}\n`);
+    }
+    if (removedPaths.length > 0) {
+        io.printf(`Removed Directive-managed slash commands (plan.policy.hostSlashCommands opt-out): ${removedPaths.join(", ")}\n`);
+    }
+    if (writtenPaths.length === 0 && removedPaths.length === 0) {
+        if (depositedHosts.length === 0) {
+            io.printf("Directive slash commands: all hosts opted out via plan.policy.hostSlashCommands.\n");
+        }
+        else {
+            io.printf("Directive slash commands already current.\n");
+        }
+    }
+    return {
+        changed: writtenPaths.length + removedPaths.length > 0,
+        writtenPaths,
+        removedPaths,
+        preservedCustomPaths,
+        depositedHosts,
+        skippedHosts,
+    };
+}
+/**
+ * Exact repo-relative product command paths (all emitter hosts).
+ * Used by installerManagedMatchers for L8 prefer-commit staging without
+ * claiming whole host command directories (consumer custom files stay app-owned).
+ */
+export function slashCommandManagedExactPaths() {
+    const paths = [];
+    for (const hostId of listSlashEmitterHosts()) {
+        const dir = getHostCommandLayout(hostId).relativeDir;
+        for (const cmd of listProductCommands()) {
+            paths.push(`${dir}/${logicalIdToFilename(cmd.logicalId)}`);
+        }
+    }
+    return paths;
+}
+function isManagedThinContent(raw, file) {
+    return raw === file.contents || isThinWrapperMarkdown(raw, file.dispatchPath);
+}
+function writeHostCommandFileIfChanged(projectRoot, file) {
+    const absolute = join(projectRoot, file.relativePath);
+    assertDepositContained(projectRoot, absolute);
+    if (existsSync(absolute)) {
+        let raw;
+        try {
+            raw = readFileSync(absolute, "utf8");
+        }
+        catch {
+            // Unreadable existing file: do not clobber consumer content.
+            return "preserved";
+        }
+        if (raw === file.contents)
+            return "unchanged";
+        // Ownership gate: only rewrite managed thin wrappers.
+        if (!isManagedThinContent(raw, file)) {
+            return "preserved";
+        }
+    }
+    const parent = dirname(absolute);
+    mkdirSync(parent, { recursive: true });
+    // Atomic replace via temp under project root (#2951).
+    const tmpName = `${basename(absolute)}.deft-${process.pid}.tmp`;
+    const temporary = join(parent, tmpName);
+    try {
+        containedWrite({
+            root: projectRoot,
+            target: temporary,
+            data: file.contents,
+            mode: "replace",
+        });
+        renameSync(temporary, absolute);
+    }
+    catch (err) {
+        try {
+            rmSync(temporary, { force: true });
+        }
+        catch {
+            /* best-effort cleanup */
+        }
+        throw err;
+    }
+    return "written";
+}
+/**
+ * On opt-out, remove only product-set managed thin wrappers for that host.
+ * User-authored or non-thin files under the host command dir are left untouched.
+ */
+function stripManagedHostCommandFiles(projectRoot, hostId) {
+    const removed = [];
+    const files = emitHostCommandFiles(hostId);
+    for (const file of files) {
+        const absolute = join(projectRoot, file.relativePath);
+        assertDepositContained(projectRoot, absolute);
+        if (!existsSync(absolute))
+            continue;
+        let raw;
+        try {
+            raw = readFileSync(absolute, "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (!isManagedThinContent(raw, file)) {
+            continue;
+        }
+        try {
+            rmSync(absolute, { force: true });
+            removed.push(file.relativePath);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    return removed;
+}
+//# sourceMappingURL=slash-deposit.js.map

package/dist/policy/host-slash-commands.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Per-host slash-command deposit policy (#3054 / epic #55 L6).
+ *
+ * Parallel to {@link plan.policy.hostHooks}: default multi-host enablement for
+ * every host that has a real emitter (no stubs). Per-host `false` opts out.
+ */
+import { type SlashEmitterHostId } from "../slash/emitters.js";
+export declare const FIELD_HOST_SLASH_COMMANDS = "plan.policy.hostSlashCommands";
+export declare const FIELD_HOST_SLASH_COMMANDS_CLI_ALIAS = "hostSlashCommands";
+/** Per-host Directive slash-command deposit toggles (#3054). */
+export type HostSlashCommandsPolicy = Record<SlashEmitterHostId, boolean>;
+/** Default = all hosts with real emitters enabled (L6; not single-host-only). */
+export declare const DEFAULT_HOST_SLASH_COMMANDS_POLICY: HostSlashCommandsPolicy;
+export interface HostSlashCommandsPolicyField {
+    readonly name: string;
+    readonly current: HostSlashCommandsPolicy;
+    readonly default: HostSlashCommandsPolicy;
+    readonly source: string;
+}
+/** Resolve typed slash-command deposit policy from raw PROJECT-DEFINITION value. */
+export declare function resolveHostSlashCommandsPolicy(raw: unknown): HostSlashCommandsPolicy;
+export declare function validateHostSlashCommands(value: unknown): string[];
+export declare function isHostSlashCommandDepositEnabled(host: SlashEmitterHostId, policy?: HostSlashCommandsPolicy): boolean;
+/** Inspector row for `policy:show --field=hostSlashCommands`. */
+export declare function inspectHostSlashCommands(data: Record<string, unknown> | null): HostSlashCommandsPolicyField;
+/** Resolve slash-command deposit policy from PROJECT-DEFINITION on disk. */
+export declare function loadHostSlashCommandsPolicyFromProject(projectRoot: string): HostSlashCommandsPolicy;
+//# sourceMappingURL=host-slash-commands.d.ts.map

package/dist/policy/host-slash-commands.js

@@ -0,0 +1,103 @@
+/**
+ * Per-host slash-command deposit policy (#3054 / epic #55 L6).
+ *
+ * Parallel to {@link plan.policy.hostHooks}: default multi-host enablement for
+ * every host that has a real emitter (no stubs). Per-host `false` opts out.
+ */
+import { isSlashEmitterHostId, SLASH_EMITTER_HOSTS, } from "../slash/emitters.js";
+import { readPlanPolicy } from "./plan-extensions.js";
+import { loadProjectDefinition } from "./resolve.js";
+export const FIELD_HOST_SLASH_COMMANDS = "plan.policy.hostSlashCommands";
+export const FIELD_HOST_SLASH_COMMANDS_CLI_ALIAS = "hostSlashCommands";
+/** Default = all hosts with real emitters enabled (L6; not single-host-only). */
+export const DEFAULT_HOST_SLASH_COMMANDS_POLICY = Object.freeze({
+    claude: true,
+    cursor: true,
+    grok: true,
+    codex: true,
+});
+function readHostBoolean(rec, host, fallback) {
+    if (host in rec && typeof rec[host] === "boolean") {
+        return rec[host];
+    }
+    return fallback;
+}
+/** Resolve typed slash-command deposit policy from raw PROJECT-DEFINITION value. */
+export function resolveHostSlashCommandsPolicy(raw) {
+    if (raw === null || raw === undefined) {
+        return { ...DEFAULT_HOST_SLASH_COMMANDS_POLICY };
+    }
+    if (typeof raw !== "object" || Array.isArray(raw)) {
+        return { ...DEFAULT_HOST_SLASH_COMMANDS_POLICY };
+    }
+    const rec = raw;
+    return {
+        claude: readHostBoolean(rec, "claude", DEFAULT_HOST_SLASH_COMMANDS_POLICY.claude),
+        cursor: readHostBoolean(rec, "cursor", DEFAULT_HOST_SLASH_COMMANDS_POLICY.cursor),
+        grok: readHostBoolean(rec, "grok", DEFAULT_HOST_SLASH_COMMANDS_POLICY.grok),
+        codex: readHostBoolean(rec, "codex", DEFAULT_HOST_SLASH_COMMANDS_POLICY.codex),
+    };
+}
+export function validateHostSlashCommands(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        return [`${FIELD_HOST_SLASH_COMMANDS} must be an object; got ${typeof value}`];
+    }
+    const rec = value;
+    const errors = [];
+    for (const host of SLASH_EMITTER_HOSTS) {
+        if (host in rec && typeof rec[host] !== "boolean") {
+            errors.push(`${FIELD_HOST_SLASH_COMMANDS}.${host} must be a boolean`);
+        }
+    }
+    for (const key of Object.keys(rec)) {
+        if (!isSlashEmitterHostId(key)) {
+            errors.push(`${FIELD_HOST_SLASH_COMMANDS}.${key} is not a slash emitter host (${SLASH_EMITTER_HOSTS.join(", ")})`);
+        }
+    }
+    return errors;
+}
+export function isHostSlashCommandDepositEnabled(host, policy = DEFAULT_HOST_SLASH_COMMANDS_POLICY) {
+    return policy[host];
+}
+function fieldFromResolved(resolved, source) {
+    return {
+        name: FIELD_HOST_SLASH_COMMANDS,
+        current: resolved,
+        default: { ...DEFAULT_HOST_SLASH_COMMANDS_POLICY },
+        source,
+    };
+}
+/** Inspector row for `policy:show --field=hostSlashCommands`. */
+export function inspectHostSlashCommands(data) {
+    if (data === null) {
+        return fieldFromResolved({ ...DEFAULT_HOST_SLASH_COMMANDS_POLICY }, "default");
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("hostSlashCommands" in policyBlock)) {
+        return fieldFromResolved({ ...DEFAULT_HOST_SLASH_COMMANDS_POLICY }, "default");
+    }
+    const resolved = resolveHostSlashCommandsPolicy(policyBlock.hostSlashCommands);
+    return fieldFromResolved(resolved, "typed");
+}
+/** Resolve slash-command deposit policy from PROJECT-DEFINITION on disk. */
+export function loadHostSlashCommandsPolicyFromProject(projectRoot) {
+    const [data] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return { ...DEFAULT_HOST_SLASH_COMMANDS_POLICY };
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("hostSlashCommands" in policyBlock)) {
+        return { ...DEFAULT_HOST_SLASH_COMMANDS_POLICY };
+    }
+    return resolveHostSlashCommandsPolicy(policyBlock.hostSlashCommands);
+}
+//# sourceMappingURL=host-slash-commands.js.map

package/dist/policy/index.d.ts

@@ -6,6 +6,7 @@ export * from "./deft-directive-disable.js";
 export * from "./delivery-branch.js";
 export * from "./disclosure.js";
 export * from "./host-hooks.js";
+export * from "./host-slash-commands.js";
 export * from "./hotfix-criteria.js";
 export * from "./intent-ceiling.js";
 export * from "./no-deft-directive.js";

package/dist/policy/index.js

@@ -1,5 +1,8 @@
+import { FIELD_HOST_SKILL_DISCOVERY, FIELD_HOST_SKILL_DISCOVERY_CLI_ALIAS, inspectHostSkillDiscovery, } from "../init-deposit/skill-discovery-hosts.js";
+import { FIELD_OPENCLAW_PRODUCT_COMMANDS, FIELD_OPENCLAW_PRODUCT_COMMANDS_CLI_ALIAS, inspectOpenClawProductCommands, } from "../slash/openclaw-deposit.js";
 import { FIELD_DELIVERY_BRANCH, FIELD_DELIVERY_BRANCH_CLI_ALIAS, inspectDeliveryBranch, } from "./delivery-branch.js";
 import { FIELD_HOST_HOOKS, FIELD_HOST_HOOKS_CLI_ALIAS, inspectHostHooks } from "./host-hooks.js";
+import { FIELD_HOST_SLASH_COMMANDS, FIELD_HOST_SLASH_COMMANDS_CLI_ALIAS, inspectHostSlashCommands, } from "./host-slash-commands.js";
 import { FIELD_HOTFIX_CRITERIA, FIELD_HOTFIX_CRITERIA_CLI_ALIAS, inspectHotfixCriteria, } from "./hotfix-criteria.js";
 import { readPlanPolicy } from "./plan-extensions.js";
 import { FIELD_PRODUCT_SIGNAL, FIELD_PRODUCT_SIGNAL_CLI_ALIAS, inspectProductSignal, } from "./product-signal.js";
@@ -17,6 +20,7 @@ export * from "./deft-directive-disable.js";
 export * from "./delivery-branch.js";
 export * from "./disclosure.js";
 export * from "./host-hooks.js";
+export * from "./host-slash-commands.js";
 export * from "./hotfix-criteria.js";
 export * from "./intent-ceiling.js";
 export * from "./no-deft-directive.js";
@@ -282,6 +286,33 @@ function inspectHostHooksField(data) {
         source: field.source,
     };
 }
+function inspectHostSlashCommandsField(data) {
+    const field = inspectHostSlashCommands(data);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
+function inspectOpenClawProductCommandsField(data) {
+    const field = inspectOpenClawProductCommands(data);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
+function inspectHostSkillDiscoveryField(data) {
+    const field = inspectHostSkillDiscovery(data);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 function inspectRequireHumanMergeField(data, projectRoot) {
     const field = inspectRequireHumanMerge(data, projectRoot);
     return {
@@ -323,6 +354,9 @@ const REGISTERED_POLICIES = [
     inspectSwarmSubagentBackend,
     inspectDeliveryBranchField,
     inspectHostHooksField,
+    inspectHostSlashCommandsField,
+    inspectOpenClawProductCommandsField,
+    inspectHostSkillDiscoveryField,
     inspectStalenessTicklerField,
     inspectRuntimeAuthorityField,
     inspectProductSignalField,
@@ -347,13 +381,19 @@ export function inspectOnePolicy(name, projectRoot) {
                     ? FIELD_RUNTIME_AUTHORITY
                     : name === FIELD_HOST_HOOKS_CLI_ALIAS
                         ? FIELD_HOST_HOOKS
-                        : name === FIELD_REQUIRE_HUMAN_MERGE_CLI_ALIAS
-                            ? FIELD_REQUIRE_HUMAN_MERGE
-                            : name === FIELD_HOTFIX_CRITERIA_CLI_ALIAS
-                                ? FIELD_HOTFIX_CRITERIA
-                                : name === FIELD_DELIVERY_BRANCH_CLI_ALIAS
-                                    ? FIELD_DELIVERY_BRANCH
-                                    : name;
+                        : name === FIELD_HOST_SLASH_COMMANDS_CLI_ALIAS
+                            ? FIELD_HOST_SLASH_COMMANDS
+                            : name === FIELD_OPENCLAW_PRODUCT_COMMANDS_CLI_ALIAS
+                                ? FIELD_OPENCLAW_PRODUCT_COMMANDS
+                                : name === FIELD_HOST_SKILL_DISCOVERY_CLI_ALIAS
+                                    ? FIELD_HOST_SKILL_DISCOVERY
+                                    : name === FIELD_REQUIRE_HUMAN_MERGE_CLI_ALIAS
+                                        ? FIELD_REQUIRE_HUMAN_MERGE
+                                        : name === FIELD_HOTFIX_CRITERIA_CLI_ALIAS
+                                            ? FIELD_HOTFIX_CRITERIA
+                                            : name === FIELD_DELIVERY_BRANCH_CLI_ALIAS
+                                                ? FIELD_DELIVERY_BRANCH
+                                                : name;
     for (const field of inspectAllPolicies(projectRoot)) {
         if (field.name === normalized)
             return field;

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