@deftai/directive-core 0.91.0 → 0.93.0

package/dist/user-config/experimental-rules.js

@@ -0,0 +1,162 @@
+/**
+ * Safe USER.md Experimental Rules toggle (#46).
+ *
+ * Pure string helpers that add/remove only the three canonical meta-philosophy
+ * reference lines (SOUL / morals / code-field). Personal and Defaults section
+ * bodies are never rewritten — only the `## Experimental Rules` region changes.
+ *
+ * Detection matches lines under `## Experimental Rules` that contain the deposit
+ * path (`meta/SOUL.md`, …); enable writes the canonical setup-skill bullet.
+ * Custom bullets for other topics in the same section are preserved.
+ */
+/** Canonical Experimental Rules entries (setup Phase 1 steps 5a–5c). */
+export const EXPERIMENTAL_META_ENTRIES = [
+    {
+        id: "soul",
+        path: "meta/SOUL.md",
+        line: "- ! Use meta/SOUL.md for strategic context and purpose-driven guidance",
+    },
+    {
+        id: "morals",
+        path: "meta/morals.md",
+        line: "- ! Use meta/morals.md for ethical AI development principles",
+    },
+    {
+        id: "code-field",
+        path: "meta/code-field.md",
+        line: "- ~ Use meta/code-field.md for advanced architecture patterns",
+    },
+];
+const SECTION_HEADING = "## Experimental Rules";
+function detectNewline(text) {
+    return text.includes("\r\n") ? "\r\n" : "\n";
+}
+function lineMentionsPath(line, path) {
+    return line.includes(path);
+}
+function findExperimentalSection(text) {
+    const re = /^## Experimental Rules[ \t]*\r?\n?/m;
+    const match = re.exec(text);
+    if (!match || match.index === undefined) {
+        return null;
+    }
+    const start = match.index;
+    const afterHeading = start + match[0].length;
+    const rest = text.slice(afterHeading);
+    // Next H2 or a horizontal rule at line start ends the section.
+    const next = /^(## |---[ \t]*$)/m.exec(rest);
+    const end = next && next.index !== undefined ? afterHeading + next.index : text.length;
+    return {
+        start,
+        end,
+        full: text.slice(start, end),
+        body: text.slice(afterHeading, end),
+    };
+}
+/**
+ * Parse on/off state for the three experimental meta entries.
+ * A path is ON only when a line under `## Experimental Rules` mentions it —
+ * mentions in Personal/Defaults/prose do not count (writes are section-scoped).
+ */
+export function parseExperimentalRulesState(userMdText) {
+    const state = {
+        soul: false,
+        morals: false,
+        "code-field": false,
+    };
+    const section = findExperimentalSection(userMdText);
+    if (!section) {
+        return state;
+    }
+    for (const line of section.body.split(/\r?\n/)) {
+        for (const entry of EXPERIMENTAL_META_ENTRIES) {
+            if (lineMentionsPath(line, entry.path)) {
+                state[entry.id] = true;
+            }
+        }
+    }
+    return state;
+}
+/**
+ * Build section body lines: preserve non-meta custom bullets; apply desired
+ * on/off for the three canonical paths; stable order soul → morals → code-field.
+ */
+function buildSectionBody(existingBody, desired, nl) {
+    const rawLines = existingBody.split(/\r?\n/);
+    const custom = [];
+    for (const line of rawLines) {
+        if (line.trim() === "") {
+            continue;
+        }
+        const isMeta = EXPERIMENTAL_META_ENTRIES.some((e) => lineMentionsPath(line, e.path));
+        if (!isMeta) {
+            custom.push(line);
+        }
+    }
+    const metaLines = EXPERIMENTAL_META_ENTRIES.filter((e) => desired[e.id]).map((e) => e.line);
+    const bullets = [...metaLines, ...custom];
+    if (bullets.length === 0) {
+        return "";
+    }
+    // Heading + blank line + bullets + trailing blank line for clean separation.
+    return `${SECTION_HEADING}${nl}${nl}${bullets.join(nl)}${nl}`;
+}
+/**
+ * Insert a new Experimental Rules section before the trailing `---` / Note
+ * block when present; otherwise append after the last non-empty content.
+ */
+function insertSection(text, section, nl) {
+    // Prefer before the trailing horizontal rule that precedes the USER.md Note
+    // block (allow blank lines between `---` and `**Note**`).
+    const noteRe = /\r?\n---[ \t]*\r?\n(?:[ \t]*\r?\n)*[ \t]*\*\*Note\*\*/;
+    const noteMatch = noteRe.exec(text);
+    if (noteMatch && noteMatch.index !== undefined) {
+        const before = text.slice(0, noteMatch.index).replace(/[ \t]+$/u, "");
+        const after = text.slice(noteMatch.index);
+        const sep = before.endsWith(nl) ? nl : `${nl}${nl}`;
+        return `${before}${sep}${section.replace(/\s+$/u, "")}${after}`;
+    }
+    const trimmed = text.replace(/\s+$/u, "");
+    return `${trimmed}${nl}${nl}${section.replace(/\s+$/u, "")}${nl}`;
+}
+/**
+ * Apply desired Experimental Rules on/off state.
+ *
+ * - Only mutates the `## Experimental Rules` region (or inserts/removes it).
+ * - Personal / Defaults content is left byte-identical outside that region.
+ * - Enabling uses the canonical setup-skill lines; disabling drops path matches.
+ * - Custom non-meta bullets under the section are preserved.
+ * - When all three are off and no custom bullets remain, the section is removed.
+ */
+export function applyExperimentalRulesState(userMdText, desired) {
+    const nl = detectNewline(userMdText);
+    const sectionText = buildSectionBody(findExperimentalSection(userMdText)?.body ?? "", desired, nl);
+    const existing = findExperimentalSection(userMdText);
+    if (existing) {
+        if (!sectionText) {
+            // Remove section; tidy surrounding blank lines.
+            const before = userMdText.slice(0, existing.start).replace(/[ \t]+$/u, "");
+            let after = userMdText.slice(existing.end);
+            // Collapse to at most two newlines at the join.
+            const beforeCore = before.replace(/(\r?\n){2,}$/u, nl);
+            after = after.replace(/^(\r?\n)+/u, nl);
+            if (after.startsWith("---") || after.startsWith("## ")) {
+                return `${beforeCore.replace(/(\r?\n)+$/u, nl)}${nl}${after}`;
+            }
+            return `${beforeCore}${after}`;
+        }
+        return userMdText.slice(0, existing.start) + sectionText + userMdText.slice(existing.end);
+    }
+    if (!sectionText) {
+        return userMdText;
+    }
+    return insertSection(userMdText, sectionText, nl);
+}
+/**
+ * Toggle a single experimental meta entry; leave the other two unchanged.
+ */
+export function setExperimentalRule(userMdText, id, enabled) {
+    const current = parseExperimentalRulesState(userMdText);
+    return applyExperimentalRulesState(userMdText, { ...current, [id]: enabled });
+}
+//# sourceMappingURL=experimental-rules.js.map

package/dist/user-config/index.d.ts

@@ -1,2 +1,3 @@
+export * from "./experimental-rules.js";
 export * from "./resolve-user-md.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/user-config/index.js

@@ -1,2 +1,3 @@
+export * from "./experimental-rules.js";
 export * from "./resolve-user-md.js";
 //# sourceMappingURL=index.js.map

package/dist/vbrief-validate/plan-hooks.d.ts

@@ -8,6 +8,10 @@ export declare function validateTriageRankingLabelsOnPlan(plan: unknown, filepat
 export declare function validateRuntimeAuthorityOnPlan(plan: unknown, filepath: string): string[];
 /** vbrief_validate hook: validate ``plan.policy.hostHooks`` (#2752). */
 export declare function validateHostHooksOnPlan(plan: unknown, filepath: string): string[];
+/** vbrief_validate hook: validate ``plan.policy.hostSlashCommands`` (#3054). */
+export declare function validateHostSlashCommandsOnPlan(plan: unknown, filepath: string): string[];
+/** vbrief_validate hook: validate ``plan.policy.openClawProductCommands`` (#3064). */
+export declare function validateOpenClawProductCommandsOnPlan(plan: unknown, filepath: string): string[];
 /** vbrief_validate hook: validate ``plan.policy.stalenessTickler`` (#2489). */
 export declare function validateStalenessTicklerOnPlan(plan: unknown, filepath: string): string[];
 /** Run all PROJECT-DEFINITION policy hooks (mirrors lazy-import block in Python). */

package/dist/vbrief-validate/plan-hooks.js

@@ -1,7 +1,9 @@
 import { validateHostHooks } from "../policy/host-hooks.js";
+import { validateHostSlashCommands } from "../policy/host-slash-commands.js";
 import { readPlanPolicy } from "../policy/plan-extensions.js";
 import { validateRuntimeAuthority } from "../policy/runtime-authority.js";
 import { validateStalenessTickler } from "../policy/staleness-tickler.js";
+import { validateOpenClawProductCommands } from "../slash/openclaw-deposit.js";
 import { validateTriageAutoClassifyOnPlan, validateTriageHoldMarkersOnPlan, } from "../triage/classify/index.js";
 import { validateRankingLabels } from "../triage/queue/ranking-labels.js";
 import { pyStrRepr, pythonTypeName } from "../triage/scope/python-repr.js";
@@ -140,6 +142,42 @@ export function validateHostHooksOnPlan(plan, filepath) {
     }
     return out;
 }
+/** vbrief_validate hook: validate ``plan.policy.hostSlashCommands`` (#3054). */
+export function validateHostSlashCommandsOnPlan(plan, filepath) {
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return [];
+    }
+    const policy = readPlanPolicy(plan);
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
+        return [];
+    }
+    if (!("hostSlashCommands" in policy)) {
+        return [];
+    }
+    const out = [];
+    for (const err of validateHostSlashCommands(policy.hostSlashCommands)) {
+        out.push(`${filepath}: ${err} (#3054)`);
+    }
+    return out;
+}
+/** vbrief_validate hook: validate ``plan.policy.openClawProductCommands`` (#3064). */
+export function validateOpenClawProductCommandsOnPlan(plan, filepath) {
+    if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
+        return [];
+    }
+    const policy = readPlanPolicy(plan);
+    if (typeof policy !== "object" || policy === null || Array.isArray(policy)) {
+        return [];
+    }
+    if (!("openClawProductCommands" in policy)) {
+        return [];
+    }
+    const out = [];
+    for (const err of validateOpenClawProductCommands(policy.openClawProductCommands)) {
+        out.push(`${filepath}: ${err} (#3064)`);
+    }
+    return out;
+}
 /** vbrief_validate hook: validate ``plan.policy.stalenessTickler`` (#2489). */
 export function validateStalenessTicklerOnPlan(plan, filepath) {
     if (typeof plan !== "object" || plan === null || Array.isArray(plan)) {
@@ -216,6 +254,18 @@ export function runProjectDefinitionHooks(plan, filepath) {
     catch {
         /* hook must not break validation */
     }
+    try {
+        errors.push(...validateHostSlashCommandsOnPlan(plan, filepath));
+    }
+    catch {
+        /* hook must not break validation */
+    }
+    try {
+        errors.push(...validateOpenClawProductCommandsOnPlan(plan, filepath));
+    }
+    catch {
+        /* hook must not break validation */
+    }
     return errors;
 }
 //# sourceMappingURL=plan-hooks.js.map

package/dist/verify-source/contained-writes.js

@@ -59,7 +59,7 @@ export const CONTAINED_WRITES_ALLOWLIST = [
     "packages/core/src/intake/issue-ingest.ts",
     "packages/core/src/intake/reconcile-issues.ts",
     "packages/core/src/issue-sync/sync-from-xbrief.ts",
-    "packages/core/src/orchestration/probe-session.ts",
+    // probe-session.ts removed from allowlist after #3042 contained writeSession.
     "packages/core/src/orchestration/verify-judgment-gates.ts",
     "packages/core/src/platform/changelog-cli.ts",
     "packages/core/src/release/gh.ts",

package/dist/xbrief/create.d.ts

@@ -0,0 +1,36 @@
+/**
+ * xbrief:create — write a dense xBRIEF artifact at --out (#3057).
+ *
+ * Required: --format (json|md|both), --out
+ * Optional: --style, --title, --id, --status, --description, --force, --project-root
+ *
+ * Does NOT move lifecycle folders. Not scope:promote / activate / complete.
+ */
+import { type XbriefCliResult, type XbriefFormat, type XbriefStyle } from "./types.js";
+export declare const CREATE_USAGE: string;
+export interface CreateOptions {
+    format: XbriefFormat;
+    out: string;
+    style: XbriefStyle;
+    title?: string;
+    id?: string;
+    status?: string;
+    description?: string;
+    fromJson?: string;
+    force?: boolean;
+    projectRoot: string;
+    sizeCapBytes?: number;
+    cwd?: string;
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    now?: Date;
+}
+/** Parse create CLI argv into options (or error string). */
+export declare function parseCreateArgv(argv: readonly string[]): CreateOptions | {
+    error: string;
+};
+/** Core create implementation (testable). */
+export declare function createXbrief(options: CreateOptions): XbriefCliResult;
+/** CLI entry for dispatch wrapper. */
+export declare function runXbriefCreateCli(argv: string[]): XbriefCliResult;
+//# sourceMappingURL=create.d.ts.map

package/dist/xbrief/create.js

@@ -0,0 +1,285 @@
+/**
+ * xbrief:create — write a dense xBRIEF artifact at --out (#3057).
+ *
+ * Required: --format (json|md|both), --out
+ * Optional: --style, --title, --id, --status, --description, --force, --project-root
+ *
+ * Does NOT move lifecycle folders. Not scope:promote / activate / complete.
+ */
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { ContainedWriteError, ContainedWriteErrorCode, containedWrite, } from "../fs/contained-write.js";
+import { validateVbriefSchema } from "../vbrief-validate/schema.js";
+import { resolveXbriefOutPaths, XbriefPathError } from "./paths.js";
+import { buildStyleDocument, renderMarkdown } from "./styles.js";
+import { DEFAULT_XBRIEF_SIZE_CAP_BYTES, isXbriefFormat, isXbriefStyle, } from "./types.js";
+export const CREATE_USAGE = "Usage: deft xbrief:create -- --format <json|md|both> --out <path> [--style <scope|playbook|mission|project>] [--title <t>] [--id <id>] [--status <s>] [--description <d>] [--from-json <path>] [--force] [--project-root <dir>]\n" +
+    "  Write a dense xBRIEF artifact at --out. Required: --format and --out.\n" +
+    "  create ≠ lifecycle: does not promote/activate/complete (use scope:* for lifecycle).\n";
+function fail(stderr, exitCode = 2) {
+    return { exitCode, stdout: "", stderr };
+}
+function parseFlagValue(argv, i, name) {
+    const eq = argv[i]?.startsWith(`${name}=`) ? argv[i].slice(name.length + 1) : undefined;
+    if (eq !== undefined) {
+        if (eq.length === 0)
+            return { error: `argument ${name}: expected one argument\n` };
+        return { value: eq, next: i };
+    }
+    const next = argv[i + 1];
+    if (next === undefined || next.startsWith("-")) {
+        return { error: `argument ${name}: expected one argument\n` };
+    }
+    return { value: next, next: i + 1 };
+}
+/** Parse create CLI argv into options (or error string). */
+export function parseCreateArgv(argv) {
+    let format;
+    let out;
+    let style = "scope";
+    let title;
+    let id;
+    let status;
+    let description;
+    let fromJson;
+    let force = false;
+    let projectRoot = process.cwd();
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined)
+            continue;
+        if (arg === "-h" || arg === "--help") {
+            return { error: CREATE_USAGE };
+        }
+        if (arg === "--force") {
+            force = true;
+            continue;
+        }
+        if (arg === "--format" || arg.startsWith("--format=")) {
+            const parsed = parseFlagValue(argv, i, "--format");
+            if ("error" in parsed)
+                return parsed;
+            format = parsed.value;
+            i = parsed.next;
+            continue;
+        }
+        if (arg === "--out" || arg.startsWith("--out=")) {
+            const parsed = parseFlagValue(argv, i, "--out");
+            if ("error" in parsed)
+                return parsed;
+            out = parsed.value;
+            i = parsed.next;
+            continue;
+        }
+        if (arg === "--style" || arg.startsWith("--style=")) {
+            const parsed = parseFlagValue(argv, i, "--style");
+            if ("error" in parsed)
+                return parsed;
+            style = parsed.value;
+            i = parsed.next;
+            continue;
+        }
+        if (arg === "--title" || arg.startsWith("--title=")) {
+            const parsed = parseFlagValue(argv, i, "--title");
+            if ("error" in parsed)
+                return parsed;
+            title = parsed.value;
+            i = parsed.next;
+            continue;
+        }
+        if (arg === "--id" || arg.startsWith("--id=")) {
+            const parsed = parseFlagValue(argv, i, "--id");
+            if ("error" in parsed)
+                return parsed;
+            id = parsed.value;
+            i = parsed.next;
+            continue;
+        }
+        if (arg === "--status" || arg.startsWith("--status=")) {
+            const parsed = parseFlagValue(argv, i, "--status");
+            if ("error" in parsed)
+                return parsed;
+            status = parsed.value;
+            i = parsed.next;
+            continue;
+        }
+        if (arg === "--description" || arg.startsWith("--description=")) {
+            const parsed = parseFlagValue(argv, i, "--description");
+            if ("error" in parsed)
+                return parsed;
+            description = parsed.value;
+            i = parsed.next;
+            continue;
+        }
+        if (arg === "--from-json" || arg.startsWith("--from-json=")) {
+            const parsed = parseFlagValue(argv, i, "--from-json");
+            if ("error" in parsed)
+                return parsed;
+            fromJson = parsed.value;
+            i = parsed.next;
+            continue;
+        }
+        if (arg === "--project-root" || arg.startsWith("--project-root=")) {
+            const parsed = parseFlagValue(argv, i, "--project-root");
+            if ("error" in parsed)
+                return parsed;
+            projectRoot = parsed.value;
+            i = parsed.next;
+            continue;
+        }
+        if (arg === "--")
+            continue;
+        return { error: `unrecognized argument: ${arg}\n${CREATE_USAGE}` };
+    }
+    if (format === undefined) {
+        return { error: `missing required --format (json|md|both)\n${CREATE_USAGE}` };
+    }
+    if (!isXbriefFormat(format)) {
+        return { error: `invalid --format ${format} (expected json|md|both)\n${CREATE_USAGE}` };
+    }
+    if (out === undefined || out.length === 0) {
+        return { error: `missing required --out\n${CREATE_USAGE}` };
+    }
+    if (!isXbriefStyle(style)) {
+        return {
+            error: `invalid --style ${style} (expected scope|playbook|mission|project)\n${CREATE_USAGE}`,
+        };
+    }
+    return {
+        format,
+        out,
+        style,
+        title,
+        id,
+        status,
+        description,
+        fromJson,
+        force,
+        projectRoot,
+    };
+}
+function loadFromJson(path) {
+    try {
+        const raw = readFileSync(path, "utf8");
+        const data = JSON.parse(raw);
+        if (typeof data !== "object" || data === null || Array.isArray(data)) {
+            return { ok: false, error: `--from-json must be a JSON object: ${path}\n` };
+        }
+        return { ok: true, doc: data };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, error: `failed to read --from-json ${path}: ${msg}\n` };
+    }
+}
+function defaultTitle(style, outStem) {
+    const base = basename(outStem);
+    if (base.length > 0)
+        return base;
+    return `Untitled ${style}`;
+}
+/** Core create implementation (testable). */
+export function createXbrief(options) {
+    let paths;
+    try {
+        paths = resolveXbriefOutPaths({
+            projectRoot: options.projectRoot,
+            out: options.out,
+            format: options.format,
+            cwd: options.cwd,
+            home: options.home,
+            env: options.env,
+        });
+    }
+    catch (err) {
+        if (err instanceof XbriefPathError) {
+            return fail(`${err.message}\n`, 1);
+        }
+        throw err;
+    }
+    let doc;
+    if (options.fromJson !== undefined) {
+        const loaded = loadFromJson(options.fromJson);
+        if (!loaded.ok)
+            return fail(loaded.error, 1);
+        doc = loaded.doc;
+    }
+    else {
+        const title = options.title ?? defaultTitle(options.style, paths.stemAbs);
+        doc = buildStyleDocument({
+            style: options.style,
+            title,
+            id: options.id,
+            status: options.status,
+            description: options.description,
+            now: options.now,
+        });
+    }
+    const schemaErrors = validateVbriefSchema(doc, paths.stemAbs);
+    if (schemaErrors.length > 0) {
+        return fail(`xbrief:create schema invalid:\n${schemaErrors.map((e) => `  - ${e}`).join("\n")}\n`, 1);
+    }
+    const sizeCap = options.sizeCapBytes ?? DEFAULT_XBRIEF_SIZE_CAP_BYTES;
+    const jsonText = `${JSON.stringify(doc, null, 2)}\n`;
+    const mdText = renderMarkdown(doc, options.style);
+    if (Buffer.byteLength(jsonText, "utf8") > sizeCap) {
+        return fail(`xbrief:create refused: json payload exceeds size cap (${sizeCap} bytes)\n`, 1);
+    }
+    if (Buffer.byteLength(mdText, "utf8") > sizeCap) {
+        return fail(`xbrief:create refused: md payload exceeds size cap (${sizeCap} bytes)\n`, 1);
+    }
+    const mode = options.force === true ? "replace" : "create";
+    const written = [];
+    try {
+        if (paths.jsonAbs !== null) {
+            containedWrite({
+                root: paths.projectRoot,
+                target: paths.jsonAbs,
+                data: jsonText,
+                mode,
+            });
+            written.push(paths.jsonAbs);
+        }
+        if (paths.mdAbs !== null) {
+            containedWrite({
+                root: paths.projectRoot,
+                target: paths.mdAbs,
+                data: mdText,
+                mode,
+            });
+            written.push(paths.mdAbs);
+        }
+    }
+    catch (err) {
+        if (err instanceof ContainedWriteError) {
+            if (err.code === ContainedWriteErrorCode.EXISTS) {
+                return fail(`xbrief:create refused: target exists (${err.target}); pass --force to replace\n`, 1);
+            }
+            if (err.code === ContainedWriteErrorCode.ESCAPE) {
+                return fail(`xbrief:create path refused: ${err.message}\n`, 1);
+            }
+            return fail(`xbrief:create write failed: ${err.message}\n`, 1);
+        }
+        throw err;
+    }
+    const lines = [
+        `OK xbrief:create format=${options.format} style=${options.style}`,
+        ...written.map((p) => `  wrote ${p}`),
+        "  note: create is not a lifecycle move (scope:* handles promote/activate/complete)",
+    ];
+    return { exitCode: 0, stdout: `${lines.join("\n")}\n`, stderr: "" };
+}
+/** CLI entry for dispatch wrapper. */
+export function runXbriefCreateCli(argv) {
+    const parsed = parseCreateArgv(argv);
+    if ("error" in parsed) {
+        const isHelp = parsed.error === CREATE_USAGE;
+        return {
+            exitCode: isHelp ? 0 : 2,
+            stdout: isHelp ? CREATE_USAGE : "",
+            stderr: isHelp ? "" : parsed.error,
+        };
+    }
+    return createXbrief(parsed);
+}
+//# sourceMappingURL=create.js.map

package/dist/xbrief/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * On-demand xBRIEF create/verify surface (#3057).
+ *
+ * create/verify write or check dense SoT artifacts at --out.
+ * Scope lifecycle remains scope:promote / activate / complete / etc.
+ */
+export { CREATE_USAGE, type CreateOptions, createXbrief, parseCreateArgv, runXbriefCreateCli, } from "./create.js";
+export { expandUserPath, resolveXbriefOutPaths, stripXbriefSuffix, XbriefPathError, } from "./paths.js";
+export { type BuildDocumentInput, buildStyleDocument, MD_REQUIRED_SECTIONS, parseMarkdownMeta, renderMarkdown, } from "./styles.js";
+export { DEFAULT_XBRIEF_SIZE_CAP_BYTES, isXbriefFormat, isXbriefStyle, XBRIEF_FORMATS, XBRIEF_STYLES, type XbriefCliResult, type XbriefDocument, type XbriefFormat, type XbriefPaths, type XbriefStyle, } from "./types.js";
+export { parseVerifyArgv, runXbriefVerifyCli, VERIFY_USAGE, type VerifyOptions, verifyXbrief, } from "./verify.js";
+/** Dispatch-compatible main for a combined xbrief-cli module (create|verify). */
+export declare function main(argv?: string[]): number;
+//# sourceMappingURL=index.d.ts.map

package/dist/xbrief/index.js

@@ -0,0 +1,42 @@
+/**
+ * On-demand xBRIEF create/verify surface (#3057).
+ *
+ * create/verify write or check dense SoT artifacts at --out.
+ * Scope lifecycle remains scope:promote / activate / complete / etc.
+ */
+import { runXbriefCreateCli } from "./create.js";
+import { runXbriefVerifyCli } from "./verify.js";
+export { CREATE_USAGE, createXbrief, parseCreateArgv, runXbriefCreateCli, } from "./create.js";
+export { expandUserPath, resolveXbriefOutPaths, stripXbriefSuffix, XbriefPathError, } from "./paths.js";
+export { buildStyleDocument, MD_REQUIRED_SECTIONS, parseMarkdownMeta, renderMarkdown, } from "./styles.js";
+export { DEFAULT_XBRIEF_SIZE_CAP_BYTES, isXbriefFormat, isXbriefStyle, XBRIEF_FORMATS, XBRIEF_STYLES, } from "./types.js";
+export { parseVerifyArgv, runXbriefVerifyCli, VERIFY_USAGE, verifyXbrief, } from "./verify.js";
+/** Dispatch-compatible main for a combined xbrief-cli module (create|verify). */
+export function main(argv = process.argv.slice(2)) {
+    const [verb, ...rest] = argv;
+    if (verb === "create") {
+        const result = runXbriefCreateCli(rest);
+        if (result.stdout)
+            process.stdout.write(result.stdout);
+        if (result.stderr)
+            process.stderr.write(result.stderr);
+        return result.exitCode;
+    }
+    if (verb === "verify") {
+        const result = runXbriefVerifyCli(rest);
+        if (result.stdout)
+            process.stdout.write(result.stdout);
+        if (result.stderr)
+            process.stderr.write(result.stderr);
+        return result.exitCode;
+    }
+    if (verb === "-h" || verb === "--help" || verb === undefined) {
+        process.stdout.write("Usage: deft xbrief:create|xbrief:verify -- --format <json|md|both> --out <path> [options]\n" +
+            "  create/verify dense xBRIEF artifacts (not scope lifecycle).\n" +
+            "  See: deft xbrief:create --help | deft xbrief:verify --help\n");
+        return verb === undefined ? 2 : 0;
+    }
+    process.stderr.write(`unknown xbrief subcommand: ${verb}\n`);
+    return 2;
+}
+//# sourceMappingURL=index.js.map

package/dist/xbrief/paths.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Portable path expand + project-root containment for xbrief:create/verify (#3057).
+ *
+ * Uses real path APIs (node:path / node:os) — no slash-only logic.
+ * Default containment under project root fails closed on escape.
+ */
+import type { XbriefFormat, XbriefPaths } from "./types.js";
+export declare class XbriefPathError extends Error {
+    readonly code: string;
+    constructor(message: string, code?: string);
+}
+/**
+ * Expand simple user path forms portably:
+ * - `~` / `~/…` / `~\…` → home directory
+ * - `%VAR%` (Windows-class env expansion) when present in the string
+ *
+ * Relative paths are left relative (caller resolves against project root or cwd).
+ */
+export declare function expandUserPath(input: string, options?: {
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+}): string;
+/** Strip known xBRIEF suffixes to recover a write stem. */
+export declare function stripXbriefSuffix(pathLike: string): string;
+/**
+ * Resolve `--out` under `projectRoot` with user-path expansion and fail-closed
+ * containment. Returns absolute stem + format-specific artifact paths.
+ */
+export declare function resolveXbriefOutPaths(input: {
+    projectRoot: string;
+    out: string;
+    format: XbriefFormat;
+    cwd?: string;
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+}): XbriefPaths;
+//# sourceMappingURL=paths.d.ts.map