@deftai/directive-core 0.85.0 → 0.87.0

package/dist/triage/queue/show.js

@@ -0,0 +1,293 @@
+/**
+ * triage:show default + operator brief renderers (#1128 / #2890).
+ *
+ * Default format mirrors the pre-Python-removal `render_show` surface.
+ * `--format=operator` emits a pasteable Phase 3 candidate brief backbone;
+ * the agent still owns lean (not invented here).
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { CACHE_DIR_NAME, CACHE_SOURCE_GITHUB_ISSUE } from "./constants.js";
+function parseLabels(raw) {
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    const labels = [];
+    for (const item of raw) {
+        if (typeof item === "object" && item !== null) {
+            const name = item.name;
+            if (typeof name === "string") {
+                labels.push(name);
+            }
+        }
+        else if (typeof item === "string") {
+            labels.push(item);
+        }
+    }
+    return labels;
+}
+/** Collapse CR/LF so cached attacker text cannot break markdown bullets (P2). */
+export function oneLine(value) {
+    return value.replace(/\r?\n/gu, " ").trim();
+}
+/**
+ * Resolve a safe issue link. Always construct the canonical github.com path for
+ * `owner/name#N` rather than trusting payload URL substrings (CodeQL
+ * incomplete-url-substring-sanitization).
+ */
+export function resolveIssueHtmlUrl(repo, number) {
+    return `https://github.com/${repo}/issues/${number}`;
+}
+/** Load a single cached issue (include closed) or null on miss. */
+export function loadCachedIssueDetail(repo, number, options = {
+    projectRoot: process.cwd(),
+}) {
+    if (!repo.includes("/")) {
+        throw new Error(`repo must be 'owner/name'; got '${repo}'`);
+    }
+    const parts = repo.split("/", 2);
+    const owner = parts[0];
+    const name = parts[1];
+    if (owner === undefined || name === undefined || owner.length === 0 || name.length === 0) {
+        throw new Error(`repo must be 'owner/name'; got '${repo}'`);
+    }
+    const source = options.source ?? CACHE_SOURCE_GITHUB_ISSUE;
+    const cacheBase = options.cacheRoot !== null && options.cacheRoot !== undefined && options.cacheRoot.length > 0
+        ? resolve(options.cacheRoot)
+        : join(resolve(options.projectRoot), CACHE_DIR_NAME);
+    const entryDir = join(cacheBase, source, owner, name, String(number));
+    const rawPath = join(entryDir, "raw.json");
+    if (!existsSync(rawPath)) {
+        return null;
+    }
+    let payload;
+    try {
+        const parsed = JSON.parse(readFileSync(rawPath, { encoding: "utf8" }));
+        if (typeof parsed !== "object" || parsed === null) {
+            return null;
+        }
+        payload = parsed;
+    }
+    catch {
+        return null;
+    }
+    const n = typeof payload.number === "number" ? payload.number : number;
+    const stateRaw = payload.state ?? "open";
+    const state = typeof stateRaw === "string" ? stateRaw.toLowerCase() : "open";
+    const title = typeof payload.title === "string" ? payload.title : "";
+    const body = typeof payload.body === "string" ? payload.body : "";
+    const updatedAt = typeof payload.updated_at === "string"
+        ? payload.updated_at
+        : typeof payload.updatedAt === "string"
+            ? payload.updatedAt
+            : "";
+    return {
+        number: n,
+        title,
+        state,
+        labels: parseLabels(payload.labels),
+        updatedAt,
+        body,
+        htmlUrl: resolveIssueHtmlUrl(repo, n),
+    };
+}
+/** Default triage:show text (audit/cache oriented). */
+export function renderShow(options) {
+    const lines = [];
+    lines.push(`triage:show -- ${options.repo}#${options.number}`);
+    if (options.issue === null) {
+        lines.push("");
+        lines.push("  (issue not present in local cache)");
+        lines.push("  Run `task triage:bootstrap` to populate, or check the repo slug.");
+        return lines.join("\n");
+    }
+    const labels = options.issue.labels.map(oneLine);
+    lines.push(`  title:      ${oneLine(options.issue.title)}`);
+    lines.push(`  state:      ${oneLine(options.issue.state)}`);
+    lines.push(`  labels:     ${labels.length > 0 ? labels.join(", ") : "<none>"}`);
+    lines.push(`  updated_at: ${oneLine(options.issue.updatedAt)}`);
+    lines.push("");
+    lines.push(`  active xBRIEF reference: ${options.inActiveXbrief ? "yes" : "no"}`);
+    if (options.latestDecision !== null) {
+        const d = options.latestDecision;
+        lines.push(`  latest decision: ${oneLine(String(d.decision ?? "?"))} at ${oneLine(String(d.timestamp ?? "?"))} by ${oneLine(String(d.actor ?? "?"))}`);
+        if (typeof d.reason === "string" && d.reason.length > 0) {
+            lines.push(`    reason: ${oneLine(d.reason)}`);
+        }
+    }
+    else {
+        lines.push("  latest decision: <none -- untriaged>");
+    }
+    if (options.history.length > 0) {
+        lines.push("");
+        lines.push(`  history (${options.history.length} entries, oldest first):`);
+        for (const entry of options.history) {
+            const decision = oneLine(String(entry.decision ?? "?")).padEnd(14);
+            lines.push(`    - ${oneLine(String(entry.timestamp ?? "?"))} ${decision} by ${oneLine(String(entry.actor ?? "?"))}`);
+        }
+    }
+    return lines.join("\n");
+}
+/** Collapse blank lines and trim for summary extraction. */
+function normalizeBody(body) {
+    return body.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+}
+/**
+ * Extract a short problem/context summary (2–5 lines) from issue body.
+ * Prefers text before the first `##` section; falls back to leading paragraphs.
+ */
+export function extractBodySummary(body, maxLines = 5) {
+    const text = normalizeBody(body);
+    if (text.length === 0) {
+        return "(thin body / no summary)";
+    }
+    // Drop leading H1/title lines
+    let rest = text.replace(/^#[^\n]*\n+/u, "");
+    // Prefer content before first ## heading (often Summary/Description)
+    const firstSection = rest.search(/^##\s+/mu);
+    if (firstSection > 0) {
+        rest = rest.slice(0, firstSection).trim();
+    }
+    else if (firstSection === 0) {
+        // Body starts with ## — take the first section body
+        const next = rest.search(/\n##\s+/u);
+        const block = next === -1 ? rest : rest.slice(0, next);
+        rest = block.replace(/^##[^\n]*\n?/u, "").trim();
+    }
+    const paragraphs = rest
+        .split(/\n{2,}/u)
+        .map((p) => p.replace(/\s+/gu, " ").trim())
+        .filter((p) => p.length > 0 && !p.startsWith("#"));
+    if (paragraphs.length === 0) {
+        const lines = rest
+            .split("\n")
+            .map((l) => l.trim())
+            .filter((l) => l.length > 0 && !l.startsWith("#"));
+        if (lines.length === 0) {
+            return "(thin body / no summary)";
+        }
+        return lines.slice(0, maxLines).join("\n");
+    }
+    const out = [];
+    for (const para of paragraphs) {
+        if (out.length >= maxLines)
+            break;
+        // Soft-wrap long paragraphs into ~100-char lines for pasteability
+        if (para.length <= 120) {
+            out.push(para);
+        }
+        else {
+            const words = para.split(/\s+/u);
+            let line = "";
+            for (const w of words) {
+                const next = line.length === 0 ? w : `${line} ${w}`;
+                if (next.length > 100 && line.length > 0) {
+                    out.push(line);
+                    line = w;
+                    if (out.length >= maxLines)
+                        break;
+                }
+                else {
+                    line = next;
+                }
+            }
+            if (line.length > 0 && out.length < maxLines) {
+                out.push(line);
+            }
+        }
+    }
+    return out.slice(0, maxLines).join("\n");
+}
+/**
+ * Extract acceptance-criteria bullets from body, or a thin-body note.
+ * Looks for AC / Acceptance headings and checkbox / bullet lists under them.
+ */
+export function extractAcceptanceCriteria(body) {
+    const text = normalizeBody(body);
+    if (text.length === 0) {
+        return [];
+    }
+    const headingRe = /^#{1,3}\s*(?:acceptance\s*criteria|acceptance|ac\b|success\s*criteria)[^\n]*$/imu;
+    const match = headingRe.exec(text);
+    if (match === null || match.index === undefined) {
+        // Loose: checkbox list near top without a heading
+        const loose = [];
+        for (const line of text.split("\n")) {
+            const m = /^\s*[-*]\s*\[[ xX]\]\s+(.+)$/u.exec(line);
+            if (m?.[1] !== undefined) {
+                loose.push(m[1].trim());
+            }
+        }
+        return loose.slice(0, 12);
+    }
+    const after = text.slice(match.index + match[0].length);
+    // Stop only at a next ## (H2) peer section — keep ### subsections (A/B/C…) inside AC.
+    const nextPeer = after.search(/\n##\s+\S/u);
+    const section = nextPeer === -1 ? after : after.slice(0, nextPeer);
+    const bullets = [];
+    for (const line of section.split("\n")) {
+        const checkbox = /^\s*[-*]\s*\[[ xX]\]\s+(.+)$/u.exec(line);
+        if (checkbox?.[1] !== undefined) {
+            bullets.push(checkbox[1].trim());
+            continue;
+        }
+        // Prefer checkboxes under AC; plain bullets are also accepted
+        const bullet = /^\s*[-*]\s+(.+)$/u.exec(line);
+        if (bullet?.[1] !== undefined) {
+            // Skip nested subsection-only markers that are just headings-as-bullets
+            bullets.push(bullet[1].trim());
+            continue;
+        }
+        const numbered = /^\s*\d+[.)]\s+(.+)$/u.exec(line);
+        if (numbered?.[1] !== undefined) {
+            bullets.push(numbered[1].trim());
+        }
+    }
+    return bullets.slice(0, 12);
+}
+/** Operator-facing pasteable brief backbone for Phase 3 decisions (#2890). */
+export function renderOperatorBrief(options) {
+    const lines = [];
+    lines.push(`triage:show --format=operator -- ${options.repo}#${options.number}`);
+    if (options.issue === null) {
+        lines.push("");
+        lines.push("  (issue not present in local cache)");
+        lines.push("  Run `task triage:bootstrap` / re-sync per Phase 0, or check the repo slug.");
+        return lines.join("\n");
+    }
+    const issue = options.issue;
+    const link = issue.htmlUrl ?? resolveIssueHtmlUrl(options.repo, options.number);
+    const labels = issue.labels.length > 0 ? issue.labels.map(oneLine).join(", ") : "<none>";
+    lines.push(`#${options.number}  ${oneLine(issue.title)}`);
+    lines.push(`link:    ${oneLine(link)}`);
+    lines.push(`labels:  ${labels}`);
+    lines.push("");
+    lines.push("summary:");
+    for (const line of extractBodySummary(issue.body).split("\n")) {
+        lines.push(`  ${oneLine(line)}`);
+    }
+    lines.push("");
+    const ac = extractAcceptanceCriteria(issue.body);
+    if (ac.length === 0) {
+        lines.push("acceptance criteria: (thin body / no AC)");
+    }
+    else {
+        lines.push("acceptance criteria:");
+        for (const item of ac) {
+            lines.push(`  - ${oneLine(item)}`);
+        }
+    }
+    lines.push("");
+    if (options.latestDecision !== null) {
+        const d = options.latestDecision;
+        lines.push(`latest decision: ${oneLine(String(d.decision ?? "?"))} at ${oneLine(String(d.timestamp ?? "?"))} by ${oneLine(String(d.actor ?? "?"))}`);
+    }
+    else {
+        lines.push("latest decision: <none -- untriaged>");
+    }
+    lines.push(`active xBRIEF: ${options.inActiveXbrief ? "yes" : "no"}`);
+    lines.push("");
+    lines.push("lean: (agent-owned — not filled by triage:show)");
+    return lines.join("\n");
+}
+//# sourceMappingURL=show.js.map

package/dist/triage/scope/cli.js

@@ -232,9 +232,12 @@ export function runCliCapture(argv) {
             cacheRoot: args.cacheRoot !== undefined ? resolve(args.cacheRoot) : undefined,
         });
         const subHash = subscriptionHash(rules);
+        // When --cache-root is outside the project tree, contain against that root
+        // instead of projectRoot (tests and operators may redirect the cache) (#2869).
         const record = writeCoverageDenominator(path, {
             count: args.count,
             subscriptionHashValue: subHash,
+            projectRoot: args.cacheRoot !== undefined ? resolve(args.cacheRoot) : projectRoot,
         });
         stdout.push(`triage:scope: wrote coverage denominator count=${record.count} ` +
             `subscription-hash=${record.subscriptionHash} path=${path}\n`);

package/dist/triage/scope/coverage.d.ts

@@ -14,6 +14,8 @@ export declare function writeCoverageDenominator(path: string, options: {
     count: number;
     subscriptionHashValue: string;
     fetchedAt?: Date;
+    /** Project (or cache) root for symlink containment (#2869). */
+    projectRoot?: string;
 }): CoverageRecord;
 export declare function readCoverageDenominator(path: string, options: {
     currentHash: string;

package/dist/triage/scope/coverage.js

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
+import { assertWriteTargetSafe } from "../../fs/projection-containment.js";
 import { CACHE_DIR_NAME, COVERAGE_FILENAME, DEFAULT_COVERAGE_TTL_HOURS, ENV_COVERAGE_TTL_HOURS, } from "./constants.js";
 import { parseIso, utcIso, utcNow } from "./time.js";
 export function coveragePath(source, repo, options = {}) {
@@ -29,14 +30,28 @@ export function writeCoverageDenominator(path, options) {
     if (!options.subscriptionHashValue) {
         throw new Error("subscription_hash_value must be a non-empty string");
     }
+    const absPath = resolve(path);
+    // Production CLI always passes projectRoot. When omitted (unit tests with a
+    // bare cacheRoot), walk up to the deepest existing ancestor so containment
+    // can realpath the root before mkdir creates intermediate dirs (#2869).
+    let containmentRoot = options.projectRoot !== undefined ? resolve(options.projectRoot) : dirname(absPath);
+    if (options.projectRoot === undefined) {
+        while (!existsSync(containmentRoot)) {
+            const parent = dirname(containmentRoot);
+            if (parent === containmentRoot)
+                break;
+            containmentRoot = parent;
+        }
+    }
+    assertWriteTargetSafe(containmentRoot, absPath);
     const stamp = utcIso(options.fetchedAt ?? null);
-    mkdirSync(join(path, ".."), { recursive: true });
+    mkdirSync(dirname(absPath), { recursive: true });
     const payload = {
         count: options.count,
         fetched_at: stamp,
         subscription_hash: options.subscriptionHashValue,
     };
-    writeFileSync(path, `${JSON.stringify(payload, Object.keys(payload).sort())}\n`, "utf8");
+    writeFileSync(absPath, `${JSON.stringify(payload, Object.keys(payload).sort())}\n`, "utf8");
     return {
         count: options.count,
         fetchedAt: stamp,

package/dist/verify-env/agent-hooks-live-probe.d.ts

@@ -0,0 +1,32 @@
+import type { HookEvent, HookHost } from "../hooks/dispatcher.js";
+export type AgentHookLiveProbeIssue = "hook-command-missing" | "spawn-failed" | "empty-stdout" | "unparseable-json" | "missing-allow" | "missing-deny";
+export interface AgentHookLiveProbeCase {
+    readonly host: HookHost;
+    readonly event: HookEvent;
+    readonly fixture: "allow" | "deny";
+    readonly issue: AgentHookLiveProbeIssue;
+    readonly detail: string;
+}
+export interface AgentHookLiveProbeResult {
+    readonly code: 0 | 1 | 2;
+    readonly message: string;
+    readonly cases: readonly AgentHookLiveProbeCase[];
+}
+export interface AgentHookLiveProbeSeams {
+    readonly resolveCommand?: (name: string) => string | null;
+    readonly spawnHook?: (input: {
+        readonly command: string;
+        readonly args: readonly string[];
+        readonly stdin: string;
+        readonly cwd: string;
+        readonly env?: NodeJS.ProcessEnv;
+    }) => {
+        readonly status: number;
+        readonly stdout: string;
+        readonly stderr: string;
+    };
+}
+export declare function quoteWindowsCmdArg(value: string): string;
+/** Spawn the configured hook command and assert Cursor tool.before allow/deny behavior. */
+export declare function probeAgentHooksLive(projectRoot: string, seams?: AgentHookLiveProbeSeams): AgentHookLiveProbeResult;
+//# sourceMappingURL=agent-hooks-live-probe.d.ts.map

package/dist/verify-env/agent-hooks-live-probe.js

@@ -0,0 +1,216 @@
+import { spawnSync } from "node:child_process";
+import { resolve } from "node:path";
+import { READ_ONLY_HOOK_ENV } from "../hooks/tools.js";
+import { DEFT_HOOK_COMMAND_MARKER } from "../init-deposit/agent-hooks.js";
+import { SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
+import { quoteWin32CommandForShell, resolveCommandOnPath, shouldUseShellForCommand, } from "./command-spawn.js";
+const LIVE_PROBE_HOST = "cursor";
+const LIVE_PROBE_EVENT = "tool.before";
+function resolveHookCommand(seams) {
+    const resolveCommand = seams.resolveCommand ?? resolveCommandOnPath;
+    const deftHook = resolveCommand(DEFT_HOOK_COMMAND_MARKER);
+    if (deftHook !== null) {
+        return { command: deftHook, argsPrefix: [] };
+    }
+    const deft = resolveCommand("deft");
+    if (deft !== null) {
+        return { command: deft, argsPrefix: ["hook:dispatch"] };
+    }
+    const directive = resolveCommand("directive");
+    if (directive !== null) {
+        return { command: directive, argsPrefix: ["hook:dispatch"] };
+    }
+    return null;
+}
+export function quoteWindowsCmdArg(value) {
+    const escaped = value.replace(/%/g, "%%");
+    if (!/[\s"&|<>^()]/.test(escaped)) {
+        return escaped;
+    }
+    return `"${escaped.replace(/"/g, '""')}"`;
+}
+function spawnHookWithStdin(command, args, stdin, cwd, env = process.env) {
+    const shell = shouldUseShellForCommand(command);
+    if (shell && process.platform === "win32") {
+        const cmdLine = [quoteWin32CommandForShell(command), ...args.map(quoteWindowsCmdArg)].join(" ");
+        const proc = spawnSync(cmdLine, [], {
+            input: stdin,
+            cwd,
+            env,
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"],
+            shell: true,
+            windowsHide: true,
+            maxBuffer: SUBPROCESS_MAX_BUFFER,
+        });
+        const status = proc.status ?? (proc.error ? 2 : proc.signal ? 128 : 0);
+        return {
+            status,
+            stdout: typeof proc.stdout === "string" ? proc.stdout : "",
+            stderr: typeof proc.stderr === "string" ? proc.stderr : "",
+        };
+    }
+    const spawnCmd = shell && process.platform === "win32" ? quoteWin32CommandForShell(command) : command;
+    const proc = spawnSync(spawnCmd, [...args], {
+        input: stdin,
+        cwd,
+        env,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        shell,
+        windowsHide: true,
+        maxBuffer: SUBPROCESS_MAX_BUFFER,
+    });
+    const status = proc.status ?? (proc.error ? 2 : proc.signal ? 128 : 0);
+    return {
+        status,
+        stdout: typeof proc.stdout === "string" ? proc.stdout : "",
+        stderr: typeof proc.stderr === "string" ? proc.stderr : "",
+    };
+}
+function allowFixture(projectRoot) {
+    return JSON.stringify({
+        tool_name: "Read",
+        cwd: projectRoot,
+        workspace_roots: [projectRoot],
+    });
+}
+function denyFixture(projectRoot) {
+    return JSON.stringify({
+        tool_name: "Task",
+        cwd: projectRoot,
+        workspace_roots: [projectRoot],
+        tool_input: { subagent_type: "generalPurpose", prompt: "implement" },
+    });
+}
+function denyProbeEnv() {
+    return { ...process.env, [READ_ONLY_HOOK_ENV]: "1" };
+}
+function parseCursorDecision(stdout) {
+    const trimmed = stdout.trim();
+    if (trimmed.length === 0) {
+        return { ok: false, detail: "empty stdout" };
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed !== null &&
+            typeof parsed === "object" &&
+            !Array.isArray(parsed) &&
+            parsed.permission === "allow") {
+            return { ok: true, permission: "allow", detail: "permission allow" };
+        }
+        if (parsed !== null &&
+            typeof parsed === "object" &&
+            !Array.isArray(parsed) &&
+            parsed.permission === "deny") {
+            return { ok: true, permission: "deny", detail: "permission deny" };
+        }
+        return { ok: false, detail: "stdout JSON missing permission allow/deny" };
+    }
+    catch {
+        return { ok: false, detail: "stdout is not valid JSON" };
+    }
+}
+function runFixtureProbe(resolved, projectRoot, fixture, stdin, env, spawnHook) {
+    const args = [
+        ...resolved.argsPrefix,
+        "--host",
+        LIVE_PROBE_HOST,
+        "--event",
+        LIVE_PROBE_EVENT,
+        "--project-root",
+        projectRoot,
+    ];
+    const spawned = spawnHook({
+        command: resolved.command,
+        args,
+        stdin,
+        cwd: projectRoot,
+        env,
+    });
+    if (spawned.status !== 0) {
+        return {
+            host: LIVE_PROBE_HOST,
+            event: LIVE_PROBE_EVENT,
+            fixture,
+            issue: "spawn-failed",
+            detail: `hook command exited ${spawned.status}${spawned.stderr.trim() ? `: ${spawned.stderr.trim()}` : ""}`,
+        };
+    }
+    const decision = parseCursorDecision(spawned.stdout);
+    if (!decision.ok) {
+        return {
+            host: LIVE_PROBE_HOST,
+            event: LIVE_PROBE_EVENT,
+            fixture,
+            issue: decision.detail.includes("JSON") ? "unparseable-json" : "empty-stdout",
+            detail: decision.detail,
+        };
+    }
+    if (fixture === "allow" && decision.permission !== "allow") {
+        return {
+            host: LIVE_PROBE_HOST,
+            event: LIVE_PROBE_EVENT,
+            fixture,
+            issue: "missing-allow",
+            detail: `expected permission allow, got ${decision.permission ?? "none"}`,
+        };
+    }
+    if (fixture === "deny" && decision.permission !== "deny") {
+        return {
+            host: LIVE_PROBE_HOST,
+            event: LIVE_PROBE_EVENT,
+            fixture,
+            issue: "missing-deny",
+            detail: `expected permission deny, got ${decision.permission ?? "none"}`,
+        };
+    }
+    return null;
+}
+/** Spawn the configured hook command and assert Cursor tool.before allow/deny behavior. */
+export function probeAgentHooksLive(projectRoot, seams = {}) {
+    const root = resolve(projectRoot);
+    const resolved = resolveHookCommand(seams);
+    if (resolved === null) {
+        return {
+            code: 2,
+            message: "deft agent hooks live probe unavailable: neither deft-hook nor deft/directive hook:dispatch is on PATH.",
+            cases: [
+                {
+                    host: LIVE_PROBE_HOST,
+                    event: LIVE_PROBE_EVENT,
+                    fixture: "allow",
+                    issue: "hook-command-missing",
+                    detail: `${DEFT_HOOK_COMMAND_MARKER} not found on PATH`,
+                },
+            ],
+        };
+    }
+    const spawnHook = seams.spawnHook ??
+        ((input) => spawnHookWithStdin(input.command, input.args, input.stdin, input.cwd, input.env ?? process.env));
+    const failures = [];
+    for (const [fixture, stdin, env] of [
+        ["allow", allowFixture(root), process.env],
+        ["deny", denyFixture(root), denyProbeEnv()],
+    ]) {
+        const failure = runFixtureProbe(resolved, root, fixture, stdin, env, spawnHook);
+        if (failure !== null)
+            failures.push(failure);
+    }
+    if (failures.length === 0) {
+        return {
+            code: 0,
+            message: "deft agent hooks live probe passed for Cursor tool.before allow and deny fixtures.",
+            cases: [],
+        };
+    }
+    const summary = failures
+        .map((entry) => `${entry.fixture}: ${entry.issue} (${entry.detail})`)
+        .join("; ");
+    return {
+        code: 1,
+        message: `deft agent hooks live probe FAILED: ${summary}. Recovery: reinstall @deftai/directive and run \`deft update\`.`,
+        cases: failures,
+    };
+}
+//# sourceMappingURL=agent-hooks-live-probe.js.map

package/dist/verify-env/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./agent-hooks.js";
+export * from "./agent-hooks-live-probe.js";
 export * from "./command-spawn.js";
 export * from "./node-runtime.js";
 export * from "./toolchain-check.js";

package/dist/verify-env/index.js

@@ -1,4 +1,5 @@
 export * from "./agent-hooks.js";
+export * from "./agent-hooks-live-probe.js";
 export * from "./command-spawn.js";
 export * from "./node-runtime.js";
 export * from "./toolchain-check.js";

package/dist/verify-source/index.d.ts

@@ -3,6 +3,7 @@ export * from "./code-structure-validate.js";
 export * from "./content-manifest.js";
 export { CANONICAL_SCHEMA_REL, type ContractDriftOptions, type ContractDriftResult, evaluateContractDrift, PUBLISHED_SCHEMA_REL, } from "./contract-drift.js";
 export * from "./cursor-tier1.js";
+export * from "./openclaw-tier1.js";
 export * from "./python-call-scan.js";
 export * from "./rule-ownership-lint.js";
 export * from "./scm-boundary.js";

package/dist/verify-source/index.js

@@ -3,6 +3,7 @@ export * from "./code-structure-validate.js";
 export * from "./content-manifest.js";
 export { CANONICAL_SCHEMA_REL, evaluateContractDrift, PUBLISHED_SCHEMA_REL, } from "./contract-drift.js";
 export * from "./cursor-tier1.js";
+export * from "./openclaw-tier1.js";
 export * from "./python-call-scan.js";
 export * from "./rule-ownership-lint.js";
 export * from "./scm-boundary.js";

package/dist/verify-source/openclaw-tier1.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Deterministic gate: assert that OpenClaw is enumerated as a Tier-1 descriptor
+ * in the swarm Phase 3 capability matrix and that routing accepts openclaw as a
+ * dispatch_provider (#2875). Without this gate the "OpenClaw -> Tier 1" mapping
+ * is prose-trusted; a doc edit that drops the sessions_spawn descriptor would
+ * silently re-open misclassification (OpenClaw falling through to grok-build or
+ * generic-terminal).
+ *
+ * Review-cycle skill markers for OpenClaw Approach 1 are owned by sibling #2876
+ * and are intentionally out of scope for this gate.
+ */
+export interface OpenclawTier1Target {
+    /** Project-root-relative path to the surface file. */
+    readonly path: string;
+    /** Human label for the surface, used in failure output. */
+    readonly label: string;
+    /** Whitespace-normalized substrings that MUST all be present. */
+    readonly markers: readonly string[];
+}
+export declare const OPENCLAW_TIER1_TARGETS: readonly OpenclawTier1Target[];
+export interface OpenclawTier1Finding {
+    readonly path: string;
+    readonly label: string;
+    readonly missingMarkers: readonly string[];
+}
+export interface OpenclawTier1Result {
+    readonly code: 0 | 1 | 2;
+    readonly findings: readonly OpenclawTier1Finding[];
+    readonly message: string;
+    readonly stream: "stdout" | "stderr";
+}
+export interface OpenclawTier1Options {
+    readonly targets?: readonly OpenclawTier1Target[];
+    readonly quiet?: boolean;
+}
+export declare function evaluateOpenclawTier1(projectRoot: string, options?: OpenclawTier1Options): OpenclawTier1Result;
+//# sourceMappingURL=openclaw-tier1.d.ts.map