@deftai/directive-core 0.55.0

package/dist/encoding/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./evaluate.js";
+export * from "./git.js";
+export * from "./patterns.js";
+export * from "./scan.js";
+export * from "./text.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/encoding/index.js

@@ -0,0 +1,6 @@
+export * from "./evaluate.js";
+export * from "./git.js";
+export * from "./patterns.js";
+export * from "./scan.js";
+export * from "./text.js";
+//# sourceMappingURL=index.js.map

package/dist/encoding/patterns.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Encoding-gate constants, ported verbatim from the Python oracle
+ * (`scripts/verify_encoding.py`, #798) so the TS port golden-diffs clean
+ * against it. Any change here MUST be mirrored in the Python source and
+ * re-validated through the parity harness (#1718).
+ */
+/**
+ * Codepoint sequences that signal a Windows codepage round-trip corruption,
+ * mapped to a short label naming the canonical codepoint that was corrupted.
+ * Order matches the Python `MOJIBAKE_PATTERNS` dict.
+ */
+export declare const MOJIBAKE_PATTERNS: ReadonlyMap<string, string>;
+/** U+FFFD REPLACEMENT CHARACTER — the universal mojibake marker. */
+export declare const REPLACEMENT_CHAR = "\uFFFD";
+/** UTF-8 BOM byte sequence (EF BB BF). */
+export declare const UTF8_BOM: ReadonlyArray<number>;
+/** Extensions where a leading UTF-8 BOM is non-canonical and should be flagged. */
+export declare const NO_BOM_EXTENSIONS: ReadonlySet<string>;
+/** Control characters that must not hide inside decoded vBRIEF narratives. */
+export declare const VBRIEF_CONTROL_CHAR_LABELS: ReadonlyMap<string, string>;
+/** File extensions to scan by default (conservative; excludes binary). */
+export declare const SCANNABLE_EXTENSIONS: ReadonlySet<string>;
+/**
+ * Path-glob patterns auto-skipped because the file legitimately contains
+ * mojibake byte sequences as part of its purpose. Matched against the path's
+ * POSIX form. Ported verbatim from the Python `BUILTIN_ALLOW_LIST`.
+ */
+export declare const BUILTIN_ALLOW_LIST: ReadonlyArray<string>;
+//# sourceMappingURL=patterns.d.ts.map

package/dist/encoding/patterns.js

@@ -0,0 +1,109 @@
+/**
+ * Encoding-gate constants, ported verbatim from the Python oracle
+ * (`scripts/verify_encoding.py`, #798) so the TS port golden-diffs clean
+ * against it. Any change here MUST be mirrored in the Python source and
+ * re-validated through the parity harness (#1718).
+ */
+/**
+ * Codepoint sequences that signal a Windows codepage round-trip corruption,
+ * mapped to a short label naming the canonical codepoint that was corrupted.
+ * Order matches the Python `MOJIBAKE_PATTERNS` dict.
+ */
+export const MOJIBAKE_PATTERNS = new Map([
+    // CP437-as-UTF-8 (Windows DOS codepage; recurrence record PR #844 / fix #846).
+    ["Γèù", "U+2297 (⊗) corrupted via cp437 read"],
+    ["Γ£ô", "U+2713 (✓) corrupted via cp437 read"],
+    ["ΓǪ", "U+2026 (…) corrupted via cp437 read"],
+    ["ΓÇö", "U+2014 (—) corrupted via cp437 read"],
+    ["ΓÇô", "U+2013 (–) corrupted via cp437 read"],
+    ["ΓÇó", "U+2022 (•) corrupted via cp437 read"],
+    ["ΓÇÖ", "U+2019 (’) corrupted via cp437 read"],
+    ["ΓÇÿ", "U+2018 (‘) corrupted via cp437 read"],
+    ["ΓÇ£", "U+201C (“) corrupted via cp437 read"],
+    ["ΓÇØ", "U+201D (”) corrupted via cp437 read"],
+    ["ΓåÆ", "U+2192 (→) corrupted via cp437 read"],
+    // CP1252-as-UTF-8 (Windows ANSI codepage; recurrence record #236, #240, #283, PR #795).
+    ["’", "U+2019 (’) corrupted via cp1252 read"],
+    ["‘", "U+2018 (‘) corrupted via cp1252 read"],
+    ["“", "U+201C (“) corrupted via cp1252 read"],
+    ["â€\x9d", "U+201D (”) corrupted via cp1252 read"],
+    ["–", "U+2013 (–) corrupted via cp1252 read"],
+    ["—", "U+2014 (—) corrupted via cp1252 read"],
+    ["…", "U+2026 (…) corrupted via cp1252 read"],
+    ["•", "U+2022 (•) corrupted via cp1252 read"],
+    ["→", "U+2192 (→) corrupted via cp1252 read"],
+    ["§", "U+00A7 (§) corrupted via cp1252 read"],
+    ["°", "U+00B0 (°) corrupted via cp1252 read"],
+    ["´", "U+00B4 (´) corrupted via cp1252 read"],
+    ["Â\xad", "U+00AD (soft hyphen) corrupted via cp1252 read"],
+    ["©", "U+00A9 (©) corrupted via cp1252 read"],
+    ["®", "U+00AE (®) corrupted via cp1252 read"],
+    ["±", "U+00B1 (±) corrupted via cp1252 read"],
+]);
+/** U+FFFD REPLACEMENT CHARACTER — the universal mojibake marker. */
+export const REPLACEMENT_CHAR = "\ufffd";
+/** UTF-8 BOM byte sequence (EF BB BF). */
+export const UTF8_BOM = [0xef, 0xbb, 0xbf];
+/** Extensions where a leading UTF-8 BOM is non-canonical and should be flagged. */
+export const NO_BOM_EXTENSIONS = new Set([
+    ".md",
+    ".json",
+    ".yml",
+    ".yaml",
+    ".txt",
+]);
+/** Control characters that must not hide inside decoded vBRIEF narratives. */
+export const VBRIEF_CONTROL_CHAR_LABELS = new Map([
+    ["\b", "U+0008 backspace in vBRIEF narrative"],
+    ["\t", "U+0009 tab in vBRIEF narrative"],
+    ["\v", "U+000B vertical tab in vBRIEF narrative"],
+    ["\f", "U+000C form feed in vBRIEF narrative"],
+]);
+/** File extensions to scan by default (conservative; excludes binary). */
+export const SCANNABLE_EXTENSIONS = new Set([
+    ".md",
+    ".json",
+    ".yml",
+    ".yaml",
+    ".txt",
+    ".py",
+    ".sh",
+    ".ps1",
+    ".toml",
+    ".cfg",
+]);
+/**
+ * Path-glob patterns auto-skipped because the file legitimately contains
+ * mojibake byte sequences as part of its purpose. Matched against the path's
+ * POSIX form. Ported verbatim from the Python `BUILTIN_ALLOW_LIST`.
+ */
+export const BUILTIN_ALLOW_LIST = [
+    "vbrief/active/*-798-*.vbrief.json",
+    "vbrief/completed/*-798-*.vbrief.json",
+    "vbrief/cancelled/*-798-*.vbrief.json",
+    "vbrief/pending/*-798-*.vbrief.json",
+    "vbrief/proposed/*-798-*.vbrief.json",
+    ".deft/core/vbrief/active/*-798-*.vbrief.json",
+    ".deft/core/vbrief/completed/*-798-*.vbrief.json",
+    ".deft/core/vbrief/cancelled/*-798-*.vbrief.json",
+    ".deft/core/vbrief/pending/*-798-*.vbrief.json",
+    ".deft/core/vbrief/proposed/*-798-*.vbrief.json",
+    "deft/vbrief/active/*-798-*.vbrief.json",
+    "deft/vbrief/completed/*-798-*.vbrief.json",
+    "deft/vbrief/cancelled/*-798-*.vbrief.json",
+    "deft/vbrief/pending/*-798-*.vbrief.json",
+    "deft/vbrief/proposed/*-798-*.vbrief.json",
+    "history/archive/**",
+    "history/archive/**/*",
+    ".deft/core/history/archive/**",
+    ".deft/core/history/archive/**/*",
+    "deft/history/archive/**",
+    "deft/history/archive/**/*",
+    "scripts/verify_encoding.py",
+    "tests/cli/test_verify_encoding.py",
+    ".deft/core/scripts/verify_encoding.py",
+    ".deft/core/tests/cli/test_verify_encoding.py",
+    "deft/scripts/verify_encoding.py",
+    "deft/tests/cli/test_verify_encoding.py",
+];
+//# sourceMappingURL=patterns.js.map

package/dist/encoding/scan.d.ts

@@ -0,0 +1,24 @@
+/** One mojibake / U+FFFD / BOM detection record. */
+export interface Finding {
+    readonly path: string;
+    readonly line: number;
+    readonly label: string;
+    readonly context: string;
+}
+/** Render a finding as the Python oracle does: `  path:line [label] context`. */
+export declare function renderFinding(f: Finding): string;
+/** Lowercased final extension of a path, including the dot (e.g. ".md"). */
+export declare function suffixOf(path: string): string;
+/** Scan one line; return findings for U+FFFD + each mojibake pattern hit. */
+export declare function scanLine(relPath: string, lineno: number, line: string, context?: string): Finding[];
+/**
+ * Scan one file for U+FFFD / mojibake / unexpected BOM. An unreadable or
+ * binary file returns an empty list rather than throwing (the gate is
+ * intentionally permissive on read failures). Mirrors Python `scan_file`.
+ */
+export declare function scanFile(relPath: string, fullPath: string): Finding[];
+/** Return true for in-flight vBRIEF files that may receive issue ingest. */
+export declare function isVbriefNarrativeControlScope(relPath: string): boolean;
+/** Scan decoded `plan.narratives` strings for hidden control chars. */
+export declare function scanVbriefNarrativeControls(relPath: string, text: string): Finding[];
+//# sourceMappingURL=scan.d.ts.map

package/dist/encoding/scan.js

@@ -0,0 +1,182 @@
+import { readFileSync } from "node:fs";
+import { MOJIBAKE_PATTERNS, NO_BOM_EXTENSIONS, REPLACEMENT_CHAR, UTF8_BOM, VBRIEF_CONTROL_CHAR_LABELS, } from "./patterns.js";
+import { pythonSplitlines, stripMarkdownQuotes } from "./text.js";
+/** Render a finding as the Python oracle does: `  path:line [label] context`. */
+export function renderFinding(f) {
+    const ctx = f.context.length <= 120 ? f.context : `${f.context.slice(0, 117)}...`;
+    return `  ${f.path}:${f.line} [${f.label}] ${ctx}`;
+}
+/** Lowercased final extension of a path, including the dot (e.g. ".md"). */
+export function suffixOf(path) {
+    const base = path.replace(/\\/g, "/").split("/").pop() ?? "";
+    const dot = base.lastIndexOf(".");
+    if (dot <= 0) {
+        return "";
+    }
+    return base.slice(dot).toLowerCase();
+}
+/** Scan one line; return findings for U+FFFD + each mojibake pattern hit. */
+export function scanLine(relPath, lineno, line, context) {
+    const findings = [];
+    const ctx = context !== undefined ? context : line;
+    if (line.includes(REPLACEMENT_CHAR)) {
+        findings.push({ path: relPath, line: lineno, label: "U+FFFD replacement char", context: ctx });
+    }
+    for (const [pattern, label] of MOJIBAKE_PATTERNS) {
+        if (line.includes(pattern)) {
+            findings.push({ path: relPath, line: lineno, label, context: ctx });
+        }
+    }
+    return findings;
+}
+function startsWithBom(raw) {
+    if (raw.length < UTF8_BOM.length) {
+        return false;
+    }
+    return UTF8_BOM.every((byte, i) => raw[i] === byte);
+}
+/**
+ * Scan one file for U+FFFD / mojibake / unexpected BOM. An unreadable or
+ * binary file returns an empty list rather than throwing (the gate is
+ * intentionally permissive on read failures). Mirrors Python `scan_file`.
+ */
+export function scanFile(relPath, fullPath) {
+    const findings = [];
+    const suffix = suffixOf(fullPath);
+    let raw;
+    try {
+        raw = readFileSync(fullPath);
+    }
+    catch {
+        return findings;
+    }
+    if (NO_BOM_EXTENSIONS.has(suffix) && startsWithBom(raw)) {
+        findings.push({
+            path: relPath,
+            line: 1,
+            label: "unexpected UTF-8 BOM",
+            context: "leading bytes EF BB BF on a format where BOM is non-canonical",
+        });
+    }
+    // Node Buffer.toString('utf8') performs lossy U+FFFD replacement, matching
+    // Python bytes.decode('utf-8', errors='replace').
+    const text = raw.toString("utf8");
+    if (text.slice(0, 1024).includes("\u0000")) {
+        // Likely binary file — skip mojibake scan.
+        return findings;
+    }
+    let scanText = text;
+    if (suffix === ".md") {
+        scanText = stripMarkdownQuotes(text);
+    }
+    if (scanText === text) {
+        const lines = pythonSplitlines(text);
+        lines.forEach((line, idx) => {
+            findings.push(...scanLine(relPath, idx + 1, line));
+        });
+    }
+    else {
+        const originalLines = pythonSplitlines(text);
+        const strippedLines = pythonSplitlines(scanText);
+        if (strippedLines.length < originalLines.length) {
+            while (strippedLines.length < originalLines.length) {
+                strippedLines.push("");
+            }
+        }
+        originalLines.forEach((orig, idx) => {
+            const stripped = strippedLines[idx] ?? "";
+            findings.push(...scanLine(relPath, idx + 1, stripped, orig));
+        });
+    }
+    if (isVbriefNarrativeControlScope(relPath)) {
+        findings.push(...scanVbriefNarrativeControls(relPath, text));
+    }
+    return findings;
+}
+/** Return true for in-flight vBRIEF files that may receive issue ingest. */
+export function isVbriefNarrativeControlScope(relPath) {
+    if (!relPath.endsWith(".vbrief.json")) {
+        return false;
+    }
+    const normalized = `/${relPath.replace(/\\/g, "/")}`;
+    return normalized.includes("/vbrief/proposed/") || normalized.includes("/vbrief/active/");
+}
+function tabIsNonIndentation(value, index) {
+    const lineStart = value.lastIndexOf("\n", index - 1) + 1;
+    for (const ch of value.slice(lineStart, index)) {
+        if (ch !== " " && ch !== "\t") {
+            return true;
+        }
+    }
+    return false;
+}
+function decodedControlLabels(value) {
+    const labels = [];
+    const seen = new Set();
+    // Iterate by UTF-16 code unit index so lastIndexOf offsets line up; control
+    // chars of interest are all BMP single-unit characters.
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index];
+        if (char === "\t" && !tabIsNonIndentation(value, index)) {
+            continue;
+        }
+        let label = VBRIEF_CONTROL_CHAR_LABELS.get(char);
+        const code = char.charCodeAt(0);
+        if (label === undefined && code < 32 && char !== "\n" && char !== "\r") {
+            label = `U+${code.toString(16).toUpperCase().padStart(4, "0")} control character in vBRIEF narrative`;
+        }
+        if (label !== undefined && !seen.has(label)) {
+            seen.add(label);
+            labels.push(label);
+        }
+    }
+    return labels;
+}
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function jsonKeyLine(text, key) {
+    const match = new RegExp(`"${escapeRegExp(key)}"\\s*:`).exec(text);
+    if (match === null) {
+        return 1;
+    }
+    return (text.slice(0, match.index).match(/\n/g) ?? []).length + 1;
+}
+/** Scan decoded `plan.narratives` strings for hidden control chars. */
+export function scanVbriefNarrativeControls(relPath, text) {
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        return [];
+    }
+    if (typeof data !== "object" || data === null) {
+        return [];
+    }
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null) {
+        return [];
+    }
+    const narratives = plan.narratives;
+    if (typeof narratives !== "object" || narratives === null) {
+        return [];
+    }
+    const findings = [];
+    for (const [key, value] of Object.entries(narratives)) {
+        if (typeof value !== "string") {
+            continue;
+        }
+        const keyLine = jsonKeyLine(text, key);
+        for (const label of decodedControlLabels(value)) {
+            findings.push({
+                path: relPath,
+                line: keyLine,
+                label,
+                context: `plan.narratives.${key} contains ${label}`,
+            });
+        }
+    }
+    return findings;
+}
+//# sourceMappingURL=scan.js.map

package/dist/encoding/text.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Text helpers ported to match Python semantics exactly so the encoding gate
+ * golden-diffs clean against the Python oracle (#798 / #1718): line splitting
+ * (`str.splitlines`), markdown code-span stripping, and `fnmatch.fnmatchcase`
+ * glob matching for the allow-list.
+ */
+/**
+ * Split `text` into lines using Python `str.splitlines()` semantics: splits on
+ * the full Unicode line-boundary set and does NOT emit a trailing empty string
+ * for a final line break. Empty input yields an empty array.
+ */
+export declare function pythonSplitlines(text: string): string[];
+/**
+ * Strip fenced code blocks and inline-code spans from markdown content.
+ * Fenced blocks are blanked newline-for-newline first (preserving line numbers),
+ * then inline spans are removed. Mirrors the Python `_strip_markdown_quotes`.
+ */
+export declare function stripMarkdownQuotes(text: string): string;
+/** Return true when `relPath` (POSIX form) matches the fnmatch `pattern`. */
+export declare function fnmatchCase(relPath: string, pattern: string): boolean;
+//# sourceMappingURL=text.d.ts.map

package/dist/encoding/text.js

@@ -0,0 +1,111 @@
+/**
+ * Text helpers ported to match Python semantics exactly so the encoding gate
+ * golden-diffs clean against the Python oracle (#798 / #1718): line splitting
+ * (`str.splitlines`), markdown code-span stripping, and `fnmatch.fnmatchcase`
+ * glob matching for the allow-list.
+ */
+// Python str.splitlines() boundaries: \n \r \r\n \v \f \x1c \x1d \x1e \x85 \u2028 \u2029.
+// The control chars are the intentional boundary set ported from CPython for
+// golden-diff parity (#1718), not accidental input.
+// biome-ignore lint/suspicious/noControlCharactersInRegex: intentional Python splitlines() boundary set (#1718)
+const SPLITLINES_BOUNDARY = /\r\n|[\n\r\v\f\u001c\u001d\u001e\u0085\u2028\u2029]/g;
+/**
+ * Split `text` into lines using Python `str.splitlines()` semantics: splits on
+ * the full Unicode line-boundary set and does NOT emit a trailing empty string
+ * for a final line break. Empty input yields an empty array.
+ */
+export function pythonSplitlines(text) {
+    if (text === "") {
+        return [];
+    }
+    const lines = [];
+    let last = 0;
+    SPLITLINES_BOUNDARY.lastIndex = 0;
+    let match = SPLITLINES_BOUNDARY.exec(text);
+    while (match !== null) {
+        lines.push(text.slice(last, match.index));
+        last = match.index + match[0].length;
+        match = SPLITLINES_BOUNDARY.exec(text);
+    }
+    if (last < text.length) {
+        lines.push(text.slice(last));
+    }
+    return lines;
+}
+// Markdown inline-code span: single backtick to single backtick on one line.
+const MD_INLINE_CODE = /`[^`\r\n]*`/g;
+// Markdown fenced code block: ``` (or ~~~) ... matching close fence.
+// Flags: g (replace all), m (^/$ per line), s (dotall so .*? spans lines).
+const MD_FENCED_BLOCK = /^[ \t]*(```|~~~)[^\n]*\n.*?^[ \t]*\1[ \t\r]*$/gms;
+/** Replace a fenced block with the same number of newlines (line alignment). */
+function blankBlock(match) {
+    const count = (match.match(/\n/g) ?? []).length;
+    return "\n".repeat(count);
+}
+/**
+ * Strip fenced code blocks and inline-code spans from markdown content.
+ * Fenced blocks are blanked newline-for-newline first (preserving line numbers),
+ * then inline spans are removed. Mirrors the Python `_strip_markdown_quotes`.
+ */
+export function stripMarkdownQuotes(text) {
+    const withoutFences = text.replace(MD_FENCED_BLOCK, (m) => blankBlock(m));
+    return withoutFences.replace(MD_INLINE_CODE, "");
+}
+/**
+ * Translate a single `fnmatch`-style glob to an anchored regex source.
+ * Mirrors CPython `fnmatch.translate` for the subset used by the allow-list:
+ * `*` matches any run of characters (including `/`), `?` matches one character,
+ * `[...]` is a character class (`!` negates), everything else is literal.
+ */
+function fnmatchTranslate(pattern) {
+    let out = "";
+    let i = 0;
+    const n = pattern.length;
+    while (i < n) {
+        const c = pattern.charAt(i);
+        i += 1;
+        if (c === "*") {
+            out += ".*";
+        }
+        else if (c === "?") {
+            out += ".";
+        }
+        else if (c === "[") {
+            let j = i;
+            if (j < n && pattern.charAt(j) === "!") {
+                j += 1;
+            }
+            if (j < n && pattern.charAt(j) === "]") {
+                j += 1;
+            }
+            while (j < n && pattern.charAt(j) !== "]") {
+                j += 1;
+            }
+            if (j >= n) {
+                out += "\\[";
+            }
+            else {
+                let stuff = pattern.slice(i, j).replace(/\\/g, "\\\\");
+                i = j + 1;
+                if (stuff.startsWith("!")) {
+                    stuff = `^${stuff.slice(1)}`;
+                }
+                else if (stuff.startsWith("^")) {
+                    stuff = `\\${stuff}`;
+                }
+                out += `[${stuff}]`;
+            }
+        }
+        else {
+            out += c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        }
+    }
+    return out;
+}
+/** Return true when `relPath` (POSIX form) matches the fnmatch `pattern`. */
+export function fnmatchCase(relPath, pattern) {
+    // `s` flag so `.` (from `*`) spans any character, matching fnmatch's dotall.
+    const re = new RegExp(`^(?:${fnmatchTranslate(pattern)})$`, "s");
+    return re.test(relPath);
+}
+//# sourceMappingURL=text.js.map

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import type { EngineInfo } from "@deftai/directive-types";
+/**
+ * `@deftai/directive-core` — the deft directive engine core.
+ *
+ * Hosts the ported enforcement gates during the strangler-fig migration
+ * (#1530). The Wave-1 encoding gate (`verify:encoding`, #1718) is re-exported
+ * flat from the root for backward compatibility. The Wave-2 gates each expose
+ * an `evaluate()` / `EvaluateResult` pair, so they are re-exported under stable
+ * namespaces here (and as `@deftai/directive-core/<gate>` subpaths in package.json) to
+ * avoid colliding on those shared symbol names.
+ */
+export * as branch from "./branch/index.js";
+export * as cache from "./cache/index.js";
+export * as capacity from "./capacity/index.js";
+export * as codebase from "./codebase/index.js";
+export * as doctor from "./doctor/index.js";
+export * from "./encoding/index.js";
+export * as intake from "./intake/index.js";
+export * as lifecycle from "./lifecycle/index.js";
+export * as orchestration from "./orchestration/index.js";
+export * as packs from "./packs/index.js";
+export * as platform from "./platform/index.js";
+export * as policy from "./policy/index.js";
+export * as prClosingKeywords from "./pr-closing-keywords/index.js";
+export * as prMergeReadiness from "./pr-merge-readiness/index.js";
+export * as prMonitor from "./pr-monitor/index.js";
+export * as prProtectedIssues from "./pr-protected-issues/index.js";
+export * as prWaitMergeable from "./pr-wait-mergeable/index.js";
+export * as preflight from "./preflight/index.js";
+export * as release from "./release/index.js";
+export * as releaseE2e from "./release-e2e/index.js";
+export * as releasePublish from "./release-publish/index.js";
+export * as releaseRollback from "./release-rollback/index.js";
+export * as render from "./render/index.js";
+export * as scm from "./scm/index.js";
+export * as scope from "./scope/index.js";
+export * as session from "./session/index.js";
+export * as slice from "./slice/index.js";
+export * as storyReady from "./story-ready/index.js";
+export * as swarm from "./swarm/index.js";
+export * as triage from "./triage/index.js";
+export * as validateContent from "./validate-content/index.js";
+export * as vbriefActivate from "./vbrief-activate/index.js";
+export * as vbriefBuild from "./vbrief-build/index.js";
+export * as vbriefReconcile from "./vbrief-reconcile/index.js";
+export * as vbriefValidate from "./vbrief-validate/index.js";
+export * as vbriefValidation from "./vbrief-validation/index.js";
+export * as verifyEnv from "./verify-env/index.js";
+export * as verifySource from "./verify-source/index.js";
+export * as wipCap from "./wip-cap/index.js";
+export declare const CORE_PACKAGE: "@deftai/directive-core";
+/** Returns identifying metadata for the core engine package. */
+export declare function engineInfo(): EngineInfo;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,55 @@
+/**
+ * `@deftai/directive-core` — the deft directive engine core.
+ *
+ * Hosts the ported enforcement gates during the strangler-fig migration
+ * (#1530). The Wave-1 encoding gate (`verify:encoding`, #1718) is re-exported
+ * flat from the root for backward compatibility. The Wave-2 gates each expose
+ * an `evaluate()` / `EvaluateResult` pair, so they are re-exported under stable
+ * namespaces here (and as `@deftai/directive-core/<gate>` subpaths in package.json) to
+ * avoid colliding on those shared symbol names.
+ */
+export * as branch from "./branch/index.js";
+export * as cache from "./cache/index.js";
+export * as capacity from "./capacity/index.js";
+export * as codebase from "./codebase/index.js";
+export * as doctor from "./doctor/index.js";
+export * from "./encoding/index.js";
+export * as intake from "./intake/index.js";
+export * as lifecycle from "./lifecycle/index.js";
+export * as orchestration from "./orchestration/index.js";
+export * as packs from "./packs/index.js";
+export * as platform from "./platform/index.js";
+export * as policy from "./policy/index.js";
+export * as prClosingKeywords from "./pr-closing-keywords/index.js";
+export * as prMergeReadiness from "./pr-merge-readiness/index.js";
+export * as prMonitor from "./pr-monitor/index.js";
+export * as prProtectedIssues from "./pr-protected-issues/index.js";
+export * as prWaitMergeable from "./pr-wait-mergeable/index.js";
+export * as preflight from "./preflight/index.js";
+export * as release from "./release/index.js";
+export * as releaseE2e from "./release-e2e/index.js";
+export * as releasePublish from "./release-publish/index.js";
+export * as releaseRollback from "./release-rollback/index.js";
+export * as render from "./render/index.js";
+export * as scm from "./scm/index.js";
+export * as scope from "./scope/index.js";
+export * as session from "./session/index.js";
+export * as slice from "./slice/index.js";
+export * as storyReady from "./story-ready/index.js";
+export * as swarm from "./swarm/index.js";
+export * as triage from "./triage/index.js";
+export * as validateContent from "./validate-content/index.js";
+export * as vbriefActivate from "./vbrief-activate/index.js";
+export * as vbriefBuild from "./vbrief-build/index.js";
+export * as vbriefReconcile from "./vbrief-reconcile/index.js";
+export * as vbriefValidate from "./vbrief-validate/index.js";
+export * as vbriefValidation from "./vbrief-validation/index.js";
+export * as verifyEnv from "./verify-env/index.js";
+export * as verifySource from "./verify-source/index.js";
+export * as wipCap from "./wip-cap/index.js";
+export const CORE_PACKAGE = "@deftai/directive-core";
+/** Returns identifying metadata for the core engine package. */
+export function engineInfo() {
+    return { name: CORE_PACKAGE, version: "0.0.0" };
+}
+//# sourceMappingURL=index.js.map

package/dist/intake/candidates-log.d.ts

@@ -0,0 +1,20 @@
+export declare const DEFAULT_LOG_PATH: string;
+export declare class CandidatesLogError extends Error {
+    constructor(message: string);
+}
+export declare function validateCandidatesEntry(entry: unknown): void;
+export declare function append(entry: Record<string, unknown>, options?: {
+    path?: string | null;
+}): string;
+export declare function readAll(repo?: string | null, options?: {
+    path?: string | null;
+    warn?: (msg: string) => void;
+}): Record<string, unknown>[];
+export declare function findByIssue(issueNumber: number, repo: string, options?: {
+    path?: string | null;
+}): Record<string, unknown>[];
+export declare function latestDecision(issueNumber: number, repo: string, options?: {
+    path?: string | null;
+}): Record<string, unknown> | null;
+export declare function newDecisionId(): string;
+//# sourceMappingURL=candidates-log.d.ts.map