@deftai/directive-core 0.77.0 → 0.78.0

package/dist/doctor/main.d.ts

@@ -2,6 +2,7 @@ import { type ResolutionFacts } from "../resolution/index.js";
 import { createPlainSink } from "./output.js";
 import type { DoctorSeams, Finding, ResolutionSummary } from "./types.js";
 export declare function cmdDoctor(args: readonly string[], seams?: DoctorSeams): number;
+export declare function runAgentHooksHealthCheck(projectRoot: string, consumerContext: boolean, sink: ReturnType<typeof createPlainSink>, addFinding: (finding: Finding) => void, seams: DoctorSeams): void;
 /**
  * Never emit a bare `task ...` remediation in a project without Taskfile wiring
  * (#2267). The `directive` surface always works; `task deft:X` is optional and

package/dist/doctor/main.js

@@ -6,6 +6,7 @@ import { describeShadowedPlanExtension, detectShadowedPlanExtensions, } from "..
 import { loadProjectDefinition } from "../policy/resolve.js";
 import { checkLocalEngineIntegrity, classify, detectPackageManager, evaluateSkew, reconcileVersions, plan as resolvePlan, } from "../resolution/index.js";
 import { resolveUserMdPath } from "../user-config/resolve-user-md.js";
+import { evaluateAgentHooks } from "../verify-env/agent-hooks.js";
 import { agentsRefreshPlan, hasV3ManagedMarker } from "./agents-md.js";
 import { runChecks } from "./checks.js";
 import { CONSUMER_FRAMEWORK_DIRS, EXPECTED_CONTENT_DIRS, EXPECTED_FRAMEWORK_DIRS, NETWORK_DISCLOSURE_LINE, PAYLOAD_STALENESS_OFFLINE_SKIP_MESSAGE, TASKFILE_INCLUDE_SNIPPET, UV_INSTALL_URL, } from "./constants.js";
@@ -162,6 +163,11 @@ export function cmdDoctor(args, seams = {}) {
     if (!jsonMode) {
         sink.blank();
     }
+    sink.info("Checking agent-host hook registration...");
+    runAgentHooksHealthCheck(projectRoot, consumerContext, sink, addFinding, seams);
+    if (!jsonMode) {
+        sink.blank();
+    }
     // #2182: payload-staleness is the only doctor check that can reach a
     // registry (git verifies the pin; npm compares stable release availability).
     // It stays in the OFFLINE
@@ -332,6 +338,37 @@ export function cmdDoctor(args, seams = {}) {
     sink.finalWarn(`System check completed with ${warningCount} warning(s).`);
     return 0;
 }
+export function runAgentHooksHealthCheck(projectRoot, consumerContext, sink, addFinding, seams) {
+    const checkName = "agent-hooks-registration";
+    if (!consumerContext) {
+        const reason = "maintainer source checkout; project hook deposit is consumer-only";
+        sink.info(`${checkName}: skip -- ${reason}`);
+        addFinding({ severity: "skip", message: reason, check: checkName, status: "skip" });
+        return;
+    }
+    try {
+        const result = (seams.evaluateAgentHooks ?? evaluateAgentHooks)(projectRoot);
+        if (result.code === 0) {
+            sink.success(`${checkName}: healthy`);
+            return;
+        }
+        const message = `${checkName}: ${result.message.replace(/\s+/g, " ").trim()}`;
+        sink.warn(message);
+        addFinding({
+            severity: "warning",
+            message,
+            check: checkName,
+            status: result.code === 2 ? "unavailable" : "non-functional",
+            registrations: result.registrations,
+            suggestion: "deft update",
+        });
+    }
+    catch (cause) {
+        const message = `${checkName}: probe failed -- ${String(cause)}`;
+        sink.warn(message);
+        addFinding({ severity: "warning", message, check: checkName, suggestion: "deft update" });
+    }
+}
 function runInstallIntegrityChecks(projectRoot, sink, addFinding, seams) {
     if (runningInsideDeftRepo(projectRoot, seams)) {
         sink.info("Skipping install-integrity checks -- running inside the deft framework repo (no install manifest in the source checkout).");

package/dist/doctor/types.d.ts

@@ -3,6 +3,7 @@ import type { ShadowedPlanExtension } from "../policy/plan-extensions.js";
 import type { EngineProbeResult } from "../resolution/classify.js";
 import type { ResolutionMode } from "../resolution/index.js";
 import type { ResolveUserMdResult } from "../user-config/resolve-user-md.js";
+import type { AgentHookHealthResult } from "../verify-env/agent-hooks.js";
 export declare const EXIT_CLEAN = 0;
 export declare const EXIT_DRIFT = 1;
 export declare const EXIT_CONFIG_ERROR = 2;
@@ -135,5 +136,7 @@ export interface DoctorSeams {
      * its `plan` object; returns [] when no project definition is present.
      */
     readonly detectPlanExtensionShadows?: (projectRoot: string) => readonly ShadowedPlanExtension[];
+    /** Read-only agent-host hook registration probe (#2438). */
+    readonly evaluateAgentHooks?: (projectRoot: string) => AgentHookHealthResult;
 }
 //# sourceMappingURL=types.d.ts.map

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