@deftai/directive-core 0.91.0 → 0.93.0

package/dist/slash/generator.js

@@ -0,0 +1,145 @@
+/**
+ * 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 { listProductCommands, logicalIdToFilename, logicalIdToFilenameStem, PRODUCT_COMMAND_COUNT, } from "./product-set.js";
+/** Rough UTF-8 bytes-per-token estimate (aligned with agents-md-budget). */
+export const BYTES_PER_TOKEN_ESTIMATE = 4;
+/** L5: invoke wrapper body budget (≈100 tokens). */
+export const MAX_WRAPPER_BODY_TOKENS = 100;
+/** Per-command catalog description hard cap for tests (order-of-magnitude 20–50). */
+export const MAX_DESCRIPTION_TOKENS = 50;
+/** Full product-set description catalog budget (≤ ~1k tok). */
+export const MAX_CATALOG_TOKENS = 1000;
+/** Estimate tokens from a UTF-8 string (bytes / 4). */
+export function estimateTokens(text) {
+    return Math.ceil(Buffer.byteLength(text, "utf8") / BYTES_PER_TOKEN_ESTIMATE);
+}
+/**
+ * Render the thin body only: short dispatch pointer, no inlined target content.
+ *
+ * Keeps invoke cost in the ~40–100 token band (L5).
+ */
+export function renderThinWrapperBody(command) {
+    const lines = [
+        `Read and follow \`${command.dispatchPath}\` (content-relative; deposit under \`.deft/core/\` when installed).`,
+        "Honor `$ARGUMENTS` as documented for this command.",
+        "Do not inline the strategy, skill, or commands.md body here.",
+    ];
+    return `${lines.join("\n")}\n`;
+}
+/**
+ * Render host-agnostic file markdown: description frontmatter + thin body.
+ *
+ * Per-host emitters may re-shape frontmatter keys; the body semantics stay shared.
+ */
+export function renderThinWrapperFile(command) {
+    const body = renderThinWrapperBody(command);
+    const frontmatterLines = [`description: ${yamlSingleLine(command.description)}`];
+    if (command.argumentHint !== undefined) {
+        frontmatterLines.push(`argument-hint: ${yamlSingleLine(command.argumentHint)}`);
+    }
+    return `---\n${frontmatterLines.join("\n")}\n---\n\n${body}`;
+}
+function yamlSingleLine(value) {
+    // Descriptions are product-controlled short ASCII; quote when needed for YAML safety.
+    if (/[:#{}[\],&*!|>'"%@`]|^\s|\s$/.test(value) || value === "") {
+        return JSON.stringify(value);
+    }
+    return value;
+}
+/** Build {@link ThinWrapperIR} for one product command. */
+export function generateThinWrapper(command) {
+    const bodyMarkdown = renderThinWrapperBody(command);
+    const fileMarkdown = renderThinWrapperFile(command);
+    return {
+        logicalId: command.logicalId,
+        filenameStem: command.filenameStem,
+        filename: logicalIdToFilename(command.logicalId),
+        description: command.description,
+        dispatchKind: command.dispatchKind,
+        dispatchPath: command.dispatchPath,
+        argumentHint: command.argumentHint,
+        bodyMarkdown,
+        fileMarkdown,
+        estimatedBodyTokens: estimateTokens(bodyMarkdown),
+        estimatedDescriptionTokens: estimateTokens(command.description),
+    };
+}
+/**
+ * Generate thin wrappers for the full L2 product set (stable order, count === 13).
+ *
+ * This is the primary API for #3053 emitters.
+ */
+export function generateThinWrappers(commands = listProductCommands()) {
+    return commands.map(generateThinWrapper);
+}
+/** Measure catalog + per-wrapper body budgets for the generated set. */
+export function measureTokenBudget(wrappers = generateThinWrappers()) {
+    const catalogTokens = wrappers.reduce((sum, w) => sum + w.estimatedDescriptionTokens, 0);
+    const maxBodyTokens = wrappers.reduce((max, w) => Math.max(max, w.estimatedBodyTokens), 0);
+    const maxDescriptionTokens = wrappers.reduce((max, w) => Math.max(max, w.estimatedDescriptionTokens), 0);
+    const withinBodyBudget = wrappers.every((w) => w.estimatedBodyTokens <= MAX_WRAPPER_BODY_TOKENS);
+    const withinDescriptionBudget = wrappers.every((w) => w.estimatedDescriptionTokens <= MAX_DESCRIPTION_TOKENS);
+    const withinCatalogBudget = catalogTokens <= MAX_CATALOG_TOKENS;
+    return {
+        commandCount: wrappers.length,
+        catalogTokens,
+        maxBodyTokens,
+        maxDescriptionTokens,
+        withinBodyBudget,
+        withinDescriptionBudget,
+        withinCatalogBudget,
+        ok: wrappers.length === PRODUCT_COMMAND_COUNT &&
+            withinBodyBudget &&
+            withinDescriptionBudget &&
+            withinCatalogBudget,
+    };
+}
+/**
+ * Structural check that a wrapper file looks like a thin pointer template.
+ * Used by unit tests and available to emitters for deposit validation.
+ */
+export function isThinWrapperMarkdown(fileMarkdown, dispatchPath) {
+    if (!fileMarkdown.startsWith("---\n")) {
+        return false;
+    }
+    const close = fileMarkdown.indexOf("\n---\n", 4);
+    if (close < 0) {
+        return false;
+    }
+    const frontmatter = fileMarkdown.slice(4, close);
+    if (!/^description:\s.+/m.test(frontmatter)) {
+        return false;
+    }
+    const body = fileMarkdown.slice(close + 5);
+    if (!body.includes(dispatchPath)) {
+        return false;
+    }
+    // Fat-body guard: refuse multi-kilobyte dumps / obvious strategy section headers.
+    if (estimateTokens(body) > MAX_WRAPPER_BODY_TOKENS) {
+        return false;
+    }
+    if (/^##\s+(Phase|Workflow|Steps|Acceptance)\b/m.test(body)) {
+        return false;
+    }
+    return true;
+}
+/** Re-export mapping helpers for emitter convenience without a second import path. */
+export { logicalIdToFilename, logicalIdToFilenameStem, PRODUCT_COMMAND_COUNT };
+//# sourceMappingURL=generator.js.map

package/dist/slash/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Slash-command generator + per-host emitters (#3052 / #3053 / epic #55)
+ * + OpenClaw L2 product-command adapter (#3064).
+ *
+ * Product command table + thin-wrapper IR/templates + host path layouts.
+ * Disk deposit for file hosts: init-deposit `writeSlashCommandDeposit` (#3054).
+ * OpenClaw skills deposit: `depositOpenClawL2ProductCommands` (#3064) — not a
+ * fake `.openclaw/commands/` file emitter.
+ */
+export { assertThinHostEmission, emitAllHostCommandFiles, emitHostCommandFiles, getHostCommandLayout, HOST_COMMAND_LAYOUTS, type HostCommandLayout, type HostEmittedFile, hostRelativePath, isSlashEmitterHostId, listSlashEmitterHosts, renderHostFileContents, SLASH_EMITTER_HOSTS, type SlashEmitterHostId, } from "./emitters.js";
+export { BYTES_PER_TOKEN_ESTIMATE, estimateTokens, generateThinWrapper, generateThinWrappers, isThinWrapperMarkdown, MAX_CATALOG_TOKENS, MAX_DESCRIPTION_TOKENS, MAX_WRAPPER_BODY_TOKENS, measureTokenBudget, renderThinWrapperBody, renderThinWrapperFile, type ThinWrapperIR, type TokenBudgetReport, } from "./generator.js";
+export { assertThinOpenClawArtifacts, generateOpenClawSkillArtifacts, isManagedOpenClawL2Skill, isManagedOpenClawRouterSkill, isThinOpenClawSkillMarkdown, listOpenClawManagedSkillSlugs, listOpenClawProductSkillSlugs, OPENCLAW_L2_MANAGED_MARKER, OPENCLAW_L2_ROUTER_MARKER, type OpenClawSkillArtifact, renderOpenClawProductSkillMarkdown, renderOpenClawRouterSkillMarkdown, } from "./openclaw-adapter.js";
+export { DEFAULT_OPENCLAW_PRODUCT_COMMANDS, depositOpenClawL2ProductCommands, FIELD_OPENCLAW_PRODUCT_COMMANDS, FIELD_OPENCLAW_PRODUCT_COMMANDS_CLI_ALIAS, inspectOpenClawProductCommands, loadOpenClawProductCommandsPolicyFromProject, type OpenClawL2DepositOptions, type OpenClawL2DepositResult, type OpenClawProductCommandsPolicy, type OpenClawProductCommandsPolicyField, resolveOpenClawProductCommandsPolicy, validateOpenClawProductCommands, } from "./openclaw-deposit.js";
+export { assertOpenClawSlugMapIntegrity, isValidOpenClawSlug, listOpenClawSlugEntries, logicalIdToOpenClawSlug, OPENCLAW_LOGICAL_ID_BY_SLUG, OPENCLAW_ROUTER_SLUG, OPENCLAW_SLUG_BY_LOGICAL_ID, OPENCLAW_SLUG_MAX_LEN, OPENCLAW_SLUG_PATTERN, type OpenClawSlugEntry, openClawSlugToLogicalId, } from "./openclaw-slugs.js";
+export { getProductCommand, listProductCommands, logicalIdToFilename, logicalIdToFilenameStem, PRODUCT_COMMAND_COUNT, PRODUCT_COMMANDS, type ProductCommand, type SlashDispatchKind, } from "./product-set.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/slash/index.js

@@ -0,0 +1,16 @@
+/**
+ * Slash-command generator + per-host emitters (#3052 / #3053 / epic #55)
+ * + OpenClaw L2 product-command adapter (#3064).
+ *
+ * Product command table + thin-wrapper IR/templates + host path layouts.
+ * Disk deposit for file hosts: init-deposit `writeSlashCommandDeposit` (#3054).
+ * OpenClaw skills deposit: `depositOpenClawL2ProductCommands` (#3064) — not a
+ * fake `.openclaw/commands/` file emitter.
+ */
+export { assertThinHostEmission, emitAllHostCommandFiles, emitHostCommandFiles, getHostCommandLayout, HOST_COMMAND_LAYOUTS, hostRelativePath, isSlashEmitterHostId, listSlashEmitterHosts, renderHostFileContents, SLASH_EMITTER_HOSTS, } from "./emitters.js";
+export { BYTES_PER_TOKEN_ESTIMATE, estimateTokens, generateThinWrapper, generateThinWrappers, isThinWrapperMarkdown, MAX_CATALOG_TOKENS, MAX_DESCRIPTION_TOKENS, MAX_WRAPPER_BODY_TOKENS, measureTokenBudget, renderThinWrapperBody, renderThinWrapperFile, } from "./generator.js";
+export { assertThinOpenClawArtifacts, generateOpenClawSkillArtifacts, isManagedOpenClawL2Skill, isManagedOpenClawRouterSkill, isThinOpenClawSkillMarkdown, listOpenClawManagedSkillSlugs, listOpenClawProductSkillSlugs, OPENCLAW_L2_MANAGED_MARKER, OPENCLAW_L2_ROUTER_MARKER, renderOpenClawProductSkillMarkdown, renderOpenClawRouterSkillMarkdown, } from "./openclaw-adapter.js";
+export { DEFAULT_OPENCLAW_PRODUCT_COMMANDS, depositOpenClawL2ProductCommands, FIELD_OPENCLAW_PRODUCT_COMMANDS, FIELD_OPENCLAW_PRODUCT_COMMANDS_CLI_ALIAS, inspectOpenClawProductCommands, loadOpenClawProductCommandsPolicyFromProject, resolveOpenClawProductCommandsPolicy, validateOpenClawProductCommands, } from "./openclaw-deposit.js";
+export { assertOpenClawSlugMapIntegrity, isValidOpenClawSlug, listOpenClawSlugEntries, logicalIdToOpenClawSlug, OPENCLAW_LOGICAL_ID_BY_SLUG, OPENCLAW_ROUTER_SLUG, OPENCLAW_SLUG_BY_LOGICAL_ID, OPENCLAW_SLUG_MAX_LEN, OPENCLAW_SLUG_PATTERN, openClawSlugToLogicalId, } from "./openclaw-slugs.js";
+export { getProductCommand, listProductCommands, logicalIdToFilename, logicalIdToFilenameStem, PRODUCT_COMMAND_COUNT, PRODUCT_COMMANDS, } from "./product-set.js";
+//# sourceMappingURL=index.js.map

package/dist/slash/openclaw-adapter.d.ts

@@ -0,0 +1,64 @@
+/**
+ * OpenClaw-native L2 product-command adapter (#3064 D1–D3).
+ *
+ * Hybrid skills-first MVP:
+ * - One thin **router** user-invocable skill (`deft`) for native menus
+ * - 13 thin user-invocable skills mapped from the L2 product set
+ *
+ * Reuses {@link generateThinWrappers} / {@link listProductCommands} — no second
+ * name table. Bodies stay thin (L5). Not a fake `.openclaw/commands/` file emitter.
+ */
+import { type ThinWrapperIR } from "./generator.js";
+/** Ownership marker in managed OpenClaw L2 skill bodies (idempotent rewrite). */
+export declare const OPENCLAW_L2_MANAGED_MARKER = "<!-- deft-managed: openclaw-l2-product-command -->";
+/** Router role marker (distinct from the 13 product skills). */
+export declare const OPENCLAW_L2_ROUTER_MARKER = "<!-- deft-openclaw-role: router -->";
+/** One OpenClaw skill directory artifact ready for deposit (D4). */
+export interface OpenClawSkillArtifact {
+    /** Directory name under workspace skills root (= OpenClaw slug). */
+    readonly slug: string;
+    /** Canonical product slash id, or null for the router. */
+    readonly logicalId: string | null;
+    readonly description: string;
+    /** Full SKILL.md contents. */
+    readonly skillMarkdown: string;
+    /** Content-relative dispatch path (null for router). */
+    readonly dispatchPath: string | null;
+    readonly role: "router" | "product";
+    readonly estimatedBodyTokens: number;
+}
+/**
+ * Render thin product skill body from shared IR (L5).
+ * OpenClaw frontmatter: name + description + user-invocable.
+ */
+export declare function renderOpenClawProductSkillMarkdown(wrapper: ThinWrapperIR): string;
+/**
+ * Router skill: one native-menu-facing entry that lists L2 slug dispatch (D1/D3).
+ * Keeps body thin — no inlined strategy/skill content.
+ */
+export declare function renderOpenClawRouterSkillMarkdown(wrappers?: readonly ThinWrapperIR[]): string;
+/** True when on-disk skill looks like a Directive-managed OpenClaw L2 artifact. */
+export declare function isManagedOpenClawL2Skill(skillMarkdown: string): boolean;
+/** True when content is the managed router skill. */
+export declare function isManagedOpenClawRouterSkill(skillMarkdown: string): boolean;
+/**
+ * Build router + 13 product skill artifacts from shared thin-wrapper IR.
+ *
+ * Count of product skills === {@link PRODUCT_COMMAND_COUNT}; plus one router.
+ */
+export declare function generateOpenClawSkillArtifacts(wrappers?: readonly ThinWrapperIR[]): readonly OpenClawSkillArtifact[];
+/** Product skill slugs only (no router), stable order. */
+export declare function listOpenClawProductSkillSlugs(): readonly string[];
+/** All managed skill directory names (router + 13). */
+export declare function listOpenClawManagedSkillSlugs(): readonly string[];
+/**
+ * Thinness guard for OpenClaw skills: managed marker + dispatch path present
+ * (product) or router marker; body token budget.
+ */
+export declare function isThinOpenClawSkillMarkdown(skillMarkdown: string, options: {
+    dispatchPath?: string | null;
+    role: "router" | "product";
+}): boolean;
+/** Assert generated artifacts stay thin and cover the full L2 set. */
+export declare function assertThinOpenClawArtifacts(artifacts?: readonly OpenClawSkillArtifact[]): void;
+//# sourceMappingURL=openclaw-adapter.d.ts.map

package/dist/slash/openclaw-adapter.js

@@ -0,0 +1,198 @@
+/**
+ * OpenClaw-native L2 product-command adapter (#3064 D1–D3).
+ *
+ * Hybrid skills-first MVP:
+ * - One thin **router** user-invocable skill (`deft`) for native menus
+ * - 13 thin user-invocable skills mapped from the L2 product set
+ *
+ * Reuses {@link generateThinWrappers} / {@link listProductCommands} — no second
+ * name table. Bodies stay thin (L5). Not a fake `.openclaw/commands/` file emitter.
+ */
+import { estimateTokens, generateThinWrappers, MAX_WRAPPER_BODY_TOKENS, } from "./generator.js";
+import { assertOpenClawSlugMapIntegrity, listOpenClawSlugEntries, logicalIdToOpenClawSlug, OPENCLAW_ROUTER_SLUG, openClawSlugToLogicalId, } from "./openclaw-slugs.js";
+import { listProductCommands, PRODUCT_COMMAND_COUNT } from "./product-set.js";
+/** Ownership marker in managed OpenClaw L2 skill bodies (idempotent rewrite). */
+export const OPENCLAW_L2_MANAGED_MARKER = "<!-- deft-managed: openclaw-l2-product-command -->";
+/** Router role marker (distinct from the 13 product skills). */
+export const OPENCLAW_L2_ROUTER_MARKER = "<!-- deft-openclaw-role: router -->";
+function yamlSingleLine(value) {
+    if (/[:#{}[\],&*!|>'"%@`]|^\s|\s$/.test(value) || value === "") {
+        return JSON.stringify(value);
+    }
+    return value;
+}
+/**
+ * Render thin product skill body from shared IR (L5).
+ * OpenClaw frontmatter: name + description + user-invocable.
+ */
+export function renderOpenClawProductSkillMarkdown(wrapper) {
+    const slug = logicalIdToOpenClawSlug(wrapper.logicalId);
+    const frontmatter = [
+        `name: ${slug}`,
+        `description: ${yamlSingleLine(wrapper.description)}`,
+        "user-invocable: true",
+    ];
+    if (wrapper.argumentHint !== undefined) {
+        frontmatter.push(`argument-hint: ${yamlSingleLine(wrapper.argumentHint)}`);
+    }
+    const body = [
+        OPENCLAW_L2_MANAGED_MARKER,
+        "",
+        `# ${slug}`,
+        "",
+        `Canonical slash: \`${wrapper.logicalId}\``,
+        "",
+        wrapper.bodyMarkdown.trimEnd(),
+        "",
+    ].join("\n");
+    return `---\n${frontmatter.join("\n")}\n---\n\n${body}`;
+}
+/**
+ * Router skill: one native-menu-facing entry that lists L2 slug dispatch (D1/D3).
+ * Keeps body thin — no inlined strategy/skill content.
+ */
+export function renderOpenClawRouterSkillMarkdown(wrappers = generateThinWrappers()) {
+    const slugLines = wrappers
+        .map((w) => {
+        const slug = logicalIdToOpenClawSlug(w.logicalId);
+        return `- \`${slug}\` → \`${w.logicalId}\` (${w.dispatchPath})`;
+    })
+        .join("\n");
+    const description = "Directive L2 product-command router (prefer for native menus; Telegram budget)";
+    const frontmatter = [
+        `name: ${OPENCLAW_ROUTER_SLUG}`,
+        `description: ${yamlSingleLine(description)}`,
+        "user-invocable: true",
+        'argument-hint: "<slug-or-logical-id>"',
+    ];
+    const body = [
+        OPENCLAW_L2_MANAGED_MARKER,
+        OPENCLAW_L2_ROUTER_MARKER,
+        "",
+        `# ${OPENCLAW_ROUTER_SLUG} (router)`,
+        "",
+        "Prefer this skill for native/Telegram menus (one slot). All 13 L2 commands remain invocable as `/<slug>` text skills when deposited.",
+        "",
+        "On invoke: match `$ARGUMENTS` to an OpenClaw slug or canonical `/deft…` id, then read and follow that command's content-relative dispatch path under `.deft/core/` when installed.",
+        "Do not inline strategy, skill, or commands.md bodies.",
+        "",
+        "L2 slug map:",
+        slugLines,
+        "",
+    ].join("\n");
+    return `---\n${frontmatter.join("\n")}\n---\n\n${body}`;
+}
+/** True when on-disk skill looks like a Directive-managed OpenClaw L2 artifact. */
+export function isManagedOpenClawL2Skill(skillMarkdown) {
+    return skillMarkdown.includes(OPENCLAW_L2_MANAGED_MARKER);
+}
+/** True when content is the managed router skill. */
+export function isManagedOpenClawRouterSkill(skillMarkdown) {
+    return (isManagedOpenClawL2Skill(skillMarkdown) && skillMarkdown.includes(OPENCLAW_L2_ROUTER_MARKER));
+}
+/**
+ * Build router + 13 product skill artifacts from shared thin-wrapper IR.
+ *
+ * Count of product skills === {@link PRODUCT_COMMAND_COUNT}; plus one router.
+ */
+export function generateOpenClawSkillArtifacts(wrappers = generateThinWrappers()) {
+    assertOpenClawSlugMapIntegrity(listProductCommands());
+    if (wrappers.length !== PRODUCT_COMMAND_COUNT) {
+        throw new Error(`Expected ${PRODUCT_COMMAND_COUNT} thin wrappers for OpenClaw adapter, got ${wrappers.length}`);
+    }
+    const routerMd = renderOpenClawRouterSkillMarkdown(wrappers);
+    const routerBodyStart = routerMd.indexOf("\n---\n", 4);
+    const routerBody = routerBodyStart >= 0 ? routerMd.slice(routerBodyStart + 5) : routerMd;
+    const artifacts = [
+        {
+            slug: OPENCLAW_ROUTER_SLUG,
+            logicalId: null,
+            description: "Directive L2 product-command router (prefer for native menus; Telegram budget)",
+            skillMarkdown: routerMd,
+            dispatchPath: null,
+            role: "router",
+            estimatedBodyTokens: estimateTokens(routerBody),
+        },
+    ];
+    for (const w of wrappers) {
+        const skillMarkdown = renderOpenClawProductSkillMarkdown(w);
+        const bodyStart = skillMarkdown.indexOf("\n---\n", 4);
+        const body = bodyStart >= 0 ? skillMarkdown.slice(bodyStart + 5) : skillMarkdown;
+        artifacts.push({
+            slug: logicalIdToOpenClawSlug(w.logicalId),
+            logicalId: w.logicalId,
+            description: w.description,
+            skillMarkdown,
+            dispatchPath: w.dispatchPath,
+            role: "product",
+            estimatedBodyTokens: estimateTokens(body),
+        });
+    }
+    return artifacts;
+}
+/** Product skill slugs only (no router), stable order. */
+export function listOpenClawProductSkillSlugs() {
+    return listOpenClawSlugEntries().map((e) => e.openClawSlug);
+}
+/** All managed skill directory names (router + 13). */
+export function listOpenClawManagedSkillSlugs() {
+    return [OPENCLAW_ROUTER_SLUG, ...listOpenClawProductSkillSlugs()];
+}
+/**
+ * Thinness guard for OpenClaw skills: managed marker + dispatch path present
+ * (product) or router marker; body token budget.
+ */
+export function isThinOpenClawSkillMarkdown(skillMarkdown, options) {
+    if (!isManagedOpenClawL2Skill(skillMarkdown))
+        return false;
+    if (!skillMarkdown.startsWith("---\n"))
+        return false;
+    if (!/^user-invocable:\s*true\s*$/m.test(skillMarkdown))
+        return false;
+    if (/^##\s+(Phase|Workflow|Steps|Acceptance)\b/m.test(skillMarkdown))
+        return false;
+    const close = skillMarkdown.indexOf("\n---\n", 4);
+    const body = close >= 0 ? skillMarkdown.slice(close + 5) : skillMarkdown;
+    // Router lists the full slug map; allow a slightly larger budget than file hosts.
+    const maxBody = options.role === "router" ? MAX_WRAPPER_BODY_TOKENS * 4 : MAX_WRAPPER_BODY_TOKENS + 40;
+    if (estimateTokens(body) > maxBody)
+        return false;
+    if (options.role === "router") {
+        return isManagedOpenClawRouterSkill(skillMarkdown);
+    }
+    if (!options.dispatchPath)
+        return false;
+    if (!body.includes(options.dispatchPath))
+        return false;
+    if (!body.includes("Read and follow"))
+        return false;
+    if (!body.includes("Do not inline"))
+        return false;
+    return true;
+}
+/** Assert generated artifacts stay thin and cover the full L2 set. */
+export function assertThinOpenClawArtifacts(artifacts = generateOpenClawSkillArtifacts()) {
+    const products = artifacts.filter((a) => a.role === "product");
+    const routers = artifacts.filter((a) => a.role === "router");
+    if (routers.length !== 1) {
+        throw new Error(`Expected exactly 1 OpenClaw router skill, got ${routers.length}`);
+    }
+    if (products.length !== PRODUCT_COMMAND_COUNT) {
+        throw new Error(`Expected ${PRODUCT_COMMAND_COUNT} OpenClaw product skills, got ${products.length}`);
+    }
+    for (const a of artifacts) {
+        if (!isThinOpenClawSkillMarkdown(a.skillMarkdown, {
+            dispatchPath: a.dispatchPath,
+            role: a.role,
+        })) {
+            throw new Error(`Non-thin OpenClaw skill artifact: ${a.slug}`);
+        }
+        if (a.role === "product" && a.logicalId) {
+            const reverse = openClawSlugToLogicalId(a.slug);
+            if (reverse !== a.logicalId) {
+                throw new Error(`Slug/logicalId mismatch for ${a.slug}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=openclaw-adapter.js.map

package/dist/slash/openclaw-deposit.d.ts

@@ -0,0 +1,73 @@
+/**
+ * OpenClaw L2 product-command skill deposit (#3064 D4–D5).
+ *
+ * Writes thin user-invocable skills into the OpenClaw **main workspace skills**
+ * root (copy/stage — not symlink-escape into npm). Idempotent managed rewrite;
+ * preserves consumer custom skills at the same slug.
+ *
+ * Primary operator path: `deft doctor --fix` when OpenClaw is detected.
+ * init/update also deposits when OC signals are present and policy is on.
+ *
+ * ⊗ Fake project `.openclaw/commands/` file emitter.
+ */
+import { type OpenClawDetectResult } from "../doctor/openclaw-skills.js";
+/** Typed policy key: opt-out of OpenClaw L2 product-command adapter deposit. */
+export declare const FIELD_OPENCLAW_PRODUCT_COMMANDS = "plan.policy.openClawProductCommands";
+export declare const FIELD_OPENCLAW_PRODUCT_COMMANDS_CLI_ALIAS = "openClawProductCommands";
+/** Default: adapter on when OpenClaw is detected (real adapter — D5). */
+export declare const DEFAULT_OPENCLAW_PRODUCT_COMMANDS = true;
+export type OpenClawProductCommandsPolicy = boolean;
+export interface OpenClawProductCommandsPolicyField {
+    readonly name: string;
+    readonly current: OpenClawProductCommandsPolicy;
+    readonly default: OpenClawProductCommandsPolicy;
+    readonly source: string;
+}
+export interface OpenClawL2DepositResult {
+    readonly changed: boolean;
+    /** Absolute skill directory paths written/updated. */
+    readonly writtenPaths: string[];
+    /** Absolute paths removed on opt-out (managed only). */
+    readonly removedPaths: string[];
+    /** Absolute paths skipped (consumer custom content). */
+    readonly preservedCustomPaths: string[];
+    readonly skillsDirs: string[];
+    readonly skipped: boolean;
+    readonly skipReason?: string;
+    readonly detect: OpenClawDetectResult | null;
+}
+export interface OpenClawL2DepositOptions {
+    /** Project root for policy load (optional; defaults enabled when absent). */
+    readonly projectRoot?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly homeDir?: string;
+    /** Multi-seat parity with doctor --openclaw-all-agents. */
+    readonly allAgents?: boolean;
+    /** Explicit policy override (tests). */
+    readonly policy?: OpenClawProductCommandsPolicy;
+    readonly printf?: (text: string) => void;
+    readonly isDir?: (path: string) => boolean;
+    readonly readDir?: (path: string) => string[];
+    /**
+     * When true, deposit even if OpenClaw is not detected (tests only).
+     * Production paths stay fail-closed when OC signals are absent (D5).
+     */
+    readonly forceDeposit?: boolean;
+    /** Override skills roots (tests). */
+    readonly skillsDirs?: readonly string[];
+}
+/** Resolve openClawProductCommands from raw policy value. */
+export declare function resolveOpenClawProductCommandsPolicy(raw: unknown): OpenClawProductCommandsPolicy;
+export declare function validateOpenClawProductCommands(value: unknown): string[];
+export declare function inspectOpenClawProductCommands(data: Record<string, unknown> | null): OpenClawProductCommandsPolicyField;
+export declare function loadOpenClawProductCommandsPolicyFromProject(projectRoot: string): OpenClawProductCommandsPolicy;
+/**
+ * Deposit OpenClaw L2 product-command skills into workspace skills roots.
+ *
+ * Fail-closed when OpenClaw is not detected (unless forceDeposit for tests).
+ * Policy false → remove managed skills only (opt-out).
+ */
+export declare function depositOpenClawL2ProductCommands(options?: OpenClawL2DepositOptions): OpenClawL2DepositResult;
+/** Resolve absolute main skills dir for a state dir (test helper re-export path). */
+export declare function resolveOpenClawMainSkillsDirForState(stateDir: string): string;
+//# sourceMappingURL=openclaw-deposit.d.ts.map