@deftai/directive-core 0.88.0 → 0.89.0

package/dist/finish-loop/queue.js

@@ -0,0 +1,65 @@
+/**
+ * Scope queue scan for directive:finish-loop (#871).
+ * Lists xbrief/active + xbrief/pending (and legacy vbrief/) story files.
+ * Implementation work is agent-owned; this is the gate's empty-queue detector.
+ */
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+const LIFECYCLE_DIRS = [
+    ["xbrief", "active"],
+    ["xbrief", "pending"],
+    ["vbrief", "active"],
+    ["vbrief", "pending"],
+];
+function isStoryFile(name) {
+    const lower = name.toLowerCase();
+    return (lower.endsWith(".xbrief.json") ||
+        lower.endsWith(".vbrief.json") ||
+        (lower.endsWith(".json") && (lower.includes("xbrief") || lower.includes("vbrief"))));
+}
+/**
+ * Scan project root for in-flight / pending story xBRIEFs.
+ * Does not invent work — empty means the outer loop may halt cleanly.
+ */
+export function scanFinishLoopQueue(projectRoot) {
+    const out = [];
+    const seen = new Set();
+    for (const [rootName, lifecycle] of LIFECYCLE_DIRS) {
+        const dir = join(projectRoot, rootName, lifecycle);
+        if (!existsSync(dir))
+            continue;
+        let names;
+        try {
+            names = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            if (!isStoryFile(name))
+                continue;
+            // Skip PROJECT-DEFINITION and similar non-story files in wrong folders
+            if (name.toUpperCase().includes("PROJECT-DEFINITION"))
+                continue;
+            const full = join(dir, name);
+            try {
+                if (!statSync(full).isFile())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const key = full.replace(/\\/g, "/").toLowerCase();
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({
+                path: full,
+                lifecycle: lifecycle,
+                name,
+            });
+        }
+    }
+    return out.sort((a, b) => a.path.localeCompare(b.path));
+}
+//# sourceMappingURL=queue.js.map

package/dist/finish-loop/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Walk-away finish-loop types (#871 Wave 5 / #2948).
+ */
+import type { AuthzDecisionCode } from "../authz/types.js";
+/** Three-state + blocked exit codes for finish-loop surfaces. */
+export declare const EXIT_OK = 0;
+/** NEW_P0_P1 / address-needed / agent step required (non-terminal product halt). */
+export declare const EXIT_ACTION_REQUIRED = 1;
+/** BLOCKED (grant/gate), ERRORED, TIMEOUT, config. */
+export declare const EXIT_BLOCKED = 2;
+export type FinishLoopHaltReason = "empty-queue" | "grant-missing" | "grant-expired" | "grant-deny" | "gate-deny" | "max-iterations" | "require-human-merge" | "address-findings" | "agent-implement" | "clean" | "merged" | "error";
+export type FinishLoopPhase = "gate" | "queue-scan" | "implement" | "pr-open" | "pr-watch" | "address" | "merge" | "halt";
+export interface FinishLoopProgressLine {
+    readonly schemaVersion: 1;
+    readonly ts: string;
+    readonly phase: FinishLoopPhase;
+    readonly iteration: number;
+    readonly haltReason: FinishLoopHaltReason | null;
+    readonly message: string;
+    readonly prNumber: number | null;
+    readonly grantId: string | null;
+    readonly queueCount: number | null;
+    readonly exitCode: number | null;
+    readonly extra?: Readonly<Record<string, unknown>>;
+}
+export interface FinishLoopGrantGateResult {
+    readonly allowed: boolean;
+    readonly code: AuthzDecisionCode | "finish-loop-env-bypass" | "finish-loop-allow";
+    readonly reason: string;
+    readonly grantId: string | null;
+    readonly missingOps: readonly string[];
+}
+export interface PrFinishLoopResult {
+    readonly exitCode: number;
+    readonly haltReason: FinishLoopHaltReason;
+    readonly message: string;
+    readonly prNumber: number;
+    readonly watchVerdict: string | null;
+    readonly mergeAttempted: boolean;
+    readonly mergeSkippedReason: string | null;
+    readonly grantId: string | null;
+}
+export interface DirectiveFinishLoopResult {
+    readonly exitCode: number;
+    readonly haltReason: FinishLoopHaltReason;
+    readonly message: string;
+    readonly iterations: number;
+    readonly queueCount: number;
+    readonly grantId: string | null;
+    readonly progressPath: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/finish-loop/types.js

@@ -0,0 +1,10 @@
+/**
+ * Walk-away finish-loop types (#871 Wave 5 / #2948).
+ */
+/** Three-state + blocked exit codes for finish-loop surfaces. */
+export const EXIT_OK = 0;
+/** NEW_P0_P1 / address-needed / agent step required (non-terminal product halt). */
+export const EXIT_ACTION_REQUIRED = 1;
+/** BLOCKED (grant/gate), ERRORED, TIMEOUT, config. */
+export const EXIT_BLOCKED = 2;
+//# sourceMappingURL=types.js.map

package/dist/fs/contained-write.d.ts

@@ -0,0 +1,101 @@
+/**
+ * contained-write.ts — mandatory contained-write API for product sinks (#2951 Phase 1).
+ *
+ * Single primitive that resolves a path under an explicit root, refuses symlink
+ * escape / out-of-root targets (via {@link assertWriteTargetSafe}), then writes
+ * with an explicit mode: create | replace | append.
+ *
+ * Hard rules:
+ * - Final write target must resolve **inside** `root` after normalization.
+ * - Symlink escape (or leaf symlink on the write path) → fail closed with a
+ *   stable error code.
+ * - No silent fallback to raw write on failure.
+ *
+ * Prefer this API for all new product write sinks. Prefer migrating call sites
+ * onto this API over bespoke per-sink checks when equivalent. See
+ * `docs/reference/contained-write.md`.
+ *
+ * Refs #2951.
+ */
+/** Stable machine-readable error codes for contained-write refusals. */
+export declare const ContainedWriteErrorCode: {
+    /** Target path escapes the containment root (`..` or absolute outside root). */
+    readonly ESCAPE: "CONTAINED_WRITE_ESCAPE";
+    /** Target or intermediate path is a symlink (leaf or escaping). */
+    readonly SYMLINK: "CONTAINED_WRITE_SYMLINK";
+    /** `mode: "create"` but the target already exists. */
+    readonly EXISTS: "CONTAINED_WRITE_EXISTS";
+    /** `mode: "append"` or replace semantics need an existing file that is missing (reserved). */
+    readonly NOT_FOUND: "CONTAINED_WRITE_NOT_FOUND";
+    /** Containment root does not exist or cannot be realpath'd. */
+    readonly ROOT_MISSING: "CONTAINED_WRITE_ROOT_MISSING";
+    /** Caller passed an unsupported mode value. */
+    readonly INVALID_MODE: "CONTAINED_WRITE_INVALID_MODE";
+    /** Underlying filesystem I/O failure after containment passed. */
+    readonly IO: "CONTAINED_WRITE_IO";
+};
+export type ContainedWriteErrorCode = (typeof ContainedWriteErrorCode)[keyof typeof ContainedWriteErrorCode];
+/** Explicit write modes for {@link containedWrite}. */
+export type ContainedWriteMode = "create" | "replace" | "append";
+/** Thrown when a contained write is refused or fails after containment. */
+export declare class ContainedWriteError extends Error {
+    readonly code: ContainedWriteErrorCode;
+    readonly root: string;
+    readonly target: string;
+    readonly offendingPath: string;
+    constructor(message: string, details: {
+        code: ContainedWriteErrorCode;
+        root: string;
+        target: string;
+        offendingPath?: string;
+    });
+}
+export interface ContainedWriteInput {
+    /** Absolute containment root (project root, deposit root, or sandbox). */
+    readonly root: string;
+    /**
+     * Write target. Relative paths are resolved under `root`. Absolute paths
+     * must stay under `root` after normalization.
+     */
+    readonly target: string;
+    /** Bytes or UTF-8 string payload. */
+    readonly data: string | Buffer;
+    /** create = fail if exists; replace = truncate/write; append = append. */
+    readonly mode: ContainedWriteMode;
+    /**
+     * Encoding when `data` is a string. Default `"utf8"`.
+     * Ignored when `data` is a Buffer.
+     */
+    readonly encoding?: BufferEncoding;
+    /**
+     * Create parent directories under `root` when missing. Default `true`.
+     * Parents are still subject to containment (no escape via mkdir).
+     */
+    readonly mkdir?: boolean;
+    /**
+     * When true, follow symlinks that resolve inside root (not recommended).
+     * Default `false` — leaf and path-component symlinks are refused via
+     * {@link assertWriteTargetSafe}.
+     */
+    readonly followSymlinks?: boolean;
+}
+export interface ContainedWriteResult {
+    /** Absolute path written. */
+    readonly path: string;
+    /** Number of bytes written in this call (not total file size for append). */
+    readonly bytesWritten: number;
+    readonly mode: ContainedWriteMode;
+}
+/**
+ * Resolve `target` under `root`. Relative targets join root; absolute targets
+ * must already be nested under root (path-segment containment).
+ */
+export declare function resolveContainedTarget(root: string, target: string): string;
+/**
+ * Contained write: resolve under root, refuse symlink escape / out-of-root,
+ * then write with the requested mode.
+ *
+ * @throws {ContainedWriteError} on containment refusal or mode violation
+ */
+export declare function containedWrite(input: ContainedWriteInput): ContainedWriteResult;
+//# sourceMappingURL=contained-write.d.ts.map

package/dist/fs/contained-write.js

@@ -0,0 +1,281 @@
+/**
+ * contained-write.ts — mandatory contained-write API for product sinks (#2951 Phase 1).
+ *
+ * Single primitive that resolves a path under an explicit root, refuses symlink
+ * escape / out-of-root targets (via {@link assertWriteTargetSafe}), then writes
+ * with an explicit mode: create | replace | append.
+ *
+ * Hard rules:
+ * - Final write target must resolve **inside** `root` after normalization.
+ * - Symlink escape (or leaf symlink on the write path) → fail closed with a
+ *   stable error code.
+ * - No silent fallback to raw write on failure.
+ *
+ * Prefer this API for all new product write sinks. Prefer migrating call sites
+ * onto this API over bespoke per-sink checks when equivalent. See
+ * `docs/reference/contained-write.md`.
+ *
+ * Refs #2951.
+ */
+import { closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, realpathSync, writeSync, } from "node:fs";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { assertWriteTargetSafe, ProjectionContainmentError } from "./projection-containment.js";
+/** Stable machine-readable error codes for contained-write refusals. */
+export const ContainedWriteErrorCode = {
+    /** Target path escapes the containment root (`..` or absolute outside root). */
+    ESCAPE: "CONTAINED_WRITE_ESCAPE",
+    /** Target or intermediate path is a symlink (leaf or escaping). */
+    SYMLINK: "CONTAINED_WRITE_SYMLINK",
+    /** `mode: "create"` but the target already exists. */
+    EXISTS: "CONTAINED_WRITE_EXISTS",
+    /** `mode: "append"` or replace semantics need an existing file that is missing (reserved). */
+    NOT_FOUND: "CONTAINED_WRITE_NOT_FOUND",
+    /** Containment root does not exist or cannot be realpath'd. */
+    ROOT_MISSING: "CONTAINED_WRITE_ROOT_MISSING",
+    /** Caller passed an unsupported mode value. */
+    INVALID_MODE: "CONTAINED_WRITE_INVALID_MODE",
+    /** Underlying filesystem I/O failure after containment passed. */
+    IO: "CONTAINED_WRITE_IO",
+};
+/** Thrown when a contained write is refused or fails after containment. */
+export class ContainedWriteError extends Error {
+    code;
+    root;
+    target;
+    offendingPath;
+    constructor(message, details) {
+        super(message);
+        this.name = "ContainedWriteError";
+        this.code = details.code;
+        this.root = details.root;
+        this.target = details.target;
+        this.offendingPath = details.offendingPath ?? details.target;
+    }
+}
+const VALID_MODES = new Set(["create", "replace", "append"]);
+/**
+ * Resolve `target` under `root`. Relative targets join root; absolute targets
+ * must already be nested under root (path-segment containment).
+ */
+export function resolveContainedTarget(root, target) {
+    const rootAbs = resolve(root);
+    if (target.length === 0) {
+        throw new ContainedWriteError("contained write refused: empty target path", {
+            code: ContainedWriteErrorCode.ESCAPE,
+            root: rootAbs,
+            target: "",
+            offendingPath: rootAbs,
+        });
+    }
+    const targetAbs = isAbsolute(target) ? resolve(target) : resolve(rootAbs, target);
+    const rel = relative(rootAbs, targetAbs);
+    if (rel.length === 0 || rel.startsWith("..") || isAbsolute(rel)) {
+        throw new ContainedWriteError(`contained write refused: target ${targetAbs} is not nested under root ${rootAbs}`, {
+            code: ContainedWriteErrorCode.ESCAPE,
+            root: rootAbs,
+            target: targetAbs,
+            offendingPath: targetAbs,
+        });
+    }
+    return targetAbs;
+}
+function mapProjectionError(err, rootAbs, targetAbs) {
+    const msg = err.message;
+    const isSymlink = /symlink/i.test(msg) ||
+        /broken\/dangling symlink/i.test(msg) ||
+        /is a symlink on the write path/i.test(msg);
+    return new ContainedWriteError(msg.replace(/^projection write refused:/i, "contained write refused:"), {
+        code: isSymlink ? ContainedWriteErrorCode.SYMLINK : ContainedWriteErrorCode.ESCAPE,
+        root: rootAbs,
+        target: targetAbs,
+        offendingPath: err.offendingPath,
+    });
+}
+function ensureParents(rootAbs, targetAbs) {
+    const parent = dirname(targetAbs);
+    if (parent === targetAbs || parent === rootAbs) {
+        return;
+    }
+    // Contain parent before mkdir (mkdir recursive must not create outside root).
+    const rel = relative(rootAbs, parent);
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+        throw new ContainedWriteError(`contained write refused: parent ${parent} is not nested under root ${rootAbs}`, {
+            code: ContainedWriteErrorCode.ESCAPE,
+            root: rootAbs,
+            target: targetAbs,
+            offendingPath: parent,
+        });
+    }
+    if (!existsSync(parent)) {
+        try {
+            assertWriteTargetSafe(rootAbs, parent);
+        }
+        catch (err) {
+            if (err instanceof ProjectionContainmentError) {
+                throw mapProjectionError(err, rootAbs, targetAbs);
+            }
+            throw err;
+        }
+        mkdirSync(parent, { recursive: true });
+    }
+    else {
+        try {
+            assertWriteTargetSafe(rootAbs, parent);
+        }
+        catch (err) {
+            if (err instanceof ProjectionContainmentError) {
+                throw mapProjectionError(err, rootAbs, targetAbs);
+            }
+            throw err;
+        }
+    }
+}
+function toBuffer(data, encoding) {
+    return Buffer.isBuffer(data) ? data : Buffer.from(data, encoding);
+}
+function writeNoFollow(targetAbs, buf, flags) {
+    const fd = openSync(targetAbs, flags, 0o644);
+    try {
+        let offset = 0;
+        while (offset < buf.length) {
+            const n = writeSync(fd, buf, offset, buf.length - offset, null);
+            if (n <= 0) {
+                throw new Error(`short write: wrote ${offset} of ${buf.length} bytes to ${targetAbs}`);
+            }
+            offset += n;
+        }
+        return offset;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/**
+ * Contained write: resolve under root, refuse symlink escape / out-of-root,
+ * then write with the requested mode.
+ *
+ * @throws {ContainedWriteError} on containment refusal or mode violation
+ */
+export function containedWrite(input) {
+    if (!VALID_MODES.has(input.mode)) {
+        throw new ContainedWriteError(`contained write refused: invalid mode ${String(input.mode)} (expected create|replace|append)`, {
+            code: ContainedWriteErrorCode.INVALID_MODE,
+            root: resolve(input.root),
+            target: String(input.target),
+        });
+    }
+    if (input.followSymlinks === true) {
+        throw new ContainedWriteError("contained write refused: followSymlinks=true is not supported in Phase 1 (always refuse symlinks)", {
+            code: ContainedWriteErrorCode.INVALID_MODE,
+            root: resolve(input.root),
+            target: String(input.target),
+        });
+    }
+    const rootAbs = resolve(input.root);
+    try {
+        realpathSync(rootAbs);
+    }
+    catch {
+        throw new ContainedWriteError(`contained write refused: root ${rootAbs} does not exist`, {
+            code: ContainedWriteErrorCode.ROOT_MISSING,
+            root: rootAbs,
+            target: String(input.target),
+            offendingPath: rootAbs,
+        });
+    }
+    const targetAbs = resolveContainedTarget(rootAbs, input.target);
+    try {
+        assertWriteTargetSafe(rootAbs, targetAbs);
+    }
+    catch (err) {
+        if (err instanceof ProjectionContainmentError) {
+            throw mapProjectionError(err, rootAbs, targetAbs);
+        }
+        throw err;
+    }
+    const doMkdir = input.mkdir !== false;
+    if (doMkdir) {
+        ensureParents(rootAbs, targetAbs);
+    }
+    // Re-check after mkdir (parent path could have been created as unexpected type).
+    try {
+        assertWriteTargetSafe(rootAbs, targetAbs);
+    }
+    catch (err) {
+        if (err instanceof ProjectionContainmentError) {
+            throw mapProjectionError(err, rootAbs, targetAbs);
+        }
+        throw err;
+    }
+    const encoding = input.encoding ?? "utf8";
+    const buf = toBuffer(input.data, encoding);
+    let exists = false;
+    try {
+        lstatSync(targetAbs);
+        exists = true;
+    }
+    catch {
+        exists = false;
+    }
+    if (input.mode === "create" && exists) {
+        throw new ContainedWriteError(`contained write refused: target ${targetAbs} already exists (mode=create)`, {
+            code: ContainedWriteErrorCode.EXISTS,
+            root: rootAbs,
+            target: targetAbs,
+            offendingPath: targetAbs,
+        });
+    }
+    try {
+        let bytesWritten;
+        if (input.mode === "append") {
+            bytesWritten = writeNoFollow(targetAbs, buf, constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | constants.O_NOFOLLOW);
+        }
+        else if (input.mode === "create") {
+            // O_EXCL refuses replace-if-exists; O_NOFOLLOW refuses symlink leaf.
+            bytesWritten = writeNoFollow(targetAbs, buf, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW);
+        }
+        else {
+            // replace
+            bytesWritten = writeNoFollow(targetAbs, buf, constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | constants.O_NOFOLLOW);
+        }
+        return { path: targetAbs, bytesWritten, mode: input.mode };
+    }
+    catch (err) {
+        if (err instanceof ContainedWriteError) {
+            throw err;
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        // EEXIST from O_EXCL
+        if (typeof err === "object" &&
+            err !== null &&
+            "code" in err &&
+            err.code === "EEXIST") {
+            throw new ContainedWriteError(`contained write refused: target ${targetAbs} already exists (mode=create)`, {
+                code: ContainedWriteErrorCode.EXISTS,
+                root: rootAbs,
+                target: targetAbs,
+                offendingPath: targetAbs,
+            });
+        }
+        // ELOOP / EMLINK style symlink refusals from O_NOFOLLOW
+        if (typeof err === "object" &&
+            err !== null &&
+            "code" in err &&
+            (err.code === "ELOOP" ||
+                err.code === "EPERM")) {
+            throw new ContainedWriteError(`contained write refused: ${targetAbs} is a symlink on the write path (O_NOFOLLOW)`, {
+                code: ContainedWriteErrorCode.SYMLINK,
+                root: rootAbs,
+                target: targetAbs,
+                offendingPath: targetAbs,
+            });
+        }
+        throw new ContainedWriteError(`contained write I/O failed: ${msg}`, {
+            code: ContainedWriteErrorCode.IO,
+            root: rootAbs,
+            target: targetAbs,
+            offendingPath: targetAbs,
+        });
+    }
+}
+//# sourceMappingURL=contained-write.js.map

package/dist/hooks/classify/classify.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Pure classify entry: payload → tool identity + write intent + paths (#2950 Phase A).
+ * No process I/O, no ritual/scope/policy evaluation.
+ */
+import type { ClassifyHookPayloadInput, HookClassification } from "./types.js";
+/**
+ * Classify a host hook payload without policy or filesystem access.
+ */
+export declare function classifyHookPayload(input: ClassifyHookPayloadInput): HookClassification;
+//# sourceMappingURL=classify.d.ts.map

package/dist/hooks/classify/classify.js

@@ -0,0 +1,37 @@
+/**
+ * Pure classify entry: payload → tool identity + write intent + paths (#2950 Phase A).
+ * No process I/O, no ritual/scope/policy evaluation.
+ */
+import { isDirectWriteTool, isMcpTool, isShellTool, isSpawnTool } from "../tools.js";
+import { hookPathSet, hookShellCommand, hookWriteTargetPath } from "./paths.js";
+import { hookPayloadTopLevelKeys } from "./payload.js";
+import { hookToolName } from "./tool-name.js";
+function writeIntentForTool(toolName) {
+    if (toolName === null)
+        return "unknown";
+    if (isDirectWriteTool(toolName))
+        return "direct-write";
+    if (isSpawnTool(toolName))
+        return "spawn";
+    if (isShellTool(toolName))
+        return "shell";
+    if (isMcpTool(toolName))
+        return "mcp";
+    return "other";
+}
+/**
+ * Classify a host hook payload without policy or filesystem access.
+ */
+export function classifyHookPayload(input) {
+    const toolName = hookToolName(input.payload, input.host);
+    const writeTargetPath = hookWriteTargetPath(input.payload);
+    return {
+        toolName,
+        writeIntent: writeIntentForTool(toolName),
+        writeTargetPath,
+        shellCommand: hookShellCommand(input.payload),
+        topLevelKeys: hookPayloadTopLevelKeys(input.payload),
+        paths: hookPathSet(input.payload),
+    };
+}
+//# sourceMappingURL=classify.js.map

package/dist/hooks/classify/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Pure hook payload classification (#2950 Phase A).
+ *
+ * Payload → tool identity + write intent + path set. No process I/O.
+ * Policy / ritual / scope / permission emission stay in dispatcher + CLI adapter.
+ */
+export { classifyHookPayload } from "./classify.js";
+export { hookMcpArgsText, hookPathSet, hookShellCommand, hookWriteTargetPath, } from "./paths.js";
+export { fieldPresent, fieldString, firstString, hookPayloadTopLevelKeys, record, toolInputRecord, } from "./payload.js";
+export { parseHookStdin, stripUtf8Bom } from "./stdin.js";
+export { hookToolName, inferCursorDirectWriteToolName, type MissingToolNameInput, missingToolNameMessage, } from "./tool-name.js";
+export type { ClassifyHookHost, ClassifyHookPayloadInput, HookClassification, HookPayloadContext, HookWriteIntent, ParsedHookPayload, } from "./types.js";
+export { CLASSIFY_HOOK_HOSTS } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/classify/index.js

@@ -0,0 +1,13 @@
+/**
+ * Pure hook payload classification (#2950 Phase A).
+ *
+ * Payload → tool identity + write intent + path set. No process I/O.
+ * Policy / ritual / scope / permission emission stay in dispatcher + CLI adapter.
+ */
+export { classifyHookPayload } from "./classify.js";
+export { hookMcpArgsText, hookPathSet, hookShellCommand, hookWriteTargetPath, } from "./paths.js";
+export { fieldPresent, fieldString, firstString, hookPayloadTopLevelKeys, record, toolInputRecord, } from "./payload.js";
+export { parseHookStdin, stripUtf8Bom } from "./stdin.js";
+export { hookToolName, inferCursorDirectWriteToolName, missingToolNameMessage, } from "./tool-name.js";
+export { CLASSIFY_HOOK_HOSTS } from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/hooks/classify/paths.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Pure write-target / shell-command extraction from host payloads (#2950).
+ * No process I/O — does not resolve against projectRoot or realpath.
+ */
+/**
+ * Best-effort write-target path from host PreToolUse payloads (#2625).
+ * Hosts disagree on nesting (`tool_input.file_path` vs top-level `path`).
+ */
+export declare function hookWriteTargetPath(payload: unknown): string | null;
+/**
+ * Best-effort shell command string from host PreToolUse payloads (#2711).
+ * Hosts disagree on nesting (`tool_input.command` vs top-level `command`).
+ */
+export declare function hookShellCommand(payload: unknown): string | null;
+/** Serialize tool args for MCP classification when nested objects are present (#2711). */
+export declare function hookMcpArgsText(payload: unknown): string | null;
+/**
+ * Collect distinct path-like strings from a payload for fixture assertions.
+ * Write target first when present; does not invent paths from free text.
+ */
+export declare function hookPathSet(payload: unknown): string[];
+//# sourceMappingURL=paths.d.ts.map