kibi-cli 0.14.0 → 0.16.1

package/dist/public/operations/discovery-executors.js

@@ -0,0 +1,101 @@
+import { rankEntities } from "../../search-ranking.js";
+import { loadEntities, paginateResults, validateEntityType, } from "./discovery-entities.js";
+import { runOperationJsonQuery } from "./prolog-json.js";
+function requireProlog(context) {
+    if (!context.prolog) {
+        throw new Error("Discovery operation requires a Prolog context");
+    }
+    return context.prolog;
+}
+function isStatusPayload(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const record = Object.fromEntries(Object.entries(value));
+    return (typeof record.branch === "string" &&
+        typeof record.snapshotId === "string" &&
+        (typeof record.syncedAt === "string" || record.syncedAt === null) &&
+        typeof record.dirty === "boolean" &&
+        typeof record.syncState === "string");
+}
+export async function executeQuery(input, context) {
+    // implements REQ-kibi-operation-interface-parity
+    const { type, id, tags, sourceFile, limit = 100, offset = 0 } = input;
+    try {
+        const entities = await loadEntities(requireProlog(context), {
+            ...(type !== undefined ? { type } : {}),
+            ...(id !== undefined ? { id } : {}),
+            ...(tags !== undefined ? { tags } : {}),
+            ...(sourceFile !== undefined ? { sourceFile } : {}),
+        });
+        const paginated = paginateResults(entities, limit, offset);
+        const text = entities.length === 0
+            ? `No entities found${type ? ` of type '${type}'` : ""}.`
+            : `Found ${entities.length} entities${type ? ` of type '${type}'` : ""}. Showing ${paginated.length} (offset ${offset}, limit ${limit}): ${paginated
+                .map((entity) => {
+                const entityId = String(entity.id ?? "").replace(/^file:\/\/.*\//, "");
+                return `${entityId} (${String(entity.title ?? "")}, status=${String(entity.status ?? "")})`;
+            })
+                .join(", ")}`;
+        return {
+            content: [{ type: "text", text }],
+            structuredContent: { entities: paginated, count: entities.length },
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Query execution failed: ${message}`);
+    }
+}
+export async function executeSearch(input, context) {
+    // implements REQ-kibi-operation-interface-parity, REQ-mcp-search-discovery
+    const { query, type, limit = 20, offset = 0 } = input;
+    const trimmedQuery = query.trim();
+    if (!trimmedQuery) {
+        throw new Error("Search execution failed: query must be a non-empty string");
+    }
+    validateEntityType(type);
+    try {
+        const entities = await loadEntities(requireProlog(context), {
+            ...(type !== undefined ? { type } : {}),
+        });
+        const matches = await rankEntities(entities, trimmedQuery, context.workspaceRoot);
+        const paginated = paginateResults(matches, limit, offset);
+        const text = matches.length === 0
+            ? `No search results for '${trimmedQuery}'.`
+            : `Found ${matches.length} search results for '${trimmedQuery}'. Showing ${paginated.length} (offset ${offset}, limit ${limit}): ${paginated
+                .map((match) => `${String(match.entity.id ?? "")} [${match.reasons.join(", ")}]`)
+                .join(", ")}`;
+        return {
+            content: [{ type: "text", text }],
+            structuredContent: { results: paginated, count: matches.length },
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.startsWith("Search execution failed:"))
+            throw error;
+        throw new Error(`Search execution failed: ${message}`);
+    }
+}
+export async function executeStatus(_input, context) {
+    // implements REQ-kibi-operation-interface-parity, REQ-cli-status-pre-first-sync
+    try {
+        const payload = await runOperationJsonQuery(requireProlog(context), "status.pl", "status:kb_status_json(JsonString)", "Status execution");
+        if (!isStatusPayload(payload)) {
+            throw new Error("Status execution query returned an invalid payload");
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Branch ${payload.branch} is ${payload.syncState} (snapshot ${payload.snapshotId}, dirty=${payload.dirty})`,
+                },
+            ],
+            structuredContent: payload,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Status execution failed: ${message}`);
+    }
+}

package/dist/public/operations/index.d.ts

@@ -0,0 +1,20 @@
+export * from "./catalog.js";
+export * from "./check-executor.js";
+export * from "./discovery-entities.js";
+export * from "./discovery-executors.js";
+export * from "./runtime-types.js";
+export * from "./node-ports.js";
+export * from "./specs/autopilot.js";
+export * from "./specs/check.js";
+export * from "./specs/discovery.js";
+export * from "./specs/modeling.js";
+export * from "./specs/mutation.js";
+export * from "./specs/reporting.js";
+export * from "./specs/semantic.js";
+export * from "./specs/skills.js";
+export * from "./specs/sparql.js";
+export * from "./types.js";
+export * from "../../operations/autopilot/generate.js";
+export * from "../../operations/autopilot/presentation.js";
+export type * from "../../operations/autopilot/types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/public/operations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/public/operations/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,wCAAwC,CAAC;AACvD,cAAc,4CAA4C,CAAC;AAC3D,mBAAmB,qCAAqC,CAAC"}

package/dist/public/operations/index.js

@@ -0,0 +1,18 @@
+export * from "./catalog.js";
+export * from "./check-executor.js";
+export * from "./discovery-entities.js";
+export * from "./discovery-executors.js";
+export * from "./runtime-types.js";
+export * from "./node-ports.js";
+export * from "./specs/autopilot.js";
+export * from "./specs/check.js";
+export * from "./specs/discovery.js";
+export * from "./specs/modeling.js";
+export * from "./specs/mutation.js";
+export * from "./specs/reporting.js";
+export * from "./specs/semantic.js";
+export * from "./specs/skills.js";
+export * from "./specs/sparql.js";
+export * from "./types.js";
+export * from "../../operations/autopilot/generate.js";
+export * from "../../operations/autopilot/presentation.js";

package/dist/public/operations/node-ports.d.ts

@@ -0,0 +1,15 @@
+import type { FilesystemPort, GitPort, NetworkPort } from "./runtime-types.js";
+type NodeFilesystemPort = FilesystemPort & {
+    readonly glob: (patterns: readonly string[], options: {
+        readonly cwd: string;
+        readonly includeIgnored?: boolean;
+    }) => Promise<readonly string[]>;
+};
+type NodeGitPort = GitPort & {
+    readonly ignoredPaths: (workspaceRoot: string, paths: readonly string[]) => Promise<readonly string[]>;
+};
+export declare const nodeFilesystem: NodeFilesystemPort;
+export declare const nodeGit: NodeGitPort;
+export declare const nodeNetwork: NetworkPort;
+export {};
+//# sourceMappingURL=node-ports.d.ts.map

package/dist/public/operations/node-ports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-ports.d.ts","sourceRoot":"","sources":["../../../src/public/operations/node-ports.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAE/E,KAAK,kBAAkB,GAAG,cAAc,GAAG;IACzC,QAAQ,CAAC,IAAI,EAAE,CACb,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,OAAO,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAA;KAAE,KACjE,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAAC;CACjC,CAAC;AAEF,KAAK,WAAW,GAAG,OAAO,GAAG;IAC3B,QAAQ,CAAC,YAAY,EAAE,CACrB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,SAAS,MAAM,EAAE,KACrB,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAAC;CACjC,CAAC;AAiBF,eAAO,MAAM,cAAc,EAAE,kBAkB5B,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,WAgBrB,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,WAEzB,CAAC"}

package/dist/public/operations/node-ports.js

@@ -0,0 +1,57 @@
+import { execFile } from "node:child_process";
+import * as fs from "node:fs/promises";
+import { promisify } from "node:util";
+import fg from "fast-glob";
+import { createRepoIgnorePolicy } from "../ignore-policy.js";
+const execFileAsync = promisify(execFile);
+const ALWAYS_IGNORED_GLOBS = [
+    "**/.git/**",
+    "**/.kb/**",
+    "**/node_modules/**",
+    "**/vendor/**",
+    "**/vendors/**",
+    "**/third_party/**",
+    "**/third-party/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/coverage/**",
+    "**/target/**",
+];
+export const nodeFilesystem = {
+    readFile: (filePath) => fs.readFile(filePath, "utf8"),
+    writeFile: async (filePath, data) => {
+        await fs.writeFile(filePath, data, "utf8");
+    },
+    mkdir: async (directoryPath) => {
+        await fs.mkdir(directoryPath, { recursive: true });
+    },
+    stat: (filePath) => fs.stat(filePath),
+    glob: (patterns, options) => fg([...patterns], {
+        cwd: options.cwd,
+        onlyFiles: true,
+        unique: true,
+        dot: true,
+        suppressErrors: true,
+        ignore: [...ALWAYS_IGNORED_GLOBS],
+    }),
+};
+export const nodeGit = {
+    revParse: async (...args) => {
+        const { stdout } = await execFileAsync("git", ["rev-parse", ...args]);
+        return stdout.trim();
+    },
+    showToplevel: async () => {
+        const { stdout } = await execFileAsync("git", [
+            "rev-parse",
+            "--show-toplevel",
+        ]);
+        return stdout.trim();
+    },
+    ignoredPaths: async (workspaceRoot, paths) => {
+        const policy = createRepoIgnorePolicy(workspaceRoot);
+        return paths.filter((candidate) => policy.isIgnored(candidate));
+    },
+};
+export const nodeNetwork = {
+    fetch: (input, init) => globalThis.fetch(input, init),
+};

package/dist/public/operations/prolog-json.d.ts

@@ -0,0 +1,5 @@
+import type { PrologPort } from "./runtime-types.js";
+export declare function runOperationJsonQuery<T>(prolog: PrologPort, fileName: string, goal: string, errorLabel: string): Promise<T>;
+export declare function toPrologAtom(value?: string): string;
+export declare function toPrologList(values?: readonly string[]): string;
+//# sourceMappingURL=prolog-json.d.ts.map

package/dist/public/operations/prolog-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prolog-json.d.ts","sourceRoot":"","sources":["../../../src/public/operations/prolog-json.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAUrD,wBAAsB,qBAAqB,CAAC,CAAC,EAC3C,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,CAAC,CAAC,CAuBZ;AAiBD,wBAAgB,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAInD;AAED,wBAAgB,YAAY,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAI/D"}

package/dist/public/operations/prolog-json.js

@@ -0,0 +1,44 @@
+import path from "node:path";
+import { getKbPlPathOverride } from "../../env.js";
+import { resolveKbPlPath } from "../../prolog.js";
+import { escapeAtom } from "../../prolog/codec.js";
+function resolveCoreModulePath(fileName) {
+    const genericOverride = getKbPlPathOverride();
+    return path.join(path.dirname(genericOverride ?? resolveKbPlPath()), fileName);
+}
+export async function runOperationJsonQuery(prolog, fileName, goal, errorLabel) {
+    const modulePath = escapeAtom(resolveCoreModulePath(fileName).replaceAll("\\", "/"));
+    const oneShotMode = typeof globalThis.Bun !== "undefined";
+    const result = oneShotMode
+        ? await prolog.query(`(use_module('${modulePath}'), ${goal})`)
+        : await runInteractiveModuleQuery(prolog, modulePath, goal, errorLabel);
+    if (!result.success) {
+        throw new Error(`${errorLabel} query failed: ${result.error ?? "Unknown error"}`);
+    }
+    const rawJson = result.bindings.JsonString;
+    if (rawJson === undefined) {
+        throw new Error(`${errorLabel} query returned no JsonString binding`);
+    }
+    let parsed = JSON.parse(rawJson);
+    if (typeof parsed === "string") {
+        parsed = JSON.parse(parsed);
+    }
+    return parsed;
+}
+async function runInteractiveModuleQuery(prolog, modulePath, goal, errorLabel) {
+    const loadResult = await prolog.query(`use_module('${modulePath}')`);
+    if (!loadResult.success) {
+        throw new Error(`${errorLabel} module load failed: ${loadResult.error ?? "Unknown error"}`);
+    }
+    return prolog.query(goal);
+}
+export function toPrologAtom(value) {
+    return value === undefined || value === ""
+        ? "none"
+        : `'${escapeAtom(value)}'`;
+}
+export function toPrologList(values) {
+    return values === undefined || values.length === 0
+        ? "[]"
+        : `[${values.map((value) => `'${escapeAtom(value)}'`).join(",")}]`;
+}

package/dist/public/operations/runtime-types.d.ts

@@ -0,0 +1,69 @@
+import type { OperationEffect } from "./types.js";
+export type { OperationEffect } from "./types.js";
+export type PrologQueryResult = {
+    readonly success: boolean;
+    readonly bindings: Readonly<Record<string, string>>;
+    readonly error?: string;
+};
+export interface PrologPort {
+    query(goal: string): Promise<PrologQueryResult>;
+    nextSolution(): Promise<PrologQueryResult | null>;
+    invalidateCache?(): void;
+    save(): Promise<PrologQueryResult>;
+}
+export type FilesystemStat = {
+    readonly isFile: () => boolean;
+    readonly isDirectory: () => boolean;
+};
+export interface FilesystemPort {
+    readFile(path: string): Promise<string>;
+    writeFile(path: string, data: string): Promise<void>;
+    mkdir(path: string): Promise<void>;
+    stat(path: string): Promise<FilesystemStat>;
+}
+export interface GitPort {
+    revParse(...args: readonly string[]): Promise<string>;
+    showToplevel(): Promise<string>;
+}
+export interface NetworkPort {
+    fetch(input: string | URL, init?: RequestInit): Promise<Response>;
+}
+export type Clock = () => Date;
+export type RuntimeOptions = {
+    readonly workspaceRoot?: string;
+    readonly signal?: AbortSignal;
+    readonly clock?: Clock;
+    readonly prolog?: PrologPort;
+    readonly fs?: FilesystemPort;
+    readonly git?: GitPort;
+    readonly net?: NetworkPort;
+};
+export type OperationContext = {
+    readonly workspaceRoot: string;
+    readonly signal: AbortSignal;
+    readonly clock: Clock;
+    readonly prolog?: PrologPort;
+    readonly fs?: FilesystemPort;
+    readonly git?: GitPort;
+    readonly net?: NetworkPort;
+};
+export interface RuntimeOperationSpec<TInput = unknown, TResult = unknown> {
+    readonly name: string;
+    readonly effects: readonly OperationEffect[];
+    readonly requiresProlog: boolean;
+    execute(input: TInput, context: OperationContext): Promise<TResult>;
+}
+export type OperationOutcome = {
+    readonly status: "success";
+    readonly result: unknown;
+} | {
+    readonly status: "error";
+    readonly error: unknown;
+};
+export interface OperationRuntime {
+    open(spec: RuntimeOperationSpec<unknown, unknown>, opts?: RuntimeOptions): Promise<OperationContext>;
+    afterSuccess(spec: RuntimeOperationSpec<unknown, unknown>, context: OperationContext): Promise<void>;
+    close(context: OperationContext, outcome: OperationOutcome): Promise<void>;
+}
+export declare function executeOperation<TInput, TResult>(runtime: OperationRuntime, spec: RuntimeOperationSpec<TInput, TResult>, input: TInput, opts?: RuntimeOptions): Promise<TResult>;
+//# sourceMappingURL=runtime-types.d.ts.map

package/dist/public/operations/runtime-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-types.d.ts","sourceRoot":"","sources":["../../../src/public/operations/runtime-types.ts"],"names":[],"mappings":"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"}

package/dist/public/operations/runtime-types.js

@@ -0,0 +1,17 @@
+// implements REQ-kibi-operation-interface-parity
+export async function executeOperation(runtime, spec, input, opts) {
+    const context = await runtime.open(spec, opts);
+    let result;
+    try {
+        result = await spec.execute(input, context);
+        if (spec.effects.includes("kb-write")) {
+            await runtime.afterSuccess(spec, context);
+        }
+    }
+    catch (error) {
+        await runtime.close(context, { status: "error", error });
+        throw error;
+    }
+    await runtime.close(context, { status: "success", result });
+    return result;
+}

package/dist/public/operations/specs/autopilot.d.ts

@@ -0,0 +1,82 @@
+import { executeAutopilotGenerate } from "../../../operations/autopilot/generate.js";
+export type { AutopilotBootstrapContext, AutopilotGenerateArgs, AutopilotGenerateResult, } from "../../../operations/autopilot/types.js";
+export { executeAutopilotGenerate } from "../../../operations/autopilot/generate.js";
+export declare const autopilotGenerateSpec: {
+    readonly name: "kb_autopilot_generate";
+    readonly cliName: "autopilot-generate";
+    readonly description: "Generate agent-centric bootstrap output for KB population. Read-only analysis that returns activation state, bootstrap guidance, candidate entities with evidence, payoff summary, and exact applyPlan payloads for later kb_upsert calls. No mutation side effects.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly includeGenericMarkdown: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Whether to include generic markdown file content as candidate facts. Default: true.";
+            };
+            readonly minConfidence: {
+                readonly type: "number";
+                readonly default: 0.8;
+                readonly minimum: 0.6;
+                readonly maximum: 0.95;
+                readonly description: "Minimum confidence threshold for candidates. Clamped to [0.60, 0.95]. Default: 0.80.";
+            };
+            readonly maxCandidates: {
+                readonly type: "integer";
+                readonly default: 50;
+                readonly minimum: 1;
+                readonly maximum: 200;
+                readonly description: "Maximum number of candidates to return. Clamped to [1, 200]. Default: 50.";
+            };
+            readonly entityTypes: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly enum: readonly ["req", "scenario", "test", "adr", "fact", "symbol"];
+                };
+                readonly description: "Optional filter to limit candidate generation to specific entity types.";
+            };
+            readonly bootstrapContext: {
+                readonly type: "object";
+                readonly description: "Optional declared bootstrap context supplied by the agent to ground the read-only synthesis output.";
+                readonly properties: {
+                    readonly projectSummary: {
+                        readonly type: "string";
+                        readonly description: "Optional short summary of the project or bootstrap goal.";
+                    };
+                    readonly sourceOfTruthPaths: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional repo-relative paths that should be treated as declared sources of truth.";
+                    };
+                    readonly sourceOfTruthNotes: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional notes about how to interpret the declared sources of truth.";
+                    };
+                    readonly priorityRoots: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional repo roots the bootstrap flow should prioritize when authoring entities.";
+                    };
+                    readonly verificationAnchors: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional verification commands, documents, or checkpoints to reference in the output.";
+                    };
+                };
+            };
+        };
+    };
+    readonly requiresProlog: false;
+    readonly effects: readonly ["workspace-read"];
+    readonly execute: typeof executeAutopilotGenerate;
+};
+//# sourceMappingURL=autopilot.d.ts.map

package/dist/public/operations/specs/autopilot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autopilot.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/autopilot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AAOrF,YAAY,EACV,yBAAyB,EACzB,qBAAqB,EACrB,uBAAuB,GACxB,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AAErF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmFjC,CAAC"}

package/dist/public/operations/specs/autopilot.js

@@ -0,0 +1,72 @@
+import { executeAutopilotGenerate } from "../../../operations/autopilot/generate.js";
+export { executeAutopilotGenerate } from "../../../operations/autopilot/generate.js";
+export const autopilotGenerateSpec = {
+    name: "kb_autopilot_generate",
+    cliName: "autopilot-generate",
+    description: "Generate agent-centric bootstrap output for KB population. Read-only analysis that returns activation state, bootstrap guidance, candidate entities with evidence, payoff summary, and exact applyPlan payloads for later kb_upsert calls. No mutation side effects.",
+    businessInputSchema: {
+        type: "object",
+        properties: {
+            includeGenericMarkdown: {
+                type: "boolean",
+                default: true,
+                description: "Whether to include generic markdown file content as candidate facts. Default: true.",
+            },
+            minConfidence: {
+                type: "number",
+                default: 0.8,
+                minimum: 0.6,
+                maximum: 0.95,
+                description: "Minimum confidence threshold for candidates. Clamped to [0.60, 0.95]. Default: 0.80.",
+            },
+            maxCandidates: {
+                type: "integer",
+                default: 50,
+                minimum: 1,
+                maximum: 200,
+                description: "Maximum number of candidates to return. Clamped to [1, 200]. Default: 50.",
+            },
+            entityTypes: {
+                type: "array",
+                items: {
+                    type: "string",
+                    enum: ["req", "scenario", "test", "adr", "fact", "symbol"],
+                },
+                description: "Optional filter to limit candidate generation to specific entity types.",
+            },
+            bootstrapContext: {
+                type: "object",
+                description: "Optional declared bootstrap context supplied by the agent to ground the read-only synthesis output.",
+                properties: {
+                    projectSummary: {
+                        type: "string",
+                        description: "Optional short summary of the project or bootstrap goal.",
+                    },
+                    sourceOfTruthPaths: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional repo-relative paths that should be treated as declared sources of truth.",
+                    },
+                    sourceOfTruthNotes: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional notes about how to interpret the declared sources of truth.",
+                    },
+                    priorityRoots: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional repo roots the bootstrap flow should prioritize when authoring entities.",
+                    },
+                    verificationAnchors: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional verification commands, documents, or checkpoints to reference in the output.",
+                    },
+                },
+            },
+        },
+    },
+    requiresProlog: false,
+    effects: ["workspace-read"],
+    execute: executeAutopilotGenerate,
+};

package/dist/public/operations/specs/check.d.ts

@@ -0,0 +1,51 @@
+import { executeCheck } from "../check-executor.js";
+export declare const checkSpec: {
+    readonly name: "kb_check";
+    readonly cliName: "check";
+    readonly description: "Run KB validation rules and return violations. Use before or after mutations, and after meaningful source edits with impact options to surface symbol granularity and semantic-review diagnostics. Do not use for point lookups. No write side effects. Prefer explicit rules for faster iteration; omit rules for final full validation plus full-KB qualityDiagnostics review.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly rules: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly enum: readonly ["must-priority-coverage", "symbol-coverage", "symbol-traceability", "no-dangling-refs", "no-cycles", "required-fields", "deprecated-adr-no-successor", "domain-contradictions", "strict-fact-shape", "strict-req-fact-pairing", "predicate-verifiability", "logic-coverage", "query-plan-safety"];
+                };
+                readonly description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, logic-coverage, query-plan-safety. If omitted, server runs all rules plus the full-KB qualityDiagnostics audit scan; if supplied, server preserves scoped validation and skips the full-KB advisory scan.";
+            };
+            readonly sourceFiles: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Optional repo-relative source files to inspect for early impact diagnostics. Use with includeImpactDiagnostics after meaningful source edits.";
+            };
+            readonly staged: {
+                readonly type: "boolean";
+                readonly description: "When true, inspect staged source changes for impact diagnostics using the shared CLI impact analyzer without shelling out to kibi check.";
+            };
+            readonly includeWorkingTreeDiff: {
+                readonly type: "boolean";
+                readonly description: "When true, inspect current unstaged working-tree diffs for impact diagnostics. Pair with sourceFiles to scope the analysis.";
+            };
+            readonly includeImpactDiagnostics: {
+                readonly type: "boolean";
+                readonly description: "When true, include changed-file impact diagnostics such as symbol_granularity_violation and symbol_semantic_review_needed in structured output.";
+            };
+            readonly maxDiagnostics: {
+                readonly type: "integer";
+                readonly minimum: 0;
+                readonly description: "Optional maximum number of impact diagnostics to return. Graph validation violations are not capped by this value.";
+            };
+            readonly workspaceRoot: {
+                readonly type: "string";
+                readonly description: "Optional workspace root for impact diagnostics and .kb/config.json lookup. Defaults to the MCP server workspace.";
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read", "workspace-read"];
+    readonly execute: typeof executeCheck;
+};
+//# sourceMappingURL=check.d.ts.map

package/dist/public/operations/specs/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/check.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGpD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoEY,CAAC"}