@deftai/directive-core 0.76.0 → 0.78.0

package/dist/hooks/dispatcher.js

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

package/dist/hooks/index.d.ts

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

package/dist/hooks/index.js

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

package/dist/hooks/scope.d.ts

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

package/dist/hooks/scope.js

@@ -0,0 +1,46 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+import { hasArtifactSuffix } from "../layout/resolve.js";
+import { evaluate } from "../preflight/evaluate.js";
+/**
+ * Find an implementation-eligible scope by delegating every candidate to the
+ * existing xBRIEF preflight evaluator. This intentionally creates no second
+ * lifecycle/status policy stack.
+ */
+export function inspectActiveScope(projectRoot) {
+    const candidates = [];
+    for (const relativeDir of [join("xbrief", "active"), join("vbrief", "active")]) {
+        const activeDir = join(projectRoot, relativeDir);
+        try {
+            for (const entry of readdirSync(activeDir, { withFileTypes: true })) {
+                if (entry.isFile() && hasArtifactSuffix(entry.name)) {
+                    candidates.push(join(activeDir, entry.name));
+                }
+            }
+        }
+        catch {
+            // A missing/unreadable active folder contributes no eligible candidate.
+        }
+    }
+    // Stable traversal makes the selected path and first rejection reproducible.
+    // This is not a priority rule: every candidate is evaluated until one passes.
+    candidates.sort();
+    let firstRejection = null;
+    for (const candidate of candidates) {
+        const result = evaluate(candidate);
+        if (result.exitCode === 0) {
+            return { ready: true, path: candidate, message: result.message };
+        }
+        firstRejection ??= result.message;
+    }
+    if (firstRejection !== null) {
+        return { ready: false, path: null, message: firstRejection };
+    }
+    return {
+        ready: false,
+        path: null,
+        message: "No active xBRIEF artifact was found under xbrief/active/ " +
+            "(or the legacy vbrief/active/ compatibility path).",
+    };
+}
+//# sourceMappingURL=scope.js.map

package/dist/hooks/tools.d.ts

@@ -0,0 +1,4 @@
+/** Host spellings that install-time matchers and runtime classification share. */
+export declare const DIRECT_WRITE_TOOL_NAMES: readonly ["Edit", "Write", "WriteFile", "CreateFile", "MultiEdit", "NotebookEdit", "StrReplace", "SearchReplace", "Delete", "DeleteFile", "ApplyPatch", "apply_patch"];
+export declare function isDirectWriteTool(toolName: string): boolean;
+//# sourceMappingURL=tools.d.ts.map

package/dist/hooks/tools.js

@@ -0,0 +1,23 @@
+/** Host spellings that install-time matchers and runtime classification share. */
+export const DIRECT_WRITE_TOOL_NAMES = [
+    "Edit",
+    "Write",
+    "WriteFile",
+    "CreateFile",
+    "MultiEdit",
+    "NotebookEdit",
+    "StrReplace",
+    "SearchReplace",
+    "Delete",
+    "DeleteFile",
+    "ApplyPatch",
+    "apply_patch",
+];
+function normalizedToolName(toolName) {
+    return toolName.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+const DIRECT_WRITE_TOOLS = new Set(DIRECT_WRITE_TOOL_NAMES.map(normalizedToolName));
+export function isDirectWriteTool(toolName) {
+    return DIRECT_WRITE_TOOLS.has(normalizedToolName(toolName));
+}
+//# sourceMappingURL=tools.js.map

package/dist/index.d.ts

@@ -25,6 +25,7 @@ export * as intake from "./intake/index.js";
 export * as layout from "./layout/index.js";
 export * as legacyBridge from "./legacy-bridge/index.js";
 export * as lifecycle from "./lifecycle/index.js";
+export * as metrics from "./metrics/index.js";
 export * as orchestration from "./orchestration/index.js";
 export * as packs from "./packs/index.js";
 export * as platform from "./platform/index.js";

package/dist/index.js

@@ -25,6 +25,7 @@ export * as intake from "./intake/index.js";
 export * as layout from "./layout/index.js";
 export * as legacyBridge from "./legacy-bridge/index.js";
 export * as lifecycle from "./lifecycle/index.js";
+export * as metrics from "./metrics/index.js";
 export * as orchestration from "./orchestration/index.js";
 export * as packs from "./packs/index.js";
 export * as platform from "./platform/index.js";

package/dist/init-deposit/agent-hooks.d.ts

@@ -0,0 +1,22 @@
+import type { HookHost } from "../hooks/dispatcher.js";
+import type { InitDepositIo } from "./constants.js";
+export declare const DIRECT_WRITE_HOOK_MATCHER: string;
+export declare const DEFT_HOOK_COMMAND_MARKER = "deft hook:dispatch";
+export declare const AGENT_HOOK_PATHS: readonly [".claude/settings.json", ".grok/hooks/deft.json", ".cursor/hooks.json"];
+export type AgentHookPath = (typeof AGENT_HOOK_PATHS)[number];
+export type AgentHookRegistrationStatus = "healthy" | "missing" | "drifted";
+export interface AgentHookInspection {
+    readonly host: HookHost;
+    readonly path: AgentHookPath;
+    readonly status: AgentHookRegistrationStatus;
+    readonly detail: string;
+}
+export interface AgentHookDepositResult {
+    readonly changed: boolean;
+    readonly changedPaths: AgentHookPath[];
+}
+/** Merge Directive-owned project hook entries without replacing user configuration. */
+export declare function writeAgentHookDeposit(projectRoot: string, io?: InitDepositIo): AgentHookDepositResult;
+/** Read-only registration probe shared by verify and doctor. */
+export declare function inspectAgentHookDeposit(projectRoot: string): AgentHookInspection[];
+//# sourceMappingURL=agent-hooks.d.ts.map

package/dist/init-deposit/agent-hooks.js

@@ -0,0 +1,228 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { assertDepositContained } from "../deposit/contain.js";
+import { DIRECT_WRITE_TOOL_NAMES } from "../hooks/tools.js";
+export const DIRECT_WRITE_HOOK_MATCHER = DIRECT_WRITE_TOOL_NAMES.join("|");
+export const DEFT_HOOK_COMMAND_MARKER = "deft hook:dispatch";
+export const AGENT_HOOK_PATHS = [
+    ".claude/settings.json",
+    ".grok/hooks/deft.json",
+    ".cursor/hooks.json",
+];
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function command(host, event) {
+    return `${DEFT_HOOK_COMMAND_MARKER} --host ${host} --event ${event}`;
+}
+function readConfig(path) {
+    if (!existsSync(path))
+        return {};
+    const raw = readFileSync(path, "utf8");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (cause) {
+        throw new Error(`${path} is not valid JSON; refusing to overwrite user configuration: ${cause}`);
+    }
+    const config = object(parsed);
+    if (config === null) {
+        throw new Error(`${path} must contain a JSON object; refusing to overwrite user configuration.`);
+    }
+    return config;
+}
+function hooksObject(config, path) {
+    if (config.hooks === undefined)
+        return {};
+    const hooks = object(config.hooks);
+    if (hooks === null)
+        throw new Error(`${path}: hooks must be a JSON object.`);
+    return { ...hooks };
+}
+function eventArray(hooks, key, path) {
+    const value = hooks[key];
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new Error(`${path}: hooks.${key} must be an array.`);
+    return [...value];
+}
+function nestedCommands(value) {
+    const group = object(value);
+    if (group === null || !Array.isArray(group.hooks))
+        return [];
+    return group.hooks.flatMap((candidate) => {
+        const hook = object(candidate);
+        return typeof hook?.command === "string" ? [hook.command] : [];
+    });
+}
+function isManagedNestedGroup(value) {
+    return nestedCommands(value).some((value) => value.includes(DEFT_HOOK_COMMAND_MARKER));
+}
+function isManagedCursorEntry(value) {
+    const entry = object(value);
+    return typeof entry?.command === "string" && entry.command.includes(DEFT_HOOK_COMMAND_MARKER);
+}
+function nestedGroup(host, event) {
+    return {
+        ...(event === "tool.before" ? { matcher: DIRECT_WRITE_HOOK_MATCHER } : {}),
+        hooks: [
+            {
+                type: "command",
+                command: command(host, event),
+                timeout: 5,
+            },
+        ],
+    };
+}
+function mergeNestedConfig(config, path, host) {
+    const hooks = hooksObject(config, path);
+    const session = eventArray(hooks, "SessionStart", path).filter((entry) => !isManagedNestedGroup(entry));
+    const preTool = eventArray(hooks, "PreToolUse", path).filter((entry) => !isManagedNestedGroup(entry));
+    hooks.SessionStart = [...session, nestedGroup(host, "session.start")];
+    hooks.PreToolUse = [...preTool, nestedGroup(host, "tool.before")];
+    return { ...config, hooks };
+}
+function mergeCursorConfig(config, path) {
+    const hooks = hooksObject(config, path);
+    const session = eventArray(hooks, "sessionStart", path).filter((entry) => !isManagedCursorEntry(entry));
+    const preTool = eventArray(hooks, "preToolUse", path).filter((entry) => !isManagedCursorEntry(entry));
+    hooks.sessionStart = [...session, { command: command("cursor", "session.start"), timeout: 5 }];
+    hooks.preToolUse = [
+        ...preTool,
+        {
+            command: command("cursor", "tool.before"),
+            matcher: DIRECT_WRITE_HOOK_MATCHER,
+            failClosed: true,
+            timeout: 5,
+        },
+    ];
+    return { ...config, version: 1, hooks };
+}
+function writeJsonIfChanged(path, payload) {
+    const next = `${JSON.stringify(payload, null, 2)}\n`;
+    if (existsSync(path) && readFileSync(path, "utf8") === next)
+        return false;
+    mkdirSync(dirname(path), { recursive: true });
+    const temporary = `${path}.deft-${process.pid}.tmp`;
+    writeFileSync(temporary, next, "utf8");
+    renameSync(temporary, path);
+    return true;
+}
+/** Merge Directive-owned project hook entries without replacing user configuration. */
+export function writeAgentHookDeposit(projectRoot, io = { printf: () => undefined }) {
+    const changedPaths = [];
+    const definitions = [
+        {
+            path: AGENT_HOOK_PATHS[0],
+            merge: (config, path) => mergeNestedConfig(config, path, "claude"),
+        },
+        {
+            path: AGENT_HOOK_PATHS[1],
+            merge: (config, path) => mergeNestedConfig(config, path, "grok"),
+        },
+        { path: AGENT_HOOK_PATHS[2], merge: mergeCursorConfig },
+    ];
+    const prepared = definitions.map((definition) => {
+        const absolute = join(projectRoot, definition.path);
+        assertDepositContained(projectRoot, absolute);
+        const merged = definition.merge(readConfig(absolute), absolute);
+        return { ...definition, absolute, merged };
+    });
+    for (const definition of prepared) {
+        if (writeJsonIfChanged(definition.absolute, definition.merged)) {
+            changedPaths.push(definition.path);
+        }
+    }
+    if (changedPaths.length > 0) {
+        io.printf(`Installed Directive agent hooks: ${changedPaths.join(", ")}\n`);
+    }
+    else {
+        io.printf("Directive agent hooks already current.\n");
+    }
+    return { changed: changedPaths.length > 0, changedPaths };
+}
+function hasNestedRegistration(config, host) {
+    const hooks = object(config.hooks);
+    if (hooks === null)
+        return false;
+    const session = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+    const preTool = Array.isArray(hooks.PreToolUse) ? hooks.PreToolUse : [];
+    const sessionCommand = command(host, "session.start");
+    const toolCommand = command(host, "tool.before");
+    return (session.some((entry) => nestedCommands(entry).includes(sessionCommand)) &&
+        preTool.some((entry) => {
+            const group = object(entry);
+            return (group?.matcher === DIRECT_WRITE_HOOK_MATCHER && nestedCommands(entry).includes(toolCommand));
+        }));
+}
+function hasCursorRegistration(config) {
+    const hooks = object(config.hooks);
+    if (hooks === null || config.version !== 1)
+        return false;
+    const session = Array.isArray(hooks.sessionStart) ? hooks.sessionStart : [];
+    const preTool = Array.isArray(hooks.preToolUse) ? hooks.preToolUse : [];
+    return (session.some((entry) => object(entry)?.command === command("cursor", "session.start")) &&
+        preTool.some((entry) => {
+            const hook = object(entry);
+            return (hook?.command === command("cursor", "tool.before") &&
+                hook.matcher === DIRECT_WRITE_HOOK_MATCHER &&
+                hook.failClosed === true);
+        }));
+}
+/** Read-only registration probe shared by verify and doctor. */
+export function inspectAgentHookDeposit(projectRoot) {
+    const definitions = [
+        {
+            host: "claude",
+            path: AGENT_HOOK_PATHS[0],
+            valid: (config) => hasNestedRegistration(config, "claude"),
+        },
+        {
+            host: "grok",
+            path: AGENT_HOOK_PATHS[1],
+            valid: (config) => hasNestedRegistration(config, "grok"),
+        },
+        { host: "cursor", path: AGENT_HOOK_PATHS[2], valid: hasCursorRegistration },
+    ];
+    return definitions.map((definition) => {
+        const absolute = join(projectRoot, definition.path);
+        if (!existsSync(absolute)) {
+            return {
+                host: definition.host,
+                path: definition.path,
+                status: "missing",
+                detail: `${definition.path} is missing.`,
+            };
+        }
+        try {
+            const config = readConfig(absolute);
+            if (definition.valid(config)) {
+                return {
+                    host: definition.host,
+                    path: definition.path,
+                    status: "healthy",
+                    detail: "SessionStart and direct-write PreToolUse registrations are current.",
+                };
+            }
+            return {
+                host: definition.host,
+                path: definition.path,
+                status: "drifted",
+                detail: "Directive SessionStart or direct-write PreToolUse registration is missing/drifted.",
+            };
+        }
+        catch (cause) {
+            return {
+                host: definition.host,
+                path: definition.path,
+                status: "drifted",
+                detail: String(cause),
+            };
+        }
+    });
+}
+//# sourceMappingURL=agent-hooks.js.map

package/dist/init-deposit/hygiene.js

@@ -21,6 +21,9 @@ export function installerManagedMatchers() {
         { exact: "AGENTS.md" },
         { prefix: ".agents/" },
         { prefix: ".githooks/" },
+        { exact: ".claude/settings.json" },
+        { exact: ".grok/hooks/deft.json" },
+        { exact: ".cursor/hooks.json" },
         { exact: ".gitattributes" },
         { exact: ".gitignore" },
         { exact: "greptile.json" },

package/dist/init-deposit/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./agent-hooks.js";
 export * from "./headless-manifest.js";
 export * from "./init-deposit.js";
 export * from "./init-dispatch.js";

package/dist/init-deposit/index.js

@@ -1,3 +1,4 @@
+export * from "./agent-hooks.js";
 export * from "./headless-manifest.js";
 export * from "./init-deposit.js";
 export * from "./init-dispatch.js";

package/dist/init-deposit/init-deposit.js

@@ -13,6 +13,7 @@ import { copyTree } from "../deposit/copy-tree.js";
 import { prunePythonArtifactsFromDeposit } from "../deposit/python-free.js";
 import { resolveInstalledContentRoot } from "../deposit/resolve-content.js";
 import { readCorePackageVersion } from "../engine-version.js";
+import { writeAgentHookDeposit } from "./agent-hooks.js";
 import { ensureInitGitignoreLines, reconstituteDepositFromContent } from "./gitignore.js";
 import { depositStagePaths, printCommitGuidance } from "./hygiene.js";
 import { buildLegacyRefusalJson, buildLegacyRefusalMessage, detectLegacyLayout, LEGACY_LAYOUT_REFUSED_EXIT_CODE, LegacyLayoutRefusedError, } from "./legacy-detect.js";
@@ -152,6 +153,7 @@ export async function runInitDeposit(args, io, seams = {}) {
     await depositNeutralization(projectDir, io);
     await writeConsumerVbrief(projectDir, deftDir, io);
     writeConsumerGitHooks(projectDir, deftDir, io, seams.gitHooks);
+    writeAgentHookDeposit(projectDir, io);
     let taskfileWired = false;
     if (args.nonInteractive) {
         taskfileWired = ensureTaskfile(projectDir, io);

package/dist/init-deposit/refresh.js

@@ -21,6 +21,7 @@ import { resolveLifecycleRoot } from "../layout/resolve.js";
 import { DEV_FALLBACK } from "../platform/constants.js";
 import { checkLocalEngineIntegrity, classify, ENGINE_PACKAGE, plan, renderGlobalInstall, resolveEngine, } from "../resolution/index.js";
 import { gitPorcelain } from "../story-ready/git.js";
+import { writeAgentHookDeposit } from "./agent-hooks.js";
 import { ensureInitGitignoreLines, isDepositTrackedInGit } from "./gitignore.js";
 import { depositStagePaths, isInstallerManagedPath, printCommitGuidance, pruneStrayDepositPaths, } from "./hygiene.js";
 import { parseInitArgv } from "./init-deposit.js";
@@ -457,6 +458,7 @@ export async function runRefreshDeposit(args, io, seams = {}) {
         syncBareVersionMarker(projectDir, contentVersion);
     }
     const agentsMdUpdated = writeAgentsMd(projectDir, deftDir, io);
+    writeAgentHookDeposit(projectDir, io);
     // #2148: the deft-core-guard CI workflow is only meaningful when the deposit
     // is git-tracked (committed vendor layout). On an npm-managed (gitignored)
     // deposit it creates untracked noise after every `directive update`. Probe

package/dist/intake/reconcile-issues.d.ts

@@ -26,6 +26,7 @@ export interface FetchIssuesOptions {
 export declare function fetchOpenIssues(repo: string, options?: FetchIssuesOptions): Record<string, unknown>[] | null;
 export declare function fetchAllOpenIssues(repo: string, options?: FetchIssuesOptions): Record<string, unknown>[] | null;
 export interface FetchIssueStatesOptions extends FetchIssuesOptions {
+    /** @deprecated REST fetch is per-issue; batch size is ignored (#2557 / #954). */
     readonly batchSize?: number;
 }
 export declare function fetchIssueStates(repo: string, issueNumbers: ReadonlySet<number>, options?: FetchIssueStatesOptions): Map<number, IssueState> | null;