@deftai/directive-core 0.92.0 → 0.94.0

package/dist/slash/openclaw-deposit.js

@@ -0,0 +1,279 @@
+/**
+ * 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 { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { detectOpenClaw, isEscapingSkillSymlink, listInScopeSkillsDirs, } from "../doctor/openclaw-skills.js";
+import { containedWrite } from "../fs/contained-write.js";
+import { readPlanPolicy } from "../policy/plan-extensions.js";
+import { loadProjectDefinition } from "../policy/resolve.js";
+import { generateOpenClawSkillArtifacts, isManagedOpenClawL2Skill, listOpenClawManagedSkillSlugs, } from "./openclaw-adapter.js";
+/** Typed policy key: opt-out of OpenClaw L2 product-command adapter deposit. */
+export const FIELD_OPENCLAW_PRODUCT_COMMANDS = "plan.policy.openClawProductCommands";
+export const FIELD_OPENCLAW_PRODUCT_COMMANDS_CLI_ALIAS = "openClawProductCommands";
+/** Default: adapter on when OpenClaw is detected (real adapter — D5). */
+export const DEFAULT_OPENCLAW_PRODUCT_COMMANDS = true;
+function defaultIsDir(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Resolve openClawProductCommands from raw policy value. */
+export function resolveOpenClawProductCommandsPolicy(raw) {
+    if (typeof raw === "boolean")
+        return raw;
+    return DEFAULT_OPENCLAW_PRODUCT_COMMANDS;
+}
+export function validateOpenClawProductCommands(value) {
+    if (value === null || value === undefined)
+        return [];
+    if (typeof value !== "boolean") {
+        return [`${FIELD_OPENCLAW_PRODUCT_COMMANDS} must be a boolean; got ${typeof value}`];
+    }
+    return [];
+}
+export function inspectOpenClawProductCommands(data) {
+    if (data === null) {
+        return {
+            name: FIELD_OPENCLAW_PRODUCT_COMMANDS,
+            current: DEFAULT_OPENCLAW_PRODUCT_COMMANDS,
+            default: DEFAULT_OPENCLAW_PRODUCT_COMMANDS,
+            source: "default",
+        };
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("openClawProductCommands" in policyBlock)) {
+        return {
+            name: FIELD_OPENCLAW_PRODUCT_COMMANDS,
+            current: DEFAULT_OPENCLAW_PRODUCT_COMMANDS,
+            default: DEFAULT_OPENCLAW_PRODUCT_COMMANDS,
+            source: "default",
+        };
+    }
+    return {
+        name: FIELD_OPENCLAW_PRODUCT_COMMANDS,
+        current: resolveOpenClawProductCommandsPolicy(policyBlock.openClawProductCommands),
+        default: DEFAULT_OPENCLAW_PRODUCT_COMMANDS,
+        source: "typed",
+    };
+}
+export function loadOpenClawProductCommandsPolicyFromProject(projectRoot) {
+    const [data] = loadProjectDefinition(projectRoot);
+    if (data === null)
+        return DEFAULT_OPENCLAW_PRODUCT_COMMANDS;
+    return inspectOpenClawProductCommands(data).current;
+}
+function skillDirLstatKind(path) {
+    try {
+        const st = lstatSync(path);
+        if (st.isSymbolicLink())
+            return "symlink";
+        if (st.isDirectory())
+            return "dir";
+        if (st.isFile())
+            return "file";
+        return "other";
+    }
+    catch {
+        return "missing";
+    }
+}
+function writeSkillArtifact(skillsDir, artifact) {
+    const skillDir = join(skillsDir, artifact.slug);
+    const skillFile = join(skillDir, "SKILL.md");
+    // #3064 Greptile P1 / #3008 spirit: never write through an escaping skill-dir symlink.
+    const dirKind = skillDirLstatKind(skillDir);
+    if (dirKind === "symlink" && isEscapingSkillSymlink(skillsDir, skillDir)) {
+        return "preserved";
+    }
+    if (existsSync(skillFile)) {
+        // Leaf symlink on SKILL.md that escapes skills root — refuse (containedWrite also fails closed).
+        if (skillDirLstatKind(skillFile) === "symlink" &&
+            isEscapingSkillSymlink(skillsDir, skillFile)) {
+            return "preserved";
+        }
+        let raw;
+        try {
+            raw = readFileSync(skillFile, "utf8");
+        }
+        catch {
+            return "preserved";
+        }
+        if (raw === artifact.skillMarkdown)
+            return "unchanged";
+        // Ownership: only rewrite managed thin L2 skills.
+        if (!isManagedOpenClawL2Skill(raw)) {
+            return "preserved";
+        }
+    }
+    mkdirSync(skillDir, { recursive: true });
+    // Re-check after mkdir: concurrent symlink plant is fail-closed.
+    if (skillDirLstatKind(skillDir) === "symlink" && isEscapingSkillSymlink(skillsDir, skillDir)) {
+        return "preserved";
+    }
+    const tmpName = `SKILL.md.deft-${process.pid}-${Date.now().toString(36)}.tmp`;
+    const tmp = join(skillDir, tmpName);
+    try {
+        // Contained write under skills root (#2951) — refuses symlink escape on the write path.
+        containedWrite({
+            root: skillsDir,
+            target: tmp,
+            data: artifact.skillMarkdown,
+            mode: "replace",
+        });
+        renameSync(tmp, skillFile);
+    }
+    catch (err) {
+        try {
+            rmSync(tmp, { force: true });
+        }
+        catch {
+            /* best-effort */
+        }
+        // Containment / symlink refusals: treat as preserved (do not clobber outside root).
+        const msg = err instanceof Error ? err.message : String(err);
+        if (/contained write refused|symlink|escape/i.test(msg)) {
+            return "preserved";
+        }
+        throw err;
+    }
+    return "written";
+}
+function stripManagedSkills(skillsDir) {
+    const removed = [];
+    for (const slug of listOpenClawManagedSkillSlugs()) {
+        const skillDir = join(skillsDir, slug);
+        const skillFile = join(skillDir, "SKILL.md");
+        if (!existsSync(skillFile))
+            continue;
+        let raw;
+        try {
+            raw = readFileSync(skillFile, "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (!isManagedOpenClawL2Skill(raw))
+            continue;
+        try {
+            rmSync(skillDir, { recursive: true, force: true });
+            removed.push(skillDir);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    return removed;
+}
+/**
+ * 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 function depositOpenClawL2ProductCommands(options = {}) {
+    const printf = options.printf ?? (() => undefined);
+    const env = options.env ?? process.env;
+    const home = options.homeDir ?? homedir();
+    const isDir = options.isDir ?? defaultIsDir;
+    const policy = options.policy ??
+        (options.projectRoot
+            ? loadOpenClawProductCommandsPolicyFromProject(options.projectRoot)
+            : DEFAULT_OPENCLAW_PRODUCT_COMMANDS);
+    const detect = detectOpenClaw(env, { homeDir: home, isDir });
+    if (!detect.detected && !options.forceDeposit) {
+        printf("OpenClaw L2 product commands: skip -- OpenClaw not detected\n");
+        return {
+            changed: false,
+            writtenPaths: [],
+            removedPaths: [],
+            preservedCustomPaths: [],
+            skillsDirs: [],
+            skipped: true,
+            skipReason: "openclaw-not-detected",
+            detect,
+        };
+    }
+    const skillsDirs = options.skillsDirs !== undefined
+        ? [...options.skillsDirs]
+        : listInScopeSkillsDirs(detect.stateDir, options.allAgents === true, {
+            isDir,
+            readDir: options.readDir,
+        });
+    const writtenPaths = [];
+    const removedPaths = [];
+    const preservedCustomPaths = [];
+    if (!policy) {
+        for (const skillsDir of skillsDirs) {
+            mkdirSync(skillsDir, { recursive: true });
+            removedPaths.push(...stripManagedSkills(skillsDir));
+        }
+        if (removedPaths.length > 0) {
+            printf(`Removed Directive-managed OpenClaw L2 product skills (plan.policy.openClawProductCommands opt-out): ${removedPaths.length}\n`);
+        }
+        else {
+            printf("OpenClaw L2 product commands: opted out (policy false); nothing to remove\n");
+        }
+        return {
+            changed: removedPaths.length > 0,
+            writtenPaths,
+            removedPaths,
+            preservedCustomPaths,
+            skillsDirs,
+            skipped: false,
+            detect,
+        };
+    }
+    const artifacts = generateOpenClawSkillArtifacts();
+    for (const skillsDir of skillsDirs) {
+        mkdirSync(skillsDir, { recursive: true });
+        for (const artifact of artifacts) {
+            const outcome = writeSkillArtifact(skillsDir, artifact);
+            const abs = join(skillsDir, artifact.slug);
+            if (outcome === "written")
+                writtenPaths.push(abs);
+            if (outcome === "preserved")
+                preservedCustomPaths.push(abs);
+        }
+    }
+    if (writtenPaths.length > 0) {
+        printf(`Installed OpenClaw L2 product-command skills (${artifacts.length} per skills root; router + ${PRODUCT_COUNT_LABEL}): ${writtenPaths.length} path(s)\n`);
+    }
+    else if (preservedCustomPaths.length === 0) {
+        printf("OpenClaw L2 product-command skills already current.\n");
+    }
+    if (preservedCustomPaths.length > 0) {
+        printf(`Preserved non-managed OpenClaw skills at product slugs: ${preservedCustomPaths.join(", ")}\n`);
+    }
+    return {
+        changed: writtenPaths.length + removedPaths.length > 0,
+        writtenPaths,
+        removedPaths,
+        preservedCustomPaths,
+        skillsDirs,
+        skipped: false,
+        detect,
+    };
+}
+const PRODUCT_COUNT_LABEL = "13 product";
+/** Resolve absolute main skills dir for a state dir (test helper re-export path). */
+export function resolveOpenClawMainSkillsDirForState(stateDir) {
+    return join(resolve(stateDir), "workspace", "skills");
+}
+//# sourceMappingURL=openclaw-deposit.js.map

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

@@ -0,0 +1,52 @@
+/**
+ * Stable logicalId → OpenClaw slug map for L2 product commands (#3064 D2).
+ *
+ * OpenClaw sanitizes skill/command names to `a-z0-9_` (max 32). Colons in
+ * `/deft:directive:run:interview` cannot survive raw. This table is the single
+ * bijective map for the L2 set of 13 — do not invent ad-hoc sanitize at emit time.
+ *
+ * Example: `/deft:directive:run:interview` → `deft_run_interview`
+ *
+ * ⊗ Add `openclaw` to HOST_COMMAND_LAYOUTS / SLASH_EMITTER_HOSTS as a fake
+ *   project file emitter (L6 / #3064 non-goal).
+ */
+import { type ProductCommand } from "./product-set.js";
+/** OpenClaw skill/command name max length (host sanitize). */
+export declare const OPENCLAW_SLUG_MAX_LEN: 32;
+/** Regex for a valid OpenClaw skill slug. */
+export declare const OPENCLAW_SLUG_PATTERN: RegExp;
+/**
+ * Router skill slug — preferred native-menu entry (D3).
+ * Keep short for Telegram BOT_COMMANDS budget.
+ */
+export declare const OPENCLAW_ROUTER_SLUG: "deft";
+/** Public frozen map (logicalId → openClawSlug). */
+export declare const OPENCLAW_SLUG_BY_LOGICAL_ID: Readonly<Record<string, string>>;
+/** Reverse map for dispatch / router lookup. */
+export declare const OPENCLAW_LOGICAL_ID_BY_SLUG: Readonly<Record<string, string>>;
+export interface OpenClawSlugEntry {
+    readonly logicalId: string;
+    readonly openClawSlug: string;
+    readonly filenameStem: string;
+    readonly description: string;
+}
+/** Assert slug shape: a-z0-9_, length 1..32, no colons. */
+export declare function isValidOpenClawSlug(slug: string): boolean;
+/**
+ * Look up the OpenClaw slug for a product logical id.
+ * Throws when the id is not in the L2 map (no ad-hoc sanitize fallback).
+ */
+export declare function logicalIdToOpenClawSlug(logicalId: string): string;
+/** Reverse lookup slug → logical id, or undefined. */
+export declare function openClawSlugToLogicalId(slug: string): string | undefined;
+/**
+ * Stable ordered list of L2 slug entries (count === PRODUCT_COMMAND_COUNT).
+ * Built from {@link listProductCommands} so the name table is not duplicated.
+ */
+export declare function listOpenClawSlugEntries(commands?: readonly ProductCommand[]): readonly OpenClawSlugEntry[];
+/**
+ * Validate the L2 map: cardinality, bijectivity, slug shape, product-set coverage.
+ * Throws on any violation (used by unit tests and deposit preflight).
+ */
+export declare function assertOpenClawSlugMapIntegrity(commands?: readonly ProductCommand[]): void;
+//# sourceMappingURL=openclaw-slugs.d.ts.map

package/dist/slash/openclaw-slugs.js

@@ -0,0 +1,126 @@
+/**
+ * Stable logicalId → OpenClaw slug map for L2 product commands (#3064 D2).
+ *
+ * OpenClaw sanitizes skill/command names to `a-z0-9_` (max 32). Colons in
+ * `/deft:directive:run:interview` cannot survive raw. This table is the single
+ * bijective map for the L2 set of 13 — do not invent ad-hoc sanitize at emit time.
+ *
+ * Example: `/deft:directive:run:interview` → `deft_run_interview`
+ *
+ * ⊗ Add `openclaw` to HOST_COMMAND_LAYOUTS / SLASH_EMITTER_HOSTS as a fake
+ *   project file emitter (L6 / #3064 non-goal).
+ */
+import { listProductCommands, PRODUCT_COMMAND_COUNT } from "./product-set.js";
+/** OpenClaw skill/command name max length (host sanitize). */
+export const OPENCLAW_SLUG_MAX_LEN = 32;
+/** Regex for a valid OpenClaw skill slug. */
+export const OPENCLAW_SLUG_PATTERN = /^[a-z0-9_]+$/;
+/**
+ * Router skill slug — preferred native-menu entry (D3).
+ * Keep short for Telegram BOT_COMMANDS budget.
+ */
+export const OPENCLAW_ROUTER_SLUG = "deft";
+/**
+ * Stable logical slash id → OpenClaw slug for the L2 product set.
+ *
+ * Derived from product-set order; shorter than hyphen-stem → underscore so
+ * every entry stays well under 32 chars (D2 example pattern).
+ */
+const OPENCLAW_SLUG_BY_LOGICAL_ID_INNER = Object.freeze({
+    "/deft:directive:change": "deft_change",
+    "/deft:directive:change:apply": "deft_change_apply",
+    "/deft:directive:change:verify": "deft_change_verify",
+    "/deft:directive:change:archive": "deft_change_archive",
+    "/deft:directive:run:interview": "deft_run_interview",
+    "/deft:directive:run:yolo": "deft_run_yolo",
+    "/deft:directive:run:map": "deft_run_map",
+    "/deft:directive:run:discuss": "deft_run_discuss",
+    "/deft:directive:run:research": "deft_run_research",
+    "/deft:directive:run:speckit": "deft_run_speckit",
+    "/deft:directive:run:probe": "deft_run_probe",
+    "/deft:continue": "deft_continue",
+    "/deft:checkpoint": "deft_checkpoint",
+});
+/** Public frozen map (logicalId → openClawSlug). */
+export const OPENCLAW_SLUG_BY_LOGICAL_ID = OPENCLAW_SLUG_BY_LOGICAL_ID_INNER;
+/** Reverse map for dispatch / router lookup. */
+export const OPENCLAW_LOGICAL_ID_BY_SLUG = Object.freeze(Object.fromEntries(Object.entries(OPENCLAW_SLUG_BY_LOGICAL_ID_INNER).map(([logicalId, slug]) => [slug, logicalId])));
+/** Assert slug shape: a-z0-9_, length 1..32, no colons. */
+export function isValidOpenClawSlug(slug) {
+    if (slug.length === 0 || slug.length > OPENCLAW_SLUG_MAX_LEN)
+        return false;
+    if (slug.includes(":"))
+        return false;
+    return OPENCLAW_SLUG_PATTERN.test(slug);
+}
+/**
+ * Look up the OpenClaw slug for a product logical id.
+ * Throws when the id is not in the L2 map (no ad-hoc sanitize fallback).
+ */
+export function logicalIdToOpenClawSlug(logicalId) {
+    const slug = OPENCLAW_SLUG_BY_LOGICAL_ID_INNER[logicalId];
+    if (slug === undefined) {
+        throw new Error(`No OpenClaw slug mapping for logicalId: ${logicalId}`);
+    }
+    return slug;
+}
+/** Reverse lookup slug → logical id, or undefined. */
+export function openClawSlugToLogicalId(slug) {
+    return OPENCLAW_LOGICAL_ID_BY_SLUG[slug];
+}
+/**
+ * Stable ordered list of L2 slug entries (count === PRODUCT_COMMAND_COUNT).
+ * Built from {@link listProductCommands} so the name table is not duplicated.
+ */
+export function listOpenClawSlugEntries(commands = listProductCommands()) {
+    return commands.map((c) => ({
+        logicalId: c.logicalId,
+        openClawSlug: logicalIdToOpenClawSlug(c.logicalId),
+        filenameStem: c.filenameStem,
+        description: c.description,
+    }));
+}
+/**
+ * Validate the L2 map: cardinality, bijectivity, slug shape, product-set coverage.
+ * Throws on any violation (used by unit tests and deposit preflight).
+ */
+export function assertOpenClawSlugMapIntegrity(commands = listProductCommands()) {
+    if (commands.length !== PRODUCT_COMMAND_COUNT) {
+        throw new Error(`OpenClaw slug map expects ${PRODUCT_COMMAND_COUNT} product commands, got ${commands.length}`);
+    }
+    const entries = listOpenClawSlugEntries(commands);
+    if (entries.length !== PRODUCT_COMMAND_COUNT) {
+        throw new Error(`OpenClaw slug map size ${entries.length} !== ${PRODUCT_COMMAND_COUNT}`);
+    }
+    const slugs = new Set();
+    for (const e of entries) {
+        if (!isValidOpenClawSlug(e.openClawSlug)) {
+            throw new Error(`Invalid OpenClaw slug for ${e.logicalId}: ${e.openClawSlug}`);
+        }
+        if (slugs.has(e.openClawSlug)) {
+            throw new Error(`Duplicate OpenClaw slug: ${e.openClawSlug}`);
+        }
+        slugs.add(e.openClawSlug);
+        if (OPENCLAW_LOGICAL_ID_BY_SLUG[e.openClawSlug] !== e.logicalId) {
+            throw new Error(`Reverse map mismatch for slug ${e.openClawSlug}`);
+        }
+    }
+    if (slugs.has(OPENCLAW_ROUTER_SLUG)) {
+        throw new Error(`Router slug "${OPENCLAW_ROUTER_SLUG}" collides with an L2 product slug (reserve for router)`);
+    }
+    if (!isValidOpenClawSlug(OPENCLAW_ROUTER_SLUG)) {
+        throw new Error(`Invalid router slug: ${OPENCLAW_ROUTER_SLUG}`);
+    }
+    // Map keys must cover exactly the product set (no orphans, no missing).
+    const mapKeys = new Set(Object.keys(OPENCLAW_SLUG_BY_LOGICAL_ID_INNER));
+    for (const c of commands) {
+        if (!mapKeys.has(c.logicalId)) {
+            throw new Error(`Product command missing OpenClaw slug map entry: ${c.logicalId}`);
+        }
+        mapKeys.delete(c.logicalId);
+    }
+    if (mapKeys.size > 0) {
+        throw new Error(`OpenClaw slug map has orphan keys: ${[...mapKeys].join(", ")}`);
+    }
+}
+//# sourceMappingURL=openclaw-slugs.js.map

package/dist/slash/product-set.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Locked product slash-command table for native multi-host registration (#3052 / epic #55).
+ *
+ * Authoritative locks: LockedDecisions L1–L10 on #55 (especially L1 names, L2 set of 13,
+ * L3 no native aliases, L4 logical-id ↔ hyphen filename map).
+ *
+ * Emitters (#3053) and deposit (#3054) MUST consume this table (or the generator IR built
+ * from it) — do not maintain a second product name list.
+ */
+/** Primary load path on slash invoke (L5: one clear artifact). */
+export type SlashDispatchKind = "strategy" | "skill" | "commands" | "resilience" | "session";
+/**
+ * One canonical product slash command (L2).
+ *
+ * `logicalId` is the external slash form (host display / autocomplete).
+ * `filenameStem` is the portable on-disk name without extension (L4).
+ * `dispatchPath` is content-root-relative; emitters may prefix deposit roots
+ * (e.g. `.deft/core/`) without changing this table.
+ */
+export interface ProductCommand {
+    readonly logicalId: string;
+    readonly filenameStem: string;
+    readonly description: string;
+    readonly dispatchKind: SlashDispatchKind;
+    readonly dispatchPath: string;
+    readonly argumentHint?: string;
+}
+/** Locked product-set cardinality (L2). */
+export declare const PRODUCT_COMMAND_COUNT: 13;
+/**
+ * Canonical L2 product command set — exactly 13 entries, stable order.
+ *
+ * ⊗ Expand without a product decision that amends L2 on #55.
+ * ⊗ Emit native alias files for legacy `/deft:change` forms (L3).
+ */
+export declare const PRODUCT_COMMANDS: readonly ProductCommand[];
+/**
+ * Map a canonical logical slash id to the portable hyphen filename stem (L4).
+ *
+ * `/deft:directive:run:interview` → `deft-directive-run-interview`
+ * `/deft:continue` → `deft-continue`
+ */
+export declare function logicalIdToFilenameStem(logicalId: string): string;
+/** Filename with `.md` extension for host command deposit (L4). */
+export declare function logicalIdToFilename(logicalId: string): string;
+/** Frozen product table for emitters (#3053) — single source of truth. */
+export declare function listProductCommands(): readonly ProductCommand[];
+/** Look up one product command by logical id, or undefined. */
+export declare function getProductCommand(logicalId: string): ProductCommand | undefined;
+//# sourceMappingURL=product-set.d.ts.map

package/dist/slash/product-set.js

@@ -0,0 +1,142 @@
+/**
+ * Locked product slash-command table for native multi-host registration (#3052 / epic #55).
+ *
+ * Authoritative locks: LockedDecisions L1–L10 on #55 (especially L1 names, L2 set of 13,
+ * L3 no native aliases, L4 logical-id ↔ hyphen filename map).
+ *
+ * Emitters (#3053) and deposit (#3054) MUST consume this table (or the generator IR built
+ * from it) — do not maintain a second product name list.
+ */
+/** Locked product-set cardinality (L2). */
+export const PRODUCT_COMMAND_COUNT = 13;
+/**
+ * Canonical L2 product command set — exactly 13 entries, stable order.
+ *
+ * ⊗ Expand without a product decision that amends L2 on #55.
+ * ⊗ Emit native alias files for legacy `/deft:change` forms (L3).
+ */
+export const PRODUCT_COMMANDS = Object.freeze([
+    {
+        logicalId: "/deft:directive:change",
+        filenameStem: "deft-directive-change",
+        description: "Create a scoped change proposal under history/changes/",
+        dispatchKind: "commands",
+        dispatchPath: "commands.md",
+        argumentHint: "<name>",
+    },
+    {
+        logicalId: "/deft:directive:change:apply",
+        filenameStem: "deft-directive-change-apply",
+        description: "Implement tasks from the active change proposal",
+        dispatchKind: "commands",
+        dispatchPath: "commands.md",
+    },
+    {
+        logicalId: "/deft:directive:change:verify",
+        filenameStem: "deft-directive-change-verify",
+        description: "Verify the active change against acceptance criteria",
+        dispatchKind: "commands",
+        dispatchPath: "commands.md",
+    },
+    {
+        logicalId: "/deft:directive:change:archive",
+        filenameStem: "deft-directive-change-archive",
+        description: "Archive the completed change under history/archive/",
+        dispatchKind: "commands",
+        dispatchPath: "commands.md",
+    },
+    {
+        logicalId: "/deft:directive:run:interview",
+        filenameStem: "deft-directive-run-interview",
+        description: "Structured interview with Light/Full sizing gate",
+        dispatchKind: "strategy",
+        dispatchPath: "strategies/interview.md",
+        argumentHint: "<name>",
+    },
+    {
+        logicalId: "/deft:directive:run:yolo",
+        filenameStem: "deft-directive-run-yolo",
+        description: "Auto-pilot interview; agent picks options",
+        dispatchKind: "strategy",
+        dispatchPath: "strategies/yolo.md",
+        argumentHint: "<name>",
+    },
+    {
+        logicalId: "/deft:directive:run:map",
+        filenameStem: "deft-directive-run-map",
+        description: "Brownfield codebase mapping strategy",
+        dispatchKind: "strategy",
+        dispatchPath: "strategies/map.md",
+    },
+    {
+        logicalId: "/deft:directive:run:discuss",
+        filenameStem: "deft-directive-run-discuss",
+        description: "Feynman-style alignment and decision locking",
+        dispatchKind: "strategy",
+        dispatchPath: "strategies/discuss.md",
+        argumentHint: "<topic>",
+    },
+    {
+        logicalId: "/deft:directive:run:research",
+        filenameStem: "deft-directive-run-research",
+        description: "Research domain before planning (don't hand-roll)",
+        dispatchKind: "strategy",
+        dispatchPath: "strategies/research.md",
+        argumentHint: "<domain>",
+    },
+    {
+        logicalId: "/deft:directive:run:speckit",
+        filenameStem: "deft-directive-run-speckit",
+        description: "Five-phase large/complex specification workflow",
+        dispatchKind: "strategy",
+        dispatchPath: "strategies/speckit.md",
+        argumentHint: "<name>",
+    },
+    {
+        logicalId: "/deft:directive:run:probe",
+        filenameStem: "deft-directive-run-probe",
+        description: "Adversarial one-question plan stress-testing",
+        dispatchKind: "skill",
+        dispatchPath: "skills/deft-directive-probe/SKILL.md",
+    },
+    {
+        logicalId: "/deft:continue",
+        filenameStem: "deft-continue",
+        description: "Resume from the continue checkpoint",
+        dispatchKind: "resilience",
+        dispatchPath: "resilience/continue-here.md",
+    },
+    {
+        logicalId: "/deft:checkpoint",
+        filenameStem: "deft-checkpoint",
+        description: "Save session state to xbrief/continue.xbrief.json",
+        dispatchKind: "session",
+        dispatchPath: "xbrief/continue.xbrief.json",
+    },
+]);
+/**
+ * Map a canonical logical slash id to the portable hyphen filename stem (L4).
+ *
+ * `/deft:directive:run:interview` → `deft-directive-run-interview`
+ * `/deft:continue` → `deft-continue`
+ */
+export function logicalIdToFilenameStem(logicalId) {
+    const trimmed = logicalId.trim();
+    if (!trimmed.startsWith("/")) {
+        throw new Error(`logicalId must start with '/': ${logicalId}`);
+    }
+    return trimmed.slice(1).replace(/:/g, "-");
+}
+/** Filename with `.md` extension for host command deposit (L4). */
+export function logicalIdToFilename(logicalId) {
+    return `${logicalIdToFilenameStem(logicalId)}.md`;
+}
+/** Frozen product table for emitters (#3053) — single source of truth. */
+export function listProductCommands() {
+    return PRODUCT_COMMANDS;
+}
+/** Look up one product command by logical id, or undefined. */
+export function getProductCommand(logicalId) {
+    return PRODUCT_COMMANDS.find((c) => c.logicalId === logicalId);
+}
+//# sourceMappingURL=product-set.js.map

package/dist/tool-events/classify.js

@@ -212,6 +212,7 @@ const VERIFY_TASK_VERBS = new Set([
     "verify:forward-coverage",
     "verify:story-ready",
     "verify:review-monitor",
+    "verify:l4-owner",
     "pr:watch",
     "pr:merge-ready",
     "coverage:hotspots",