@deftai/directive-core 0.76.0 → 0.78.0

package/dist/eval/health.js

@@ -3,7 +3,8 @@ import { dirname, resolve } from "node:path";
 import { agentsRefreshPlan } from "../doctor/agents-md.js";
 import { evaluate as evaluateEncoding } from "../encoding/evaluate.js";
 import { readCorePackageVersion } from "../engine-version.js";
-import { resolveEvalPath, resolveProjectDefinitionPath } from "../layout/resolve.js";
+import { resolveProjectDefinitionPath } from "../layout/resolve.js";
+import { healthMetricsHistoryPath } from "../metrics/resolve-metrics-home.js";
 import { readPlanPolicy } from "../policy/plan-extensions.js";
 import { classifyOnboarding, detectPriorState } from "../triage/welcome/prior-state.js";
 import { validateLinks } from "../validate-content/index.js";
@@ -11,7 +12,8 @@ import { evaluateConformance } from "../vbrief-validate/conformance.js";
 import { validateWipCapOnPlan } from "../vbrief-validate/plan-hooks.js";
 import { evaluateContentManifest } from "../verify-source/content-manifest.js";
 export const HEALTH_SCHEMA_VERSION = 1;
-export const HEALTH_HISTORY_REL = "results/health-history.jsonl";
+/** Relative path under the resolved metrics home for eval:health history (#2545). */
+export const HEALTH_HISTORY_REL = "health/health-history.jsonl";
 function sanitizeOneLine(value) {
     return value.replace(/\r?\n/g, " ");
 }
@@ -99,9 +101,9 @@ function probeContentManifest(projectRoot) {
         detail: result.code === 0 ? undefined : result.message.split("\n")[0],
     };
 }
-/** Absolute path to the versioned health history ledger. */
+/** Absolute path to the versioned health history ledger (#2545). */
 export function healthHistoryPath(projectRoot) {
-    return resolveEvalPath(projectRoot, HEALTH_HISTORY_REL);
+    return healthMetricsHistoryPath(projectRoot);
 }
 /** Detect the canonical wipCap unsatisfiable-nudge contradiction (#1694). */
 export function detectWipCapUnsatisfiableNudge(projectRoot) {
@@ -154,9 +156,12 @@ export function computeHealthScore(gates, contradictions) {
     const penalty = contradictions.length * 15;
     return Math.max(0, base - penalty);
 }
-/** Append one health run to the versioned ledger (#1703 Tier 0). */
+/** Append one health run to the versioned ledger (#1703 Tier 0 / #2545). */
 export function persistHealthRun(projectRoot, report) {
     const path = healthHistoryPath(projectRoot);
+    if (path === null) {
+        return;
+    }
     mkdirSync(dirname(path), { recursive: true });
     appendFileSync(path, `${JSON.stringify(report)}\n`, "utf8");
 }
@@ -223,17 +228,20 @@ export function evaluateHealth(options = {}) {
         contradictions,
     };
     if (persist) {
-        try {
-            persistHealthRun(projectRoot, report);
-        }
-        catch (err) {
-            const persistError = `eval:health: failed to persist health history: ${String(err)}`;
-            const healthy = score === 100 && contradictions.length === 0;
-            return {
-                code: healthy ? 0 : 1,
-                report,
-                message: `${formatHumanReport(report)}\n${persistError}`,
-            };
+        const ledgerPath = healthHistoryPath(projectRoot);
+        if (ledgerPath !== null) {
+            try {
+                persistHealthRun(projectRoot, report);
+            }
+            catch (err) {
+                const persistError = `eval:health: failed to persist health history: ${String(err)}`;
+                const healthy = score === 100 && contradictions.length === 0;
+                return {
+                    code: healthy ? 0 : 1,
+                    report,
+                    message: `${formatHumanReport(report)}\n${persistError}`,
+                };
+            }
         }
     }
     const healthy = score === 100 && contradictions.length === 0;

package/dist/eval/readback.js

@@ -28,14 +28,8 @@ function parseJsonObjectOrNull(text) {
     return null;
 }
 function readHealthHistoryRows(projectRoot) {
-    let path;
-    try {
-        path = healthHistoryPath(projectRoot);
-    }
-    catch {
-        return []; // No xbrief/ layout; no health history.
-    }
-    if (!existsSync(path)) {
+    const path = healthHistoryPath(projectRoot);
+    if (path === null || !existsSync(path)) {
         return [];
     }
     let text;

package/dist/eval/triggers.d.ts

@@ -0,0 +1,76 @@
+/** Relative path to skill-pi-trigger-eval compatible case rows (#1586). */
+export declare const TRIGGER_CASES_REL = "evals/trigger-cases.jsonl";
+/** Default Skills Index source for AGENTS.md skill routing (#1586). */
+export declare const SKILLS_INDEX_REL = "REFERENCES.md";
+/** Parsed Skills Index row. */
+export interface SkillsIndexEntry {
+    readonly skillId: string;
+    readonly triggers: readonly string[];
+}
+/** One row in evals/trigger-cases.jsonl (skill-pi-trigger-eval eval-set + skill id). */
+export interface TriggerCaseRow {
+    readonly id: string;
+    readonly query: string;
+    readonly skill: string;
+    readonly should_trigger: boolean;
+}
+/** Outcome for a single trigger case. */
+export interface TriggerCaseResult {
+    readonly id: string;
+    readonly query: string;
+    readonly skill: string;
+    readonly should_trigger: boolean;
+    readonly actual: boolean;
+    readonly pass: boolean;
+    readonly matchedTrigger?: string;
+    readonly winnerSkill?: string;
+}
+/** Aggregate eval:triggers report. */
+export interface TriggerEvalReport {
+    readonly total: number;
+    readonly passed: number;
+    readonly failed: number;
+    readonly pass_rate: number | null;
+    readonly results: readonly TriggerCaseResult[];
+    readonly coverageErrors: readonly string[];
+}
+export interface RunTriggerEvalOptions {
+    readonly projectRoot?: string;
+    readonly casesPath?: string;
+    readonly indexPath?: string;
+    readonly cases?: readonly TriggerCaseRow[];
+    readonly indexText?: string;
+}
+export interface RunTriggerEvalResult {
+    readonly code: 0 | 1 | 2;
+    readonly report: TriggerEvalReport | null;
+    readonly message: string;
+}
+/** Normalize user text for deterministic substring trigger matching. */
+export declare function normalizeTriggerText(text: string): string;
+/** Collapse embedded newlines before interpolating user/data into log lines. */
+export declare function sanitizeTriggerLogLine(text: string): string;
+/** Extract backtick trigger phrases from a Skills Index triggers cell. */
+export declare function parseTriggerCell(cell: string): string[];
+/** Parse the Skills Index markdown table in REFERENCES.md. */
+export declare function parseSkillsIndex(markdown: string): SkillsIndexEntry[];
+interface TriggerMatch {
+    readonly skillId: string;
+    readonly trigger: string;
+}
+/** Find the winning skill for a query using longest-trigger-wins disambiguation. */
+export declare function resolveTriggerWinner(query: string, index: readonly SkillsIndexEntry[]): TriggerMatch | null;
+/** True when the Skills Index routing would send *query* to *skillId*. */
+export declare function wouldRouteToSkill(query: string, skillId: string, index: readonly SkillsIndexEntry[]): boolean;
+/** Validate one JSONL row against the skill-pi-trigger-eval row contract. */
+export declare function parseTriggerCaseRow(raw: unknown, lineNumber: number): TriggerCaseRow | string;
+/** Load evals/trigger-cases.jsonl. */
+export declare function loadTriggerCases(path: string): TriggerCaseRow[] | {
+    error: string;
+};
+/** Verify at least two positive and one negative case per indexed skill. */
+export declare function validateTriggerCoverage(cases: readonly TriggerCaseRow[], index: readonly SkillsIndexEntry[]): string[];
+/** Run deterministic trigger routing eval (offline skill-pi-trigger-eval counterpart). */
+export declare function runTriggerEval(options?: RunTriggerEvalOptions): RunTriggerEvalResult;
+export {};
+//# sourceMappingURL=triggers.d.ts.map

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"];
+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