kibi-cli 0.14.0 → 0.17.0

package/dist/operations/semantic-advisor/shared.js

@@ -0,0 +1,209 @@
+import { createHash } from "node:crypto";
+import { semanticClaimKey } from "./clauses.js";
+// implements REQ-mcp-semantic-advisor-preflight
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function stringValue(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function canonicalize(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalize).join(",")}]`;
+    if (isRecord(value)) {
+        return `{${Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${canonicalize(value[key])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function payloadHash(payload) {
+    const stable = Object.fromEntries(Object.entries(payload).filter(([key]) => !key.startsWith("_")));
+    return createHash("sha256").update(canonicalize(stable)).digest("hex");
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function shortHash(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function propertiesOf(payload) {
+    return isRecord(payload.properties) ? payload.properties : {};
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function statementOf(payload) {
+    const properties = propertiesOf(payload);
+    return stringValue(properties.text_ref) || stringValue(properties.title);
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function sourceOf(payload) {
+    return (stringValue(propertiesOf(payload).source) || "mcp://kibi/semantic-advisor");
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function normalizeKey(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/['’]/g, "")
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function normalizePredicateToken(value) {
+    return value
+        .trim()
+        .replace(/\b(?:a|an|the)\b\s*/gi, "")
+        .replace(/['’]/g, "")
+        .replace(/\s+/g, "_")
+        .replace(/[^A-Za-z0-9_-]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function singularize(value) {
+    if (["status", "results"].includes(value))
+        return value;
+    return value.endsWith("s") && value.length > 3 ? value.slice(0, -1) : value;
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function normalizeSubjectKey(value) {
+    return normalizeKey(value).split("_").map(singularize).join(".");
+}
+export function relationship(from, to, type) {
+    return { type, from, to };
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function strictSuggestion(payload, evidence, claim, rationale, confidence = 0.9) {
+    const claimText = statementOf(payload);
+    const reqId = stringValue(payload.id) || `REQ-SEMANTIC-${shortHash(claim.subject_key)}`;
+    const subjectId = `FACT-SUBJECT-${shortHash(claim.subject_key)}`;
+    const propertyId = `FACT-PROP-${shortHash(`${claim.subject_key}.${claim.property_key}.${claim.operator}.${canonicalize(claim)}`)}`;
+    const source = sourceOf(payload);
+    const value = claim.value_string ??
+        claim.value_int ??
+        claim.value_number ??
+        claim.value_bool;
+    const propertyFields = {
+        ...(claim.value_string !== undefined
+            ? { value_string: claim.value_string }
+            : {}),
+        ...(claim.value_int !== undefined ? { value_int: claim.value_int } : {}),
+        ...(claim.value_number !== undefined
+            ? { value_number: claim.value_number }
+            : {}),
+        ...(claim.value_bool !== undefined ? { value_bool: claim.value_bool } : {}),
+        ...(claim.unit ? { unit: claim.unit } : {}),
+    };
+    return {
+        kind: "strict_property",
+        claim_key: semanticClaimKey(claimText),
+        claim_text: claimText,
+        confidence,
+        evidence,
+        rationale,
+        suggested_next_tool: "kb_model_requirement",
+        claim,
+        rejected_alternatives: ["predicate", "observation_review"],
+        applyPlan: [
+            {
+                type: "fact",
+                id: subjectId,
+                properties: {
+                    title: `${claim.subject_key} subject`,
+                    status: "active",
+                    source,
+                    fact_kind: "subject",
+                    subject_key: claim.subject_key,
+                    canonical_key: claim.subject_key,
+                    tags: ["lane:strict", "semantic-advisor-suggestion"],
+                },
+                relationships: [],
+            },
+            {
+                type: "fact",
+                id: propertyId,
+                properties: {
+                    title: `${claim.subject_key} ${claim.property_key}`,
+                    status: "active",
+                    source,
+                    fact_kind: "property_value",
+                    subject_key: claim.subject_key,
+                    property_key: claim.property_key,
+                    operator: claim.operator,
+                    value_type: claim.value_type,
+                    ...propertyFields,
+                    canonical_key: `${claim.subject_key}.${claim.property_key}.${claim.operator}.${value}`,
+                    tags: ["lane:strict", "semantic-advisor-suggestion"],
+                },
+                relationships: [],
+            },
+            {
+                type: "req",
+                id: reqId,
+                properties: {
+                    title: stringValue(propertiesOf(payload).title) ||
+                        "Semantic advisor requirement suggestion",
+                    status: "open",
+                    source,
+                    text_ref: statementOf(payload),
+                    tags: ["semantic-advisor-suggestion"],
+                },
+                relationships: [
+                    relationship(reqId, subjectId, "constrains"),
+                    relationship(reqId, propertyId, "requires_property"),
+                ],
+            },
+        ],
+    };
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function predicateSuggestion(payload, evidence, name, args, rationale, polarity = "assert") {
+    const claimText = statementOf(payload);
+    const canonicalKey = `${name}(${args.join(",")})`;
+    const predicate = {
+        predicate_name: name,
+        predicate_args: args,
+        canonical_key: canonicalKey,
+        polarity,
+    };
+    const factId = `FACT-PRED-${shortHash(canonicalKey)}`;
+    const reqId = stringValue(payload.id);
+    return {
+        kind: "predicate",
+        claim_key: semanticClaimKey(claimText),
+        claim_text: claimText,
+        confidence: 0.84,
+        evidence,
+        rationale,
+        suggested_next_tool: "kb_suggest_predicates",
+        predicate,
+        rejected_alternatives: ["strict_property"],
+        applyPlan: [
+            {
+                type: "fact",
+                id: factId,
+                properties: {
+                    title: `${name} suggestion`,
+                    status: "active",
+                    source: sourceOf(payload),
+                    fact_kind: "predicate",
+                    predicate_name: name,
+                    predicate_args: args,
+                    canonical_key: canonicalKey,
+                    polarity,
+                    tags: ["lane:ontology", "semantic-advisor-suggestion"],
+                },
+                relationships: [],
+            },
+        ],
+        relationshipPlan: reqId
+            ? {
+                applyAfter: factId,
+                requiresExistingReq: reqId,
+                relationship: relationship(reqId, factId, "requires_predicate"),
+            }
+            : null,
+    };
+}

package/dist/operations/semantic-advisor/strict-count-rules.d.ts

@@ -0,0 +1,4 @@
+import { type Payload } from "./shared.js";
+import type { SemanticModelingSuggestion } from "./types.js";
+export declare function detectCountStrictSuggestion(payload: Payload, statement: string): SemanticModelingSuggestion | null;
+//# sourceMappingURL=strict-count-rules.d.ts.map

package/dist/operations/semantic-advisor/strict-count-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strict-count-rules.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/strict-count-rules.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAKb,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAuB7D,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,MAAM,GAChB,0BAA0B,GAAG,IAAI,CA4DnC"}

package/dist/operations/semantic-advisor/strict-count-rules.js

@@ -0,0 +1,62 @@
+import { normalizeKey, normalizeSubjectKey, singularize, strictSuggestion, } from "./shared.js";
+const NUMBER_WORDS = new Map([
+    ["zero", 0],
+    ["one", 1],
+    ["two", 2],
+    ["three", 3],
+    ["four", 4],
+    ["five", 5],
+    ["six", 6],
+    ["seven", 7],
+    ["eight", 8],
+    ["nine", 9],
+    ["ten", 10],
+]);
+function numberToken(value) {
+    return /^\d+$/.test(value)
+        ? Number(value)
+        : (NUMBER_WORDS.get(value.toLowerCase()) ?? null);
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function detectCountStrictSuggestion(payload, statement) {
+    const cardinality = statement.match(/\b(?<operator>at\s+most|at\s+least|exactly|no\s+more\s+than|up\s+to)\s+(?<value>\d+|zero|one|two|three|four|five|six|seven|eight|nine|ten)\s+(?<resource>[a-z][a-z\s_-]*?)\.?$/i);
+    if (cardinality?.groups?.operator &&
+        cardinality.groups.value &&
+        cardinality.groups.resource) {
+        const value = numberToken(cardinality.groups.value);
+        if (value !== null) {
+            const normalized = normalizeKey(cardinality.groups.resource);
+            const tail = singularize(normalized.split("_").at(-1) ?? normalized);
+            const operator = /at\s+least/i.test(cardinality.groups.operator)
+                ? "gte"
+                : /exactly/i.test(cardinality.groups.operator)
+                    ? "eq"
+                    : "lte";
+            return strictSuggestion(payload, `${cardinality.groups.operator} ${cardinality.groups.value}`, {
+                subject_key: tail === "session" ? "user.session" : normalized.replace(/_/g, "."),
+                property_key: normalized.includes("active_session")
+                    ? "active_count"
+                    : "count",
+                operator,
+                value_type: "int",
+                value_int: value,
+            }, "Bounded cardinality is a strict numeric property and should be modeled explicitly.", 0.9);
+        }
+    }
+    const capped = statement.match(/^(?<subject>.+?)\s+cap(?:s|ped)?\s+at\s+(?:(?<property>[a-z][a-z\s_-]*?)\s+)?(?<value>\d+|zero|one|two|three|four|five|six|seven|eight|nine|ten)\.?$/i);
+    if (capped?.groups?.subject && capped.groups.value) {
+        const value = numberToken(capped.groups.value);
+        if (value !== null) {
+            return strictSuggestion(payload, `cap at ${capped.groups.value}`, {
+                subject_key: normalizeSubjectKey(capped.groups.subject),
+                property_key: capped.groups.property
+                    ? `${normalizeKey(capped.groups.property)}_cap`
+                    : "count",
+                operator: "lte",
+                value_type: "int",
+                value_int: value,
+            }, "Cap-at prose is an upper-bound strict property and should be modeled explicitly.", 0.9);
+        }
+    }
+    return null;
+}

package/dist/operations/semantic-advisor/strict-rules.d.ts

@@ -0,0 +1,4 @@
+import { type Payload } from "./shared.js";
+import type { SemanticModelingSuggestion } from "./types.js";
+export declare function detectStrictSuggestion(payload: Payload, statement: string): SemanticModelingSuggestion | null;
+//# sourceMappingURL=strict-rules.d.ts.map

package/dist/operations/semantic-advisor/strict-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strict-rules.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/strict-rules.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGb,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EACV,0BAA0B,EAE3B,MAAM,YAAY,CAAC;AAcpB,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,MAAM,GAChB,0BAA0B,GAAG,IAAI,CA8KnC"}

package/dist/operations/semantic-advisor/strict-rules.js

@@ -0,0 +1,106 @@
+import { normalizeSubjectKey, strictSuggestion, } from "./shared.js";
+import { detectCountStrictSuggestion } from "./strict-count-rules.js";
+function suggestion(payload, match, claim, rationale, confidence, evidence = match[0]) {
+    return strictSuggestion(payload, evidence, claim, rationale, confidence);
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function detectStrictSuggestion(payload, statement) {
+    const expiry = statement.match(/^(?<subject>.+?)\s+expir(?:e|es)\s+after\s+(?<value>\d+)\s+(?<unit>days?|months?|years?|hours?|minutes?)\.?$/i);
+    if (expiry?.groups?.subject && expiry.groups.value && expiry.groups.unit) {
+        const unit = expiry.groups.unit.toLowerCase().replace(/s?$/, "s");
+        return suggestion(payload, expiry, {
+            subject_key: normalizeSubjectKey(expiry.groups.subject),
+            property_key: `expiry_${unit}`,
+            operator: "eq",
+            value_type: "int",
+            value_int: Number(expiry.groups.value),
+            unit,
+        }, "Expiry duration is a scalar strict property and should be explicit.", 0.88, `expire after ${expiry.groups.value} ${expiry.groups.unit}`);
+    }
+    const comparative = statement.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?<operator>less\s+than|greater\s+than|below|above|minimum|maximum|at\s+least|at\s+most)\s+(?<value>\d+)\.?$/i);
+    if (comparative?.groups?.subject &&
+        comparative.groups.operator &&
+        comparative.groups.value) {
+        const operatorText = comparative.groups.operator.toLowerCase();
+        const operator = /less|below/.test(operatorText)
+            ? "lt"
+            : /greater|above/.test(operatorText)
+                ? "gt"
+                : /minimum|least/.test(operatorText)
+                    ? "gte"
+                    : "lte";
+        return suggestion(payload, comparative, {
+            subject_key: normalizeSubjectKey(comparative.groups.subject),
+            property_key: "value",
+            operator,
+            value_type: "int",
+            value_int: Number(comparative.groups.value),
+        }, "Comparative numeric prose is a strict property constraint.", 0.86, `${comparative.groups.operator} ${comparative.groups.value}`);
+    }
+    const precision = statement.match(/^.+?\s+(?:must|shall|should)\s+normalize\s+into\s+canonical\s+integer\s+decisecond\s+(?<subject>[a-z][a-z0-9_-]*)\s+values?\.?$/i);
+    if (precision?.groups?.subject) {
+        return suggestion(payload, precision, {
+            subject_key: normalizeSubjectKey(precision.groups.subject),
+            property_key: "slot_precision",
+            operator: "eq",
+            value_type: "string",
+            value_string: "decisecond",
+        }, "Canonical decisecond slot prose is a strict precision property.", 0.9);
+    }
+    const threshold = statement.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+return\s+within\s+(?<value>\d+)\s+(?<unit>ms|milliseconds?|s|sec|secs|seconds?)\.?$/i);
+    if (threshold?.groups?.subject &&
+        threshold.groups.value &&
+        threshold.groups.unit) {
+        const unit = threshold.groups.unit.toLowerCase().startsWith("m")
+            ? "ms"
+            : "seconds";
+        return suggestion(payload, threshold, {
+            subject_key: normalizeSubjectKey(threshold.groups.subject),
+            property_key: unit === "ms" ? "latency_ms" : "latency_seconds",
+            operator: "lte",
+            value_type: "int",
+            value_int: Number(threshold.groups.value),
+            unit,
+        }, "Response-time thresholds are bounded numeric properties and should be modeled explicitly.", 0.88, `within ${threshold.groups.value} ${threshold.groups.unit}`);
+    }
+    const booleanState = statement.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?<state>enabled|disabled)\.?$/i);
+    if (booleanState?.groups?.subject && booleanState.groups.state) {
+        return suggestion(payload, booleanState, {
+            subject_key: normalizeSubjectKey(booleanState.groups.subject),
+            property_key: "enabled",
+            operator: "eq",
+            value_type: "bool",
+            value_bool: booleanState.groups.state.toLowerCase() === "enabled",
+        }, "Enabled/disabled requirements are boolean properties and can participate in strict checks.", 0.88, `be ${booleanState.groups.state}`);
+    }
+    const retention = statement.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+retained\s+for\s+(?<value>\d+)\s+(?<unit>days?|months?|years?)\.?$/i);
+    if (retention?.groups?.subject &&
+        retention.groups.value &&
+        retention.groups.unit) {
+        const unit = retention.groups.unit.toLowerCase().replace(/s$/, "s");
+        return suggestion(payload, retention, {
+            subject_key: normalizeSubjectKey(retention.groups.subject),
+            property_key: `retention_${unit}`,
+            operator: "eq",
+            value_type: "int",
+            value_int: Number(retention.groups.value),
+            unit,
+        }, "Retention duration is a scalar strict property and can participate in contradiction checks.", 0.92, `retained for ${retention.groups.value} ${retention.groups.unit}`);
+    }
+    const enumSet = statement.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+one\s+of\s+(?<values>.+?)\.?$/i);
+    if (enumSet?.groups?.subject && enumSet.groups.values) {
+        const values = enumSet.groups.values
+            .split(/,|\bor\b/i)
+            .map((value) => value.trim())
+            .filter(Boolean);
+        if (values.length > 1)
+            return suggestion(payload, enumSet, {
+                subject_key: normalizeSubjectKey(enumSet.groups.subject),
+                property_key: "allowed_values",
+                operator: "eq",
+                value_type: "string",
+                value_string: values.join("|"),
+            }, "Allowed enum sets are explicit property values and should not remain prose-only.", 0.86, `one of ${enumSet.groups.values}`);
+    }
+    return detectCountStrictSuggestion(payload, statement);
+}

package/dist/operations/semantic-advisor/types.d.ts

@@ -0,0 +1,195 @@
+import type { LogicRuleIR } from "../../logic/ir.js";
+export type SemanticAdvisorLane = "strict_property" | "predicate" | "rule" | "observation_review" | "none";
+export type SemanticAdvisorReadiness = "modeled" | "needs_modeling" | "not_applicable";
+export type SemanticLogicCoverageStatus = "complete" | "partial" | "unverified" | "not_applicable";
+export type SemanticPropositionRole = "normative" | "definition" | "descriptive" | "condition" | "exception" | "rationale" | "example" | "subjective";
+export type SemanticPropositionStatus = "modeled" | "ambiguous" | "ontology_gap" | "nonlogical" | "missing";
+export interface SemanticPropositionSpan {
+    readonly start: number;
+    readonly end: number;
+}
+export interface SemanticProposition {
+    readonly claim_key: string;
+    readonly claim_text: string;
+    readonly role: SemanticPropositionRole;
+    readonly status: SemanticPropositionStatus;
+    readonly span: SemanticPropositionSpan;
+    readonly payload_hash?: string;
+    readonly semantic_key?: string;
+    readonly reason?: string;
+}
+export interface SemanticInterpretationInput {
+    readonly claim_key: string;
+    readonly claim_text: string;
+    readonly ir: LogicRuleIR;
+    readonly confidence?: number;
+    readonly span?: SemanticPropositionSpan;
+}
+export interface SemanticInterpretationResult {
+    readonly claim_key: string;
+    readonly semantic_key?: string;
+    /** Canonical, schema-validated IR for inspection; never executable source. */
+    readonly normalized_ir?: LogicRuleIR;
+    readonly valid: boolean;
+    readonly confidence: number;
+    readonly errors: readonly string[];
+    readonly warnings: readonly string[];
+    readonly rendered_prolog?: string;
+}
+export type SemanticShadowCueKind = "modal" | "polarity" | "passive_voice" | "nominalization" | "conditional" | "causal" | "prerequisite" | "exception" | "temporal" | "quantifier" | "numeric" | "negation_scope" | "directionality";
+export interface SemanticShadowCue {
+    readonly kind: SemanticShadowCueKind;
+    readonly evidence: string;
+    readonly represented: boolean;
+}
+export type SemanticSignalKind = "normative_modal" | "numeric_cardinality" | "numeric_threshold" | "conditional" | "permission" | "state_or_default";
+export interface SemanticSignal {
+    readonly kind: SemanticSignalKind;
+    readonly evidence: string;
+    readonly candidate_lane: SemanticAdvisorLane;
+    readonly confidence: number;
+}
+export interface SemanticAmbiguityWitness {
+    readonly signal_kind: SemanticSignalKind;
+    readonly evidence: string;
+    readonly interpretations: readonly string[];
+    readonly message: string;
+}
+export interface SemanticStrictPropertyClaim {
+    readonly subject_key: string;
+    readonly property_key: string;
+    readonly operator: "eq" | "neq" | "lt" | "lte" | "gt" | "gte";
+    readonly value_type: "string" | "int" | "number" | "bool";
+    readonly value_string?: string;
+    readonly value_int?: number;
+    readonly value_number?: number;
+    readonly value_bool?: boolean;
+    readonly unit?: string;
+}
+export interface SemanticPredicateClaim {
+    readonly predicate_name: string;
+    readonly predicate_args: readonly string[];
+    readonly canonical_key: string;
+    readonly polarity: "assert" | "deny";
+}
+export type SemanticModelingSuggestion = {
+    readonly kind: "strict_property";
+    readonly claim_key: string;
+    readonly claim_text: string;
+    readonly confidence: number;
+    readonly evidence: string;
+    readonly rationale: string;
+    readonly suggested_next_tool: "kb_model_requirement";
+    readonly claim: SemanticStrictPropertyClaim;
+    readonly rejected_alternatives: readonly string[];
+    readonly applyPlan: readonly Readonly<Record<string, unknown>>[];
+} | {
+    readonly kind: "predicate";
+    readonly claim_key: string;
+    readonly claim_text: string;
+    readonly confidence: number;
+    readonly evidence: string;
+    readonly rationale: string;
+    readonly suggested_next_tool: "kb_suggest_predicates";
+    readonly predicate: SemanticPredicateClaim;
+    readonly rejected_alternatives: readonly string[];
+    readonly applyPlan: readonly Readonly<Record<string, unknown>>[];
+    readonly relationshipPlan: Readonly<Record<string, unknown>> | null;
+} | {
+    readonly kind: "rule";
+    readonly claim_key: string;
+    readonly claim_text: string;
+    readonly confidence: number;
+    readonly evidence: string;
+    readonly rationale: string;
+    readonly suggested_next_tool: "kb_model_requirement";
+    readonly rule: LogicRuleIR;
+    readonly semantic_key: string;
+    readonly rendered_prolog: string;
+    readonly rejected_alternatives: readonly string[];
+    readonly applyPlan: readonly Readonly<Record<string, unknown>>[];
+    readonly relationshipPlan: Readonly<Record<string, unknown>> | null;
+} | {
+    readonly kind: "ambiguity_observation";
+    readonly claim_key: string;
+    readonly claim_text: string;
+    readonly confidence: number;
+    readonly evidence: string;
+    readonly rationale: string;
+    readonly ambiguity: readonly string[];
+    readonly suggested_next_tool: "kb_model_requirement" | "kb_suggest_predicates";
+    readonly applyPlan: readonly Readonly<Record<string, unknown>>[];
+} | {
+    readonly kind: "ontology_gap";
+    readonly claim_key: string;
+    readonly claim_text: string;
+    readonly confidence: number;
+    readonly evidence: string;
+    readonly rationale: string;
+    readonly suggested_next_tool: "kb_suggest_predicates";
+    readonly recommendedPredicateSchema: {
+        readonly predicate_name: string;
+        readonly argument_names: readonly string[];
+        readonly argument_types: readonly string[];
+    } | null;
+    readonly applyPlan: readonly Readonly<Record<string, unknown>>[];
+};
+export interface SemanticAdvisorReceipt {
+    readonly version: string;
+    readonly payload_hash: string;
+    readonly logic_readiness: SemanticAdvisorReadiness;
+    readonly candidate_lane: SemanticAdvisorLane;
+    readonly signals: readonly SemanticSignal[];
+    readonly ambiguity_witnesses: readonly SemanticAmbiguityWitness[];
+    readonly propositions: readonly SemanticProposition[];
+    readonly interpretations: readonly SemanticInterpretationResult[];
+    readonly shadow_analysis: readonly SemanticShadowCue[];
+    readonly suggestions: readonly SemanticModelingSuggestion[];
+    readonly clauses: readonly {
+        readonly claim_key: string;
+        readonly text: string;
+        readonly index: number;
+        readonly normative: boolean;
+        readonly source: "detected" | "supplied";
+        readonly suggestion_indexes: readonly number[];
+    }[];
+    readonly logic_coverage: {
+        readonly status: SemanticLogicCoverageStatus;
+        readonly expected_claim_keys: readonly string[];
+        readonly declared_claim_keys: readonly string[];
+        readonly missing_claim_keys: readonly string[];
+        readonly unresolved_claim_keys: readonly string[];
+    };
+    readonly suggested_next_tools: readonly string[];
+    readonly summary: string;
+}
+export interface SemanticAdvisorInput {
+    readonly payload: Readonly<Record<string, unknown>>;
+    readonly clauses?: readonly string[];
+    readonly interpretations?: readonly SemanticInterpretationInput[];
+}
+export interface SemanticAdvisorAnalysisResult {
+    readonly receipt: SemanticAdvisorReceipt;
+    readonly warnings: readonly string[];
+}
+export interface SemanticAdvisorArgs {
+    readonly text: string;
+    readonly clauses?: readonly string[];
+    readonly type?: string;
+    readonly id?: string;
+    readonly title?: string;
+    readonly source?: string;
+    readonly status?: string;
+    readonly interpretations?: readonly SemanticInterpretationInput[];
+}
+export interface SemanticAdvisorOperationResult {
+    readonly content: readonly {
+        readonly type: "text";
+        readonly text: string;
+    }[];
+    readonly structuredContent: {
+        readonly receipt: SemanticAdvisorReceipt;
+        readonly warnings: readonly string[];
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/operations/semantic-advisor/types.d.ts.map

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

package/dist/operations/semantic-advisor/types.js

@@ -0,0 +1 @@
+export {};

package/dist/prolog/codec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/prolog/codec.ts"],"names":[],"mappings":"AAUA;;;GAGG;AAEH;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGhD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMlD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASpD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGvD;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CA8C5D;AAED,wBAAgB,sBAAsB,CAEpC,UAAU,EAAE,MAAM,GACjB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAoBzB;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAqB3E;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA8B3E;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CA8F5D;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAoD7E;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAGtE;AAqBD,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAenD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAmBlE;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAoBzE;AAuDD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,EAAE,CA6DjE"}
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/prolog/codec.ts"],"names":[],"mappings":"AAUA;;;GAGG;AAEH;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGhD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMlD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASpD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGvD;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CA8C5D;AAED,wBAAgB,sBAAsB,CAEpC,UAAU,EAAE,MAAM,GACjB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAoBzB;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAqB3E;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgD3E;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CA8F5D;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAoD7E;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAGtE;AAqBD,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAenD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAmBlE;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAoBzE;AAuDD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,EAAE,CA6DjE"}

package/dist/prolog/codec.js

@@ -138,7 +138,7 @@ export function parseEntityFromList(data) {
     return { ...props, id: normalizeEntityId(stripOuterQuotes(id)), type };
 }
 export function parsePropertyList(propsStr) {
-    // implements REQ-009
+    // implements REQ-009, REQ-skillopt-logical-evidence-fidelity
     const props = {};
     let cleaned = propsStr.trim();
     if (cleaned.startsWith("[")) {
@@ -157,8 +157,25 @@ export function parsePropertyList(propsStr) {
         if (key === "..." || value === "..." || value === "...|...") {
             continue;
         }
-        const parsed = parsePrologValue(value);
-        props[key] = parsed;
+        let parsed = parsePrologValue(value);
+        if ((key === "rule_ir" || key === "semantic_inventory") &&
+            typeof parsed === "string") {
+            try {
+                parsed = JSON.parse(parsed);
+            }
+            catch {
+                // Keep malformed structured fields as strings so the schema validator
+                // can report the precise payload problem instead of losing evidence.
+            }
+        }
+        if (!Object.hasOwn(props, key)) {
+            props[key] = parsed;
+            continue;
+        }
+        const existing = props[key];
+        props[key] = Array.isArray(existing)
+            ? [...existing, parsed]
+            : [existing, parsed];
     }
     return props;
 }