@deftai/directive-core 0.77.0 → 0.79.0

package/dist/eval/triggers.js

@@ -0,0 +1,259 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+/** Relative path to skill-pi-trigger-eval compatible case rows (#1586). */
+export const TRIGGER_CASES_REL = "evals/trigger-cases.jsonl";
+/** Default Skills Index source for AGENTS.md skill routing (#1586). */
+export const SKILLS_INDEX_REL = "REFERENCES.md";
+/** Normalize user text for deterministic substring trigger matching. */
+export function normalizeTriggerText(text) {
+    return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+/** Collapse embedded newlines before interpolating user/data into log lines. */
+export function sanitizeTriggerLogLine(text) {
+    return text.replace(/\r?\n/g, " ").trim();
+}
+/** Extract backtick trigger phrases from a Skills Index triggers cell. */
+export function parseTriggerCell(cell) {
+    const triggers = [];
+    for (const match of cell.matchAll(/`([^`]+)`/g)) {
+        const phrase = normalizeTriggerText(match[1] ?? "");
+        if (phrase.length > 0) {
+            triggers.push(phrase);
+        }
+    }
+    return triggers;
+}
+/** Parse the Skills Index markdown table in REFERENCES.md. */
+export function parseSkillsIndex(markdown) {
+    const entries = [];
+    for (const line of markdown.split(/\r?\n/)) {
+        if (!line.startsWith("| [deft-directive-")) {
+            continue;
+        }
+        const columns = line.split("|").map((col) => col.trim());
+        if (columns.length < 5) {
+            continue;
+        }
+        const linkCell = columns[1] ?? "";
+        const triggersCell = columns[3] ?? "";
+        // Avoid nested character-class regex (CodeQL js/polynomial-redos on \[([^\]]+)\]).
+        const open = linkCell.indexOf("[");
+        const close = open === -1 ? -1 : linkCell.indexOf("]", open + 1);
+        if (open === -1 || close === -1) {
+            continue;
+        }
+        const skillId = linkCell.slice(open + 1, close).trim();
+        if (skillId.length === 0) {
+            continue;
+        }
+        const triggers = parseTriggerCell(triggersCell);
+        if (triggers.length === 0) {
+            continue;
+        }
+        entries.push({ skillId, triggers });
+    }
+    return entries;
+}
+/** Find the winning skill for a query using longest-trigger-wins disambiguation. */
+export function resolveTriggerWinner(query, index) {
+    const normalized = normalizeTriggerText(query);
+    let best = null;
+    for (const entry of index) {
+        for (const trigger of entry.triggers) {
+            if (!normalized.includes(trigger)) {
+                continue;
+            }
+            if (best === null ||
+                trigger.length > best.trigger.length ||
+                (trigger.length === best.trigger.length && entry.skillId.localeCompare(best.skillId) < 0)) {
+                best = { skillId: entry.skillId, trigger };
+            }
+        }
+    }
+    return best;
+}
+/** True when the Skills Index routing would send *query* to *skillId*. */
+export function wouldRouteToSkill(query, skillId, index) {
+    const winner = resolveTriggerWinner(query, index);
+    return winner !== null && winner.skillId === skillId;
+}
+/** Validate one JSONL row against the skill-pi-trigger-eval row contract. */
+export function parseTriggerCaseRow(raw, lineNumber) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        return `line ${lineNumber}: expected a JSON object`;
+    }
+    const record = raw;
+    const id = record.id;
+    const query = record.query;
+    const skill = record.skill;
+    const shouldTrigger = record.should_trigger;
+    if (typeof id !== "string" || id.trim().length === 0) {
+        return `line ${lineNumber}: id must be a non-empty string`;
+    }
+    if (typeof query !== "string" || query.trim().length === 0) {
+        return `line ${lineNumber}: query must be a non-empty string`;
+    }
+    if (typeof skill !== "string" || !skill.startsWith("deft-directive-")) {
+        return `line ${lineNumber}: skill must be a deft-directive-* id`;
+    }
+    if (typeof shouldTrigger !== "boolean") {
+        return `line ${lineNumber}: should_trigger must be true or false`;
+    }
+    return {
+        id: id.trim(),
+        query: query.trim(),
+        skill: skill.trim(),
+        should_trigger: shouldTrigger,
+    };
+}
+/** Load evals/trigger-cases.jsonl. */
+export function loadTriggerCases(path) {
+    if (!existsSync(path)) {
+        return { error: `missing trigger cases at ${path}` };
+    }
+    const text = readFileSync(path, "utf8");
+    const rows = [];
+    const lines = text.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i]?.trim() ?? "";
+        if (line.length === 0 || line.startsWith("#")) {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            return { error: `line ${i + 1}: invalid JSON` };
+        }
+        const row = parseTriggerCaseRow(parsed, i + 1);
+        if (typeof row === "string") {
+            return { error: row };
+        }
+        rows.push(row);
+    }
+    if (rows.length === 0) {
+        return { error: "trigger-cases.jsonl has no cases" };
+    }
+    return rows;
+}
+/** Verify at least two positive and one negative case per indexed skill. */
+export function validateTriggerCoverage(cases, index) {
+    const errors = [];
+    const bySkill = new Map();
+    for (const entry of index) {
+        bySkill.set(entry.skillId, { positive: 0, negative: 0 });
+    }
+    for (const row of cases) {
+        const bucket = bySkill.get(row.skill);
+        if (bucket === undefined) {
+            errors.push(`case '${row.id}' references unknown skill '${row.skill}'`);
+            continue;
+        }
+        if (row.should_trigger) {
+            bucket.positive += 1;
+        }
+        else {
+            bucket.negative += 1;
+        }
+    }
+    for (const [skillId, counts] of bySkill) {
+        if (counts.positive < 2) {
+            errors.push(`${skillId}: need at least 2 positive trigger cases (have ${counts.positive})`);
+        }
+        if (counts.negative < 1) {
+            errors.push(`${skillId}: need at least 1 negative trigger case (have ${counts.negative})`);
+        }
+    }
+    return errors;
+}
+/** Run deterministic trigger routing eval (offline skill-pi-trigger-eval counterpart). */
+export function runTriggerEval(options = {}) {
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const casesPath = options.casesPath ?? resolve(projectRoot, TRIGGER_CASES_REL);
+    const indexPath = options.indexPath ?? resolve(projectRoot, SKILLS_INDEX_REL);
+    let cases;
+    if (options.cases !== undefined) {
+        cases = [...options.cases];
+    }
+    else {
+        const loaded = loadTriggerCases(casesPath);
+        if ("error" in loaded) {
+            return { code: 2, report: null, message: `eval:triggers: ${loaded.error}` };
+        }
+        cases = loaded;
+    }
+    let indexText;
+    if (options.indexText !== undefined) {
+        indexText = options.indexText;
+    }
+    else if (!existsSync(indexPath)) {
+        return { code: 2, report: null, message: `eval:triggers: missing ${SKILLS_INDEX_REL}` };
+    }
+    else {
+        indexText = readFileSync(indexPath, "utf8");
+    }
+    const index = parseSkillsIndex(indexText);
+    if (index.length === 0) {
+        return {
+            code: 2,
+            report: null,
+            message: `eval:triggers: no Skills Index rows parsed from ${SKILLS_INDEX_REL}`,
+        };
+    }
+    const coverageErrors = validateTriggerCoverage(cases, index);
+    const results = [];
+    for (const row of cases) {
+        const winner = resolveTriggerWinner(row.query, index);
+        const actual = wouldRouteToSkill(row.query, row.skill, index);
+        results.push({
+            id: row.id,
+            query: row.query,
+            skill: row.skill,
+            should_trigger: row.should_trigger,
+            actual,
+            pass: actual === row.should_trigger,
+            matchedTrigger: winner?.trigger,
+            winnerSkill: winner?.skillId,
+        });
+    }
+    const passed = results.filter((result) => result.pass).length;
+    const failed = results.length - passed;
+    const report = {
+        total: results.length,
+        passed,
+        failed,
+        pass_rate: results.length > 0 ? passed / results.length : null,
+        results,
+        coverageErrors,
+    };
+    if (coverageErrors.length > 0) {
+        const detail = coverageErrors.map((err) => `   - ${sanitizeTriggerLogLine(err)}`).join("\n");
+        return {
+            code: 1,
+            report,
+            message: `eval:triggers: trigger coverage incomplete\n${detail}`,
+        };
+    }
+    if (failed > 0) {
+        const detail = results
+            .filter((result) => !result.pass)
+            .slice(0, 8)
+            .map((result) => `   - ${sanitizeTriggerLogLine(result.id)}: expected ${result.should_trigger ? "trigger" : "no-trigger"} ` +
+            `for ${sanitizeTriggerLogLine(result.skill)}; winner=${sanitizeTriggerLogLine(result.winnerSkill ?? "none")}`)
+            .join("\n");
+        return {
+            code: 1,
+            report,
+            message: `eval:triggers: ${failed}/${results.length} trigger cases failed ` +
+                `(offline skill-pi-trigger-eval routing against ${SKILLS_INDEX_REL})\n${detail}`,
+        };
+    }
+    return {
+        code: 0,
+        report,
+        message: `eval:triggers: ${passed}/${results.length} trigger cases passed ` +
+            `(offline skill-pi-trigger-eval routing against ${SKILLS_INDEX_REL})`,
+    };
+}
+//# sourceMappingURL=triggers.js.map

package/dist/eval-triggers-relocation/evaluate.d.ts

@@ -0,0 +1,36 @@
+export type OutputStream = "stdout" | "stderr" | "none";
+/** Glob patterns that classify a change as skill-routing / trigger eval relevant (#1586). */
+export declare const TRIGGER_ROUTING_PATH_PATTERNS: readonly ["AGENTS.md", "REFERENCES.md", "evals/trigger-cases.jsonl", "content/templates/agents-entry.md", "packages/core/src/eval/triggers.ts"];
+export interface EvaluateResult {
+    readonly code: 0 | 1 | 2;
+    readonly message: string;
+    readonly stream: OutputStream;
+    readonly skipped?: boolean;
+}
+export interface EvaluateOptions {
+    readonly projectRoot?: string;
+    readonly baseRef?: string;
+    readonly staged?: boolean;
+    readonly paths?: readonly string[];
+    readonly quiet?: boolean;
+}
+/** True when *path* matches a trigger-routing home. */
+export declare function isTriggerRoutingPath(path: string): boolean;
+/** Classify a path list for trigger-routing coverage. */
+export declare function classifyTriggerRoutingPaths(paths: readonly string[]): {
+    readonly isTriggerRouting: boolean;
+    readonly matchedPaths: readonly string[];
+};
+/** Collect changed paths from git (base ref or staged index). */
+export declare function collectChangedPaths(projectRoot: string, options: {
+    baseRef?: string;
+    staged?: boolean;
+}): string[] | {
+    error: string;
+};
+/**
+ * Conditional gate: run eval:triggers when AGENTS.md / REFERENCES.md / trigger
+ * cases change (#1586). Skips (exit 0) when the diff does not touch routing homes.
+ */
+export declare function evaluate(options?: EvaluateOptions): EvaluateResult;
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/eval-triggers-relocation/evaluate.js

@@ -0,0 +1,115 @@
+import { execFileSync } from "node:child_process";
+import { resolve } from "node:path";
+import { runTriggerEval } from "../eval/triggers.js";
+import { matchAny } from "../orchestration/pathspec.js";
+/** Glob patterns that classify a change as skill-routing / trigger eval relevant (#1586). */
+export const TRIGGER_ROUTING_PATH_PATTERNS = [
+    "AGENTS.md",
+    "REFERENCES.md",
+    "evals/trigger-cases.jsonl",
+    "content/templates/agents-entry.md",
+    "packages/core/src/eval/triggers.ts",
+];
+/** True when *path* matches a trigger-routing home. */
+export function isTriggerRoutingPath(path) {
+    return matchAny(TRIGGER_ROUTING_PATH_PATTERNS, path);
+}
+/** Classify a path list for trigger-routing coverage. */
+export function classifyTriggerRoutingPaths(paths) {
+    const matchedPaths = paths.filter(isTriggerRoutingPath);
+    return { isTriggerRouting: matchedPaths.length > 0, matchedPaths };
+}
+function gitNameOnlyDiff(projectRoot, args) {
+    try {
+        const stdout = execFileSync("git", ["-C", projectRoot, "diff", "--name-only", ...args], {
+            encoding: "utf8",
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        return stdout
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+    }
+    catch (err) {
+        return { error: String(err) };
+    }
+}
+/** Collect changed paths from git (base ref or staged index). */
+export function collectChangedPaths(projectRoot, options) {
+    if (options.staged) {
+        return gitNameOnlyDiff(projectRoot, ["--cached"]);
+    }
+    if (options.baseRef !== undefined && options.baseRef.length > 0) {
+        return gitNameOnlyDiff(projectRoot, [options.baseRef, "HEAD"]);
+    }
+    return [];
+}
+function formatSkipMessage() {
+    return ("✓ verify:eval-triggers-relocation: no trigger-routing paths in diff " +
+        `(checked ${TRIGGER_ROUTING_PATH_PATTERNS.length} patterns).`);
+}
+function formatPassMessage(matchedPaths, summary) {
+    return (`✓ verify:eval-triggers-relocation: eval:triggers OK ` +
+        `(routing paths: ${matchedPaths.join(", ")}; ${summary}).`);
+}
+/**
+ * Conditional gate: run eval:triggers when AGENTS.md / REFERENCES.md / trigger
+ * cases change (#1586). Skips (exit 0) when the diff does not touch routing homes.
+ */
+export function evaluate(options = {}) {
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const quiet = options.quiet ?? false;
+    let paths;
+    if (options.paths !== undefined) {
+        paths = [...options.paths];
+    }
+    else if (options.baseRef !== undefined || options.staged) {
+        const collected = collectChangedPaths(projectRoot, {
+            baseRef: options.baseRef,
+            staged: options.staged,
+        });
+        if ("error" in collected) {
+            return {
+                code: 2,
+                message: "❌ verify:eval-triggers-relocation: could not read git diff " +
+                    `(project_root=${projectRoot}): ${collected.error}`,
+                stream: "stderr",
+            };
+        }
+        paths = collected;
+    }
+    else {
+        return { code: 0, message: "", stream: "none", skipped: true };
+    }
+    const { isTriggerRouting, matchedPaths } = classifyTriggerRoutingPaths(paths);
+    if (!isTriggerRouting) {
+        if (quiet) {
+            return { code: 0, message: "", stream: "none", skipped: true };
+        }
+        return {
+            code: 0,
+            message: formatSkipMessage(),
+            stream: "stdout",
+            skipped: true,
+        };
+    }
+    const evalResult = runTriggerEval({ projectRoot });
+    if (evalResult.code !== 0) {
+        return {
+            code: evalResult.code,
+            message: `❌ verify:eval-triggers-relocation: eval:triggers failed on trigger-routing PR (#1586).\n` +
+                `   Matched routing paths: ${matchedPaths.join(", ")}\n` +
+                `   ${evalResult.message.replace(/\n/g, "\n   ")}`,
+            stream: "stderr",
+        };
+    }
+    if (quiet) {
+        return { code: 0, message: "", stream: "none" };
+    }
+    return {
+        code: 0,
+        message: formatPassMessage(matchedPaths, evalResult.message),
+        stream: "stdout",
+    };
+}
+//# sourceMappingURL=evaluate.js.map

package/dist/eval-triggers-relocation/index.d.ts

@@ -0,0 +1,2 @@
+export { classifyTriggerRoutingPaths, collectChangedPaths, type EvaluateOptions, type EvaluateResult, evaluate, isTriggerRoutingPath, type OutputStream, TRIGGER_ROUTING_PATH_PATTERNS, } from "./evaluate.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/eval-triggers-relocation/index.js

@@ -0,0 +1,2 @@
+export { classifyTriggerRoutingPaths, collectChangedPaths, evaluate, isTriggerRoutingPath, TRIGGER_ROUTING_PATH_PATTERNS, } from "./evaluate.js";
+//# sourceMappingURL=index.js.map

package/dist/hooks/dispatcher.d.ts

@@ -0,0 +1,43 @@
+import { type VerifyResult } from "../session/verify-session-ritual.js";
+import { type ActiveScopeInspection } from "./scope.js";
+export { DIRECT_WRITE_TOOL_NAMES, isDirectWriteTool } from "./tools.js";
+export declare const HOOK_HOSTS: readonly ["claude", "grok", "cursor", "codex"];
+export type HookHost = (typeof HOOK_HOSTS)[number];
+export declare const HOOK_EVENTS: readonly ["session.start", "tool.before"];
+export type HookEvent = (typeof HOOK_EVENTS)[number];
+export type HookVerdict = "allow" | "deny";
+export type HookDecisionCode = "session-start" | "session-start-degraded" | "not-direct-write" | "invalid-input" | "ritual-not-ready" | "scope-not-ready" | "write-ready";
+export interface HookDecision {
+    readonly verdict: HookVerdict;
+    readonly code: HookDecisionCode;
+    readonly event: HookEvent;
+    readonly host: HookHost;
+    readonly toolName: string | null;
+    readonly projectRoot: string;
+    readonly message: string;
+    readonly scopePath: string | null;
+}
+export interface HookDispatchInput {
+    readonly host: HookHost;
+    readonly event: HookEvent;
+    readonly projectRoot: string;
+    readonly payload: unknown;
+}
+export interface HookPolicySeams {
+    readonly inspectRitual?: (projectRoot: string) => VerifyResult;
+    readonly inspectScope?: (projectRoot: string) => ActiveScopeInspection;
+    readonly sessionStart?: (projectRoot: string) => {
+        code: number;
+        stdout: string;
+        stderr: string;
+    };
+}
+export declare function hookToolName(payload: unknown): string | null;
+export declare function projectRootFromHookPayload(payload: unknown, fallback: string): string;
+export declare function isHookHost(value: string): value is HookHost;
+export declare function isHookEvent(value: string): value is HookEvent;
+/** Decide a normalized event using only the P0 direct-write policy. */
+export declare function decideHook(input: HookDispatchInput, seams?: HookPolicySeams): HookDecision;
+/** Render only authoritative denials; allow preserves the host's own permission flow. */
+export declare function renderHostDecision(host: HookHost, decision: HookDecision): string;
+//# sourceMappingURL=dispatcher.d.ts.map

package/dist/hooks/dispatcher.js

@@ -0,0 +1,173 @@
+import { resolve } from "node:path";
+import { runSessionStartHookWrite } from "../session/session-start-hook.js";
+import { inspectSessionRitual } from "../session/verify-session-ritual.js";
+import { inspectActiveScope } from "./scope.js";
+import { isDirectWriteTool } from "./tools.js";
+export { DIRECT_WRITE_TOOL_NAMES, isDirectWriteTool } from "./tools.js";
+export const HOOK_HOSTS = ["claude", "grok", "cursor", "codex"];
+export const HOOK_EVENTS = ["session.start", "tool.before"];
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim().length > 0)
+            return value.trim();
+    }
+    return null;
+}
+export function hookToolName(payload) {
+    const input = record(payload);
+    if (input === null)
+        return null;
+    return firstString(input.tool_name, input.toolName, input.tool);
+}
+export function projectRootFromHookPayload(payload, fallback) {
+    const input = record(payload);
+    if (input === null)
+        return resolve(fallback);
+    const workspaceRoots = input.workspace_roots;
+    const root = firstString(input.workspaceRoot, input.workspace_root, Array.isArray(workspaceRoots) ? workspaceRoots[0] : null, input.cwd, fallback);
+    return resolve(root ?? fallback);
+}
+export function isHookHost(value) {
+    return HOOK_HOSTS.includes(value);
+}
+export function isHookEvent(value) {
+    return HOOK_EVENTS.includes(value);
+}
+function deny(input, code, toolName, message) {
+    return {
+        verdict: "deny",
+        code,
+        event: input.event,
+        host: input.host,
+        toolName,
+        projectRoot: resolve(input.projectRoot),
+        message,
+        scopePath: null,
+    };
+}
+/** Decide a normalized event using only the P0 direct-write policy. */
+export function decideHook(input, seams = {}) {
+    const projectRoot = resolve(input.projectRoot);
+    if (input.event === "session.start") {
+        try {
+            const result = (seams.sessionStart ?? runSessionStartHookWrite)(projectRoot);
+            if (result.code !== 0) {
+                const detail = (result.stderr || result.stdout).trim().replace(/\s+/g, " ").slice(0, 400);
+                return {
+                    verdict: "allow",
+                    code: "session-start-degraded",
+                    event: input.event,
+                    host: input.host,
+                    toolName: null,
+                    projectRoot,
+                    message: `Directive SessionStart bookkeeping reported exit ${result.code} on its non-blocking path` +
+                        `${detail.length > 0 ? `: ${detail}` : "."}`,
+                    scopePath: null,
+                };
+            }
+        }
+        catch (cause) {
+            return {
+                verdict: "allow",
+                code: "session-start-degraded",
+                event: input.event,
+                host: input.host,
+                toolName: null,
+                projectRoot,
+                message: `Directive SessionStart bookkeeping failed on its non-blocking path: ${String(cause)}`,
+                scopePath: null,
+            };
+        }
+        return {
+            verdict: "allow",
+            code: "session-start",
+            event: input.event,
+            host: input.host,
+            toolName: null,
+            projectRoot,
+            message: "SessionStart bookkeeping completed on a non-blocking path.",
+            scopePath: null,
+        };
+    }
+    const toolName = hookToolName(input.payload);
+    if (toolName === null) {
+        return deny(input, "invalid-input", null, "Directive denied this matched write event because the host payload omitted its tool name.");
+    }
+    if (!isDirectWriteTool(toolName)) {
+        return {
+            verdict: "allow",
+            code: "not-direct-write",
+            event: input.event,
+            host: input.host,
+            toolName,
+            projectRoot,
+            message: `${toolName} is outside the P0 direct-write enforcement slice.`,
+            scopePath: null,
+        };
+    }
+    let ritual;
+    try {
+        ritual = (seams.inspectRitual ??
+            ((root) => inspectSessionRitual(root, { tier: "gated", posture: "mutation" })))(projectRoot);
+    }
+    catch (cause) {
+        return deny(input, "ritual-not-ready", toolName, `Directive could not inspect the gated session ritual: ${String(cause)}. ` +
+            "Run `deft session:start`, then `deft verify:session-ritual -- --tier=gated`.");
+    }
+    if (ritual.code !== 0) {
+        return deny(input, "ritual-not-ready", toolName, `Directive denied ${toolName}: ${ritual.message} ` +
+            "Recovery: run `deft session:start`, then " +
+            "`deft verify:session-ritual -- --tier=gated`.");
+    }
+    let scope;
+    try {
+        scope = (seams.inspectScope ?? inspectActiveScope)(projectRoot);
+    }
+    catch (cause) {
+        scope = { ready: false, path: null, message: String(cause) };
+    }
+    if (!scope.ready) {
+        return deny(input, "scope-not-ready", toolName, `Directive denied ${toolName}: ${scope.message} ` +
+            "Recovery: run `deft scope:activate -- <path>` for the approved xBRIEF.");
+    }
+    return {
+        verdict: "allow",
+        code: "write-ready",
+        event: input.event,
+        host: input.host,
+        toolName,
+        projectRoot,
+        message: `Directive write gate passed for ${toolName}.`,
+        scopePath: scope.path,
+    };
+}
+/** Render only authoritative denials; allow preserves the host's own permission flow. */
+export function renderHostDecision(host, decision) {
+    if (decision.verdict === "allow")
+        return "";
+    switch (host) {
+        case "claude":
+        case "codex":
+            return JSON.stringify({
+                hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    permissionDecision: "deny",
+                    permissionDecisionReason: decision.message,
+                },
+            });
+        case "grok":
+            return JSON.stringify({ decision: "deny", reason: decision.message });
+        case "cursor":
+            return JSON.stringify({
+                permission: "deny",
+                user_message: decision.message,
+                agent_message: decision.message,
+            });
+    }
+}
+//# sourceMappingURL=dispatcher.js.map

package/dist/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./dispatcher.js";
+export * from "./scope.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.js

@@ -0,0 +1,3 @@
+export * from "./dispatcher.js";
+export * from "./scope.js";
+//# sourceMappingURL=index.js.map

package/dist/hooks/scope.d.ts

@@ -0,0 +1,12 @@
+export interface ActiveScopeInspection {
+    readonly ready: boolean;
+    readonly path: string | null;
+    readonly message: string;
+}
+/**
+ * Find an implementation-eligible scope by delegating every candidate to the
+ * existing xBRIEF preflight evaluator. This intentionally creates no second
+ * lifecycle/status policy stack.
+ */
+export declare function inspectActiveScope(projectRoot: string): ActiveScopeInspection;
+//# sourceMappingURL=scope.d.ts.map