kibi-cli 0.14.0 → 0.17.0

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

@@ -0,0 +1,185 @@
+import type { OperationContext } from "../runtime-types.js";
+import type { OperationResult } from "../types.js";
+export type FindGapsInput = {
+    readonly type?: string;
+    readonly missingRelationships?: readonly string[];
+    readonly presentRelationships?: readonly string[];
+    readonly tags?: readonly string[];
+    readonly sourceFile?: string;
+    readonly limit?: number;
+    readonly offset?: number;
+};
+export type FindGapsPayload = {
+    readonly rows: readonly Readonly<Record<string, unknown>>[];
+    readonly count: number;
+    readonly meta?: Readonly<Record<string, unknown>>;
+};
+export type CoverageInput = {
+    readonly by?: "req" | "symbol" | "type";
+    readonly tags?: readonly string[];
+    readonly includePassing?: boolean;
+    readonly includeTransitive?: boolean;
+    readonly limit?: number;
+    readonly offset?: number;
+};
+export type CoveragePayload = {
+    readonly summary: Readonly<Record<string, number>>;
+    readonly rows: readonly Readonly<Record<string, unknown>>[];
+    readonly meta?: Readonly<Record<string, unknown>>;
+};
+export type GraphInput = {
+    readonly seedIds: readonly string[];
+    readonly relationships?: readonly string[];
+    readonly direction?: "outgoing" | "incoming" | "both";
+    readonly depth?: number;
+    readonly entityTypes?: readonly string[];
+    readonly maxNodes?: number;
+    readonly maxEdges?: number;
+};
+export type GraphPayload = {
+    readonly nodes: readonly Readonly<Record<string, unknown>>[];
+    readonly edges: readonly Readonly<Record<string, unknown>>[];
+    readonly truncated: boolean;
+    readonly meta?: Readonly<Record<string, unknown>>;
+};
+export declare function executeFindGaps(input: FindGapsInput, context: OperationContext): Promise<OperationResult<FindGapsPayload>>;
+export declare const findGapsSpec: {
+    readonly name: "kb_find_gaps";
+    readonly cliName: "find-gaps";
+    readonly description: "Run bulk missing/present relationship analysis over KB entities. Use for questions like which requirements lack scenarios or tests. No mutation side effects.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
+            };
+            readonly missingRelationships: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly presentRelationships: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly tags: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly sourceFile: {
+                readonly type: "string";
+            };
+            readonly limit: {
+                readonly type: "integer";
+                readonly default: 100;
+            };
+            readonly offset: {
+                readonly type: "integer";
+                readonly default: 0;
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read"];
+    readonly execute: typeof executeFindGaps;
+};
+export declare function executeCoverage(input: CoverageInput, context: OperationContext): Promise<OperationResult<CoveragePayload>>;
+export declare const coverageSpec: {
+    readonly name: "kb_coverage";
+    readonly cliName: "coverage";
+    readonly description: "Generate curated coverage reports for requirements, symbols, or grouped types. Read-only reporting with no mutation side effects.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly by: {
+                readonly type: "string";
+                readonly enum: readonly ["req", "symbol", "type"];
+                readonly default: "req";
+            };
+            readonly tags: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly includePassing: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly includeTransitive: {
+                readonly type: "boolean";
+                readonly default: true;
+            };
+            readonly limit: {
+                readonly type: "integer";
+                readonly default: 100;
+            };
+            readonly offset: {
+                readonly type: "integer";
+                readonly default: 0;
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read"];
+    readonly execute: typeof executeCoverage;
+};
+export declare function executeGraph(input: GraphInput, context: OperationContext): Promise<OperationResult<GraphPayload>>;
+export declare const graphSpec: {
+    readonly name: "kb_graph";
+    readonly cliName: "graph";
+    readonly description: "Run bounded graph traversal from one or more seed IDs across curated relationship types. No mutation side effects.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["seedIds"];
+        readonly properties: {
+            readonly seedIds: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly relationships: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly direction: {
+                readonly type: "string";
+                readonly enum: readonly ["outgoing", "incoming", "both"];
+                readonly default: "outgoing";
+            };
+            readonly depth: {
+                readonly type: "integer";
+                readonly default: 1;
+                readonly minimum: 1;
+                readonly maximum: 5;
+            };
+            readonly entityTypes: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+            readonly maxNodes: {
+                readonly type: "integer";
+                readonly default: 200;
+            };
+            readonly maxEdges: {
+                readonly type: "integer";
+                readonly default: 500;
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read"];
+    readonly execute: typeof executeGraph;
+};
+//# sourceMappingURL=reporting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reporting.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/reporting.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAiB,MAAM,aAAa,CAAC;AAclE,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClD,QAAQ,CAAC,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClD,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,IAAI,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;IAC5D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACnD,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,EAAE,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACxC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,QAAQ,CAAC,IAAI,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;IAC5D,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACnD,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,SAAS,CAAC,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM,CAAC;IACtD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;IAC7D,QAAQ,CAAC,KAAK,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;IAC7D,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACnD,CAAC;AAiBF,wBAAsB,eAAe,CACnC,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC,CA0B3C;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuByC,CAAC;AAEnE,wBAAsB,eAAe,CACnC,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC,CAuB3C;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmByC,CAAC;AAEnE,wBAAsB,YAAY,CAChC,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CA8BxC;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBsC,CAAC"}

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

@@ -0,0 +1,158 @@
+import { runOperationJsonQuery, toPrologAtom, toPrologList, } from "../prolog-json.js";
+const ENTITY_TYPES = [
+    "req",
+    "scenario",
+    "test",
+    "adr",
+    "flag",
+    "event",
+    "symbol",
+    "fact",
+];
+const ENTITY_TYPE_SET = new Set(ENTITY_TYPES);
+function requireProlog(context) {
+    if (context.prolog === undefined) {
+        throw new Error("Reporting operation requires a Prolog runtime");
+    }
+    return context.prolog;
+}
+function validateEntityType(type) {
+    if (type !== undefined && !ENTITY_TYPE_SET.has(type)) {
+        throw new Error(`Invalid type '${type}'. Valid types: ${ENTITY_TYPES.join(", ")}. Use a single type value, or omit this parameter to query all entities.`);
+    }
+}
+export async function executeFindGaps(input, context) {
+    validateEntityType(input.type);
+    try {
+        const payload = await runOperationJsonQuery(requireProlog(context), "discovery.pl", `discovery:find_gaps_json(${toPrologAtom(input.type)}, ${toPrologList(input.missingRelationships)}, ${toPrologList(input.presentRelationships)}, ${toPrologList(input.tags)}, ${toPrologAtom(input.sourceFile)}, ${input.limit ?? 100}, ${input.offset ?? 0}, JsonString)`, "Find-gaps execution");
+        const rows = payload.rows ?? [];
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: rows.length === 0
+                        ? "No matching gaps found."
+                        : `Found ${payload.count ?? rows.length} gap rows. Showing ${rows.length}: ${rows.map((row) => row.id).join(", ")}`,
+                },
+            ],
+            structuredContent: payload,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Find-gaps execution failed: ${message}`);
+    }
+}
+export const findGapsSpec = {
+    name: "kb_find_gaps",
+    cliName: "find-gaps",
+    description: "Run bulk missing/present relationship analysis over KB entities. Use for questions like which requirements lack scenarios or tests. No mutation side effects.",
+    businessInputSchema: {
+        type: "object",
+        properties: {
+            type: {
+                type: "string",
+                enum: ENTITY_TYPES,
+            },
+            missingRelationships: { type: "array", items: { type: "string" } },
+            presentRelationships: { type: "array", items: { type: "string" } },
+            tags: { type: "array", items: { type: "string" } },
+            sourceFile: { type: "string" },
+            limit: { type: "integer", default: 100 },
+            offset: { type: "integer", default: 0 },
+        },
+    },
+    requiresProlog: true,
+    effects: ["kb-read"],
+    execute: executeFindGaps,
+};
+export async function executeCoverage(input, context) {
+    try {
+        const payload = await runOperationJsonQuery(requireProlog(context), "discovery.pl", `discovery:coverage_report_json('${input.by ?? "req"}', ${toPrologList(input.tags)}, ${input.includePassing ?? false}, ${input.includeTransitive ?? true}, ${input.limit ?? 100}, ${input.offset ?? 0}, JsonString)`, "Coverage execution");
+        const fullyCovered = Number(payload.summary?.fullyCovered ?? 0);
+        const total = Number(payload.summary?.total ?? 0);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Coverage summary: ${fullyCovered} fully covered out of ${total}.`,
+                },
+            ],
+            structuredContent: payload,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Coverage execution failed: ${message}`);
+    }
+}
+export const coverageSpec = {
+    name: "kb_coverage",
+    cliName: "coverage",
+    description: "Generate curated coverage reports for requirements, symbols, or grouped types. Read-only reporting with no mutation side effects.",
+    businessInputSchema: {
+        type: "object",
+        properties: {
+            by: { type: "string", enum: ["req", "symbol", "type"], default: "req" },
+            tags: { type: "array", items: { type: "string" } },
+            includePassing: { type: "boolean", default: false },
+            includeTransitive: { type: "boolean", default: true },
+            limit: { type: "integer", default: 100 },
+            offset: { type: "integer", default: 0 },
+        },
+    },
+    requiresProlog: true,
+    effects: ["kb-read"],
+    execute: executeCoverage,
+};
+export async function executeGraph(input, context) {
+    const depth = input.depth ?? 1;
+    if (depth < 1 || depth > 5) {
+        throw new RangeError("Graph depth must be between 1 and 5");
+    }
+    try {
+        const payload = await runOperationJsonQuery(requireProlog(context), "discovery.pl", `discovery:graph_expand_json(${toPrologList(input.seedIds)}, ${toPrologList(input.relationships)}, '${input.direction ?? "outgoing"}', ${depth}, ${toPrologList(input.entityTypes)}, ${input.maxNodes ?? 200}, ${input.maxEdges ?? 500}, JsonString)`, "Graph execution");
+        const nodes = payload.nodes ?? [];
+        const edges = payload.edges ?? [];
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: nodes.length === 0
+                        ? "Graph traversal returned no nodes."
+                        : `Graph traversal returned ${nodes.length} nodes and ${edges.length} edges from ${input.seedIds.join(", ")}.`,
+                },
+            ],
+            structuredContent: payload,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Graph execution failed: ${message}`);
+    }
+}
+export const graphSpec = {
+    name: "kb_graph",
+    cliName: "graph",
+    description: "Run bounded graph traversal from one or more seed IDs across curated relationship types. No mutation side effects.",
+    businessInputSchema: {
+        type: "object",
+        required: ["seedIds"],
+        properties: {
+            seedIds: { type: "array", items: { type: "string" } },
+            relationships: { type: "array", items: { type: "string" } },
+            direction: {
+                type: "string",
+                enum: ["outgoing", "incoming", "both"],
+                default: "outgoing",
+            },
+            depth: { type: "integer", default: 1, minimum: 1, maximum: 5 },
+            entityTypes: { type: "array", items: { type: "string" } },
+            maxNodes: { type: "integer", default: 200 },
+            maxEdges: { type: "integer", default: 500 },
+        },
+    },
+    requiresProlog: true,
+    effects: ["kb-read"],
+    execute: executeGraph,
+};

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

@@ -0,0 +1,81 @@
+import type { SemanticAdvisorArgs, SemanticAdvisorOperationResult } from "../../../operations/semantic-advisor/types.js";
+import type { OperationContext } from "../runtime-types.js";
+export declare function executeSemanticAdvisor(args: SemanticAdvisorArgs, _context?: OperationContext): Promise<SemanticAdvisorOperationResult>;
+declare function executeSemanticAdvisorInput(input: Readonly<Record<string, unknown>>, context: OperationContext): Promise<SemanticAdvisorOperationResult>;
+export declare const semanticAdvisorSpec: {
+    readonly name: "kb_semantic_advisor";
+    readonly cliName: "semantic-advisor";
+    readonly description: "Analyze requirement prose without mutating the KB and return semantic advisor receipts with modeling suggestions. Use before constructing kb_upsert payloads when prose may contain machine-checkable logic. Suggestions can include strict-property facts, predicate facts, ambiguity observations, or ontology-gap observations; all suggestions are advisory and reviewable.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["text"];
+        readonly properties: {
+            readonly text: {
+                readonly type: "string";
+                readonly description: "Requirement prose to inspect for machine-checkable modeling suggestions.";
+            };
+            readonly clauses: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Optional complete list of atomic requirement clauses supplied by the caller. Use this for compound prose so every normative clause receives a stable claim key and independent grounding review.";
+            };
+            readonly interpretations: {
+                readonly type: "array";
+                readonly maxItems: 3;
+                readonly description: "Optional host-LLM typed kibi.logic.v1 interpretations. Kibi validates and canonicalizes them; raw Prolog is not accepted.";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["claim_key", "claim_text", "ir"];
+                    readonly properties: {
+                        readonly claim_key: {
+                            readonly type: "string";
+                        };
+                        readonly claim_text: {
+                            readonly type: "string";
+                        };
+                        readonly confidence: {
+                            readonly type: "number";
+                            readonly minimum: 0;
+                            readonly maximum: 1;
+                        };
+                        readonly span: {
+                            readonly type: "object";
+                        };
+                        readonly ir: {
+                            readonly type: "object";
+                        };
+                    };
+                };
+            };
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
+                readonly default: "req";
+                readonly description: "Entity type context for analysis. Requirement, domain-fact, and supporting prose all receive a proposition ledger; only requirements receive deterministic modeling suggestions.";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly description: "Optional requirement ID used for deterministic draft relationship guidance.";
+            };
+            readonly title: {
+                readonly type: "string";
+                readonly description: "Optional requirement title for draft apply plans.";
+            };
+            readonly source: {
+                readonly type: "string";
+                readonly description: "Optional provenance for draft suggestions.";
+            };
+            readonly status: {
+                readonly type: "string";
+                readonly description: "Optional requirement status for draft suggestions.";
+            };
+        };
+    };
+    readonly requiresProlog: false;
+    readonly effects: readonly ["local-read"];
+    readonly execute: typeof executeSemanticAdvisorInput;
+};
+export {};
+//# sourceMappingURL=semantic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/semantic.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,8BAA8B,EAC/B,MAAM,+CAA+C,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAmB5D,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,mBAAmB,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,OAAO,CAAC,8BAA8B,CAAC,CA8BzC;AAED,iBAAe,2BAA2B,CACxC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,8BAA8B,CAAC,CAiCzC;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EE,CAAC"}

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

@@ -0,0 +1,137 @@
+import { InputError } from "../../../cli-errors.js";
+import { analyzeSemanticAdvisorInput } from "../../../operations/semantic-advisor/analyze-prose.js";
+function requiredText(value) {
+    const text = typeof value === "string" ? value.trim() : "";
+    if (!text) {
+        throw new InputError("VALIDATION_FAILED", "Semantic advisor failed: text must be a non-empty string");
+    }
+    return text;
+}
+function optionalString(value) {
+    const text = typeof value === "string" ? value.trim() : "";
+    return text || undefined;
+}
+export async function executeSemanticAdvisor(args, _context) {
+    const text = requiredText(args.text);
+    const id = optionalString(args.id) ?? "REQ-SEMANTIC-ADVISOR-PREVIEW";
+    const title = optionalString(args.title) ?? text.split(/[.!?]/, 1)[0] ?? text;
+    const source = optionalString(args.source) ?? "mcp://kibi/semantic-advisor";
+    const result = analyzeSemanticAdvisorInput({
+        payload: {
+            type: optionalString(args.type) ?? "req",
+            id,
+            properties: {
+                title,
+                status: optionalString(args.status) ?? "open",
+                source,
+                text_ref: text,
+            },
+        },
+        ...(args.clauses !== undefined ? { clauses: args.clauses } : {}),
+        ...(args.interpretations !== undefined
+            ? { interpretations: args.interpretations }
+            : {}),
+    });
+    return {
+        content: [
+            {
+                type: "text",
+                text: `kb_semantic_advisor: ${result.receipt.summary} Suggestions: ${result.receipt.suggestions.map(({ kind }) => kind).join(", ") || "none"}.`,
+            },
+        ],
+        structuredContent: { receipt: result.receipt, warnings: result.warnings },
+    };
+}
+async function executeSemanticAdvisorInput(input, context) {
+    const type = optionalString(input.type);
+    const id = optionalString(input.id);
+    const title = optionalString(input.title);
+    const source = optionalString(input.source);
+    const status = optionalString(input.status);
+    const clauses = Array.isArray(input.clauses)
+        ? input.clauses.filter((value) => typeof value === "string")
+        : undefined;
+    const interpretations = Array.isArray(input.interpretations)
+        ? input.interpretations.filter((value) => typeof value === "object" && value !== null)
+        : undefined;
+    return executeSemanticAdvisor({
+        text: requiredText(input.text),
+        ...(type ? { type } : {}),
+        ...(id ? { id } : {}),
+        ...(title ? { title } : {}),
+        ...(source ? { source } : {}),
+        ...(status ? { status } : {}),
+        ...(clauses !== undefined ? { clauses } : {}),
+        ...(interpretations !== undefined ? { interpretations } : {}),
+    }, context);
+}
+export const semanticAdvisorSpec = {
+    name: "kb_semantic_advisor",
+    cliName: "semantic-advisor",
+    description: "Analyze requirement prose without mutating the KB and return semantic advisor receipts with modeling suggestions. Use before constructing kb_upsert payloads when prose may contain machine-checkable logic. Suggestions can include strict-property facts, predicate facts, ambiguity observations, or ontology-gap observations; all suggestions are advisory and reviewable.",
+    businessInputSchema: {
+        type: "object",
+        required: ["text"],
+        properties: {
+            text: {
+                type: "string",
+                description: "Requirement prose to inspect for machine-checkable modeling suggestions.",
+            },
+            clauses: {
+                type: "array",
+                items: { type: "string" },
+                description: "Optional complete list of atomic requirement clauses supplied by the caller. Use this for compound prose so every normative clause receives a stable claim key and independent grounding review.",
+            },
+            interpretations: {
+                type: "array",
+                maxItems: 3,
+                description: "Optional host-LLM typed kibi.logic.v1 interpretations. Kibi validates and canonicalizes them; raw Prolog is not accepted.",
+                items: {
+                    type: "object",
+                    required: ["claim_key", "claim_text", "ir"],
+                    properties: {
+                        claim_key: { type: "string" },
+                        claim_text: { type: "string" },
+                        confidence: { type: "number", minimum: 0, maximum: 1 },
+                        span: { type: "object" },
+                        ir: { type: "object" },
+                    },
+                },
+            },
+            type: {
+                type: "string",
+                enum: [
+                    "req",
+                    "scenario",
+                    "test",
+                    "adr",
+                    "flag",
+                    "event",
+                    "symbol",
+                    "fact",
+                ],
+                default: "req",
+                description: "Entity type context for analysis. Requirement, domain-fact, and supporting prose all receive a proposition ledger; only requirements receive deterministic modeling suggestions.",
+            },
+            id: {
+                type: "string",
+                description: "Optional requirement ID used for deterministic draft relationship guidance.",
+            },
+            title: {
+                type: "string",
+                description: "Optional requirement title for draft apply plans.",
+            },
+            source: {
+                type: "string",
+                description: "Optional provenance for draft suggestions.",
+            },
+            status: {
+                type: "string",
+                description: "Optional requirement status for draft suggestions.",
+            },
+        },
+    },
+    requiresProlog: false,
+    effects: ["local-read"],
+    execute: executeSemanticAdvisorInput,
+};

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

@@ -0,0 +1,70 @@
+import { type SkillManifest } from "../../skills.js";
+import type { OperationContext } from "../runtime-types.js";
+import type { OperationResult } from "../types.js";
+declare function executeSkillsList(_input: Readonly<Record<string, unknown>>, _context: OperationContext): Promise<OperationResult<{
+    readonly skills: readonly SkillManifest[];
+}>>;
+declare function executeSkillsLoad(input: Readonly<Record<string, unknown>>, _context: OperationContext): Promise<OperationResult<{
+    readonly metadata: SkillManifest;
+    readonly body: string;
+    readonly resources: readonly string[];
+    readonly contentHash: string;
+    readonly sourceType: "bundled";
+}>>;
+declare function executeSkillsRead(input: Readonly<Record<string, unknown>>, _context: OperationContext): Promise<OperationResult<{
+    readonly content: string;
+}>>;
+export declare const skillsListSpec: {
+    readonly name: "kb_skills_list";
+    readonly cliName: "skills list";
+    readonly description: "List bundled Kibi agent skills available for progressive disclosure. Read-only; does not mutate the KB or require Prolog.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+    };
+    readonly requiresProlog: false;
+    readonly effects: readonly ["local-read"];
+    readonly execute: typeof executeSkillsList;
+};
+export declare const skillsLoadSpec: {
+    readonly name: "kb_skills_load";
+    readonly cliName: "skills load";
+    readonly description: "Load a bundled Kibi agent skill by ID, returning its manifest metadata, Markdown body, declared resources, content hash, and source type. Read-only; does not execute scripts or require Prolog.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["id"];
+        readonly properties: {
+            readonly id: {
+                readonly type: "string";
+                readonly description: "Bundled skill ID to load. Example: 'kibi-usage'.";
+            };
+        };
+    };
+    readonly requiresProlog: false;
+    readonly effects: readonly ["local-read"];
+    readonly execute: typeof executeSkillsLoad;
+};
+export declare const skillsReadSpec: {
+    readonly name: "kb_skills_read";
+    readonly cliName: "skills read";
+    readonly description: "Read a declared resource from a bundled Kibi agent skill. Resource paths are restricted to the skill manifest; arbitrary file paths are not exposed. Read-only; does not require Prolog.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["id", "resource"];
+        readonly properties: {
+            readonly id: {
+                readonly type: "string";
+                readonly description: "Bundled skill ID. Example: 'kibi-usage'.";
+            };
+            readonly resource: {
+                readonly type: "string";
+                readonly description: "Manifest-declared resource path to read. Example: 'resources/workflows.md'.";
+            };
+        };
+    };
+    readonly requiresProlog: false;
+    readonly effects: readonly ["local-read"];
+    readonly execute: typeof executeSkillsRead;
+};
+export {};
+//# sourceMappingURL=skills.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/skills.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,aAAa,EAInB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAiB,MAAM,aAAa,CAAC;AAQlE,iBAAe,iBAAiB,CAC9B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,eAAe,CAAC;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAA;CAAE,CAAC,CAAC,CASzE;AAED,iBAAe,iBAAiB,CAC9B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CACR,eAAe,CAAC;IACd,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;CAChC,CAAC,CACH,CAwBA;AAED,iBAAe,iBAAiB,CAC9B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,eAAe,CAAC;IAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAexD;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;CASO,CAAC;AAEnC,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;CAkBO,CAAC;AAEnC,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;CAuBO,CAAC"}