kibi-cli 2.0.0 → 2.2.0

package/dist/operations/semantic-advisor/predicate-rules-core.js

@@ -1,140 +1,7 @@
-import { commaList, normalizeKey, normalizePredicateToken, normalizeSubjectKey, singularize, } from "./predicate-rule.js";
-export const CORE_PREDICATE_RULES = [
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)?\s*(?:stay|remain)?\s*disabled\s+until\s+(?<condition>.+?)\.?$/i,
-        name: "guard",
-        args: (g) => [
-            normalizeKey(g.subject ?? ""),
-            normalizePredicateToken(g.condition ?? ""),
-            "disabled",
-        ],
-        rationale: "Disabled-until prose defines a condition that guards behavior availability and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?<before>[a-z][a-z\s_-]*?)\s+before\s+(?<after>.+?)\.?$/i,
-        name: "temporal_order",
-        args: (g) => [
-            normalizeKey(g.subject ?? "").replace(/_/g, "."),
-            normalizePredicateToken(g.before ?? ""),
-            normalizePredicateToken(g.after ?? ""),
-        ],
-        rationale: "Before/after ordering is relational temporal logic and should be modeled as a predicate.",
-    },
-    {
-        pattern: /^if\s+(?:(?:a|an|the)\s+)?(?<conditionSubject>[a-z][a-z_-]*)\s+(?<condition>.+?),\s*(?:it|they|the\s+[a-z][a-z\s_-]*?)\s+(?<behavior>.+?)\.?$/i,
-        name: "conditional_behavior",
-        args: (g) => [
-            singularize(normalizeKey(g.conditionSubject ?? "")),
-            normalizePredicateToken(g.condition ?? ""),
-            normalizePredicateToken(g.behavior ?? ""),
-        ],
-        rationale: "If/then requirement prose is conditional behavior and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^when\s+(?<condition>.+?),\s*(?:the\s+)?(?<subject>.+?)\s+(?:must|shall|should)\s+(?<behavior>.+?)\.?$/i,
-        name: "conditional_behavior",
-        args: (g) => [
-            normalizeKey(g.subject ?? ""),
-            normalizePredicateToken(g.condition ?? ""),
-            normalizePredicateToken(g.behavior ?? "behavior"),
-        ],
-        rationale: "When/must prose is conditional behavior and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?:the\s+)?(?<subject>[a-z][a-z\s_-]*?)\s+(?:must|shall|should)\s+(?<behavior>.+?)\s+unless\s+(?:the\s+)?(?<exception>.+?)\.?$/i,
-        name: "exception_rule",
-        args: (g) => [
-            normalizeSubjectKey(g.subject ?? ""),
-            normalizePredicateToken(g.behavior ?? ""),
-            normalizePredicateToken(g.exception ?? ""),
-        ],
-        rationale: "Unless/except prose defines an explicit exception to required behavior and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<left>.+?)\s+and\s+(?<right>.+?)\s+(?:must|shall|should)\s+be\s+mutually\s+exclusive\.?$/i,
-        name: "mutual_exclusion",
-        args: (g) => [normalizeKey(g.left ?? ""), normalizeKey(g.right ?? "")],
-        rationale: "Mutual-exclusion prose is a relational constraint and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+requires\s+(?<prerequisite>.+?)\s+before\s+(?<dependent>.+?)\.?$/i,
-        name: "dependency_rule",
-        args: (g) => [
-            normalizeKey(g.subject ?? ""),
-            normalizePredicateToken(g.prerequisite ?? ""),
-            normalizePredicateToken(g.dependent ?? ""),
-        ],
-        rationale: "Requires-before prose defines a prerequisite relationship and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<resource>.+?)\s+(?:is|are)\s+owned\s+by\s+(?:the\s+)?(?<owner>.+?)\.?$/i,
-        name: "ownership_rule",
-        args: (g) => [normalizeKey(g.resource ?? ""), normalizeKey(g.owner ?? "")],
-        rationale: "Ownership prose assigns responsibility for a resource or behavior and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<inputs>.+?)\s+saved\s+in\s+the\s+same\s+(?<slot>.+?)\s+must\s+merge\s+into\s+(?<target>.+?)\s+instead\s+of\s+creating\s+.+?\.?$/i,
-        name: "merge_policy",
-        args: (g) => [
-            normalizePredicateToken(g.inputs ?? ""),
-            normalizePredicateToken(g.slot ?? ""),
-            normalizePredicateToken(g.target ?? ""),
-        ],
-        rationale: "Same-slot merge prose defines ontology-lite merge behavior and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+retry\s+up\s+to\s+(?<count>\d+)\s+(?<unit>times|attempts?)\.?$/i,
-        name: "retry_policy",
-        args: (g) => [
-            normalizeKey(g.subject ?? ""),
-            g.count ?? "",
-            normalizeKey(g.unit ?? ""),
-        ],
-        rationale: "Retry prose defines bounded recovery behavior and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+escalate\s+to\s+(?<target>.+?)\s+after\s+(?<delay>\d+)\s+(?<unit>[a-z]+)\.?$/i,
-        name: "escalation_rule",
-        args: (g) => [
-            normalizeKey(g.subject ?? ""),
-            normalizeKey(g.target ?? ""),
-            g.delay ?? "",
-            normalizeKey(g.unit ?? ""),
-        ],
-        rationale: "Escalation prose defines delayed handoff behavior and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+availability\s+(?:must|shall|should)\s+be\s+at\s+least\s+(?<threshold>\d+(?:\.\d+)?)\s+(?<unit>percent|%)\s+(?<window>[a-z]+)\.?$/i,
-        name: "availability_sla",
-        args: (g) => [
-            normalizeKey(g.subject ?? ""),
-            g.threshold ?? "",
-            g.unit === "%" ? "percent" : normalizeKey(g.unit ?? ""),
-            normalizeKey(g.window ?? ""),
-        ],
-        rationale: "Availability SLA prose defines a service target over a window and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+notify\s+(?<recipient>.+?)\s+by\s+(?<channel>[a-z]+)\.?$/i,
-        name: "notification_route",
-        args: (g) => [
-            normalizeKey(g.subject ?? ""),
-            normalizeKey(g.recipient ?? ""),
-            normalizeKey(g.channel ?? ""),
-        ],
-        rationale: "Notification routing prose defines a recipient and channel and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+idempotent\s+by\s+(?<key>.+?)\.?$/i,
-        name: "idempotency_rule",
-        args: (g) => [normalizeKey(g.subject ?? ""), normalizeKey(g.key ?? "")],
-        rationale: "Idempotency prose defines deduplication behavior and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+deduplicated\s+to\s+prevent\s+redundant\s+requests\s+during\s+(?<key>.+?)\.?$/i,
-        name: "idempotency_rule",
-        args: (g) => [normalizeKey(g.subject ?? ""), normalizeKey(g.key ?? "")],
-        rationale: "Deduplication prose defines idempotent handling of repeated or concurrent operations and should be queryable as a predicate.",
-    },
-];
-export { commaList };
+/**
+ * Single source of truth: re-export builtin ontology rule tables so CLI
+ * coverage/tests cannot drift from kibi-plugin-builtin.
+ */
+// implements REQ-capability-plugin-builtin-parity-v1
+import { CORE_PREDICATE_RULES as BUILTIN_CORE_PREDICATE_RULES } from "kibi-plugin-builtin";
+export const CORE_PREDICATE_RULES = BUILTIN_CORE_PREDICATE_RULES;

package/dist/operations/semantic-advisor/predicate-rules-launcher.d.ts

@@ -1,51 +1,50 @@
 /**
- * Launcher contracts are deliberately matched as complete, domain-specific
- * propositions. Generic words such as "error" or "workspace" are not enough
- * to route a requirement into this family.
+ * Single source of truth: re-export builtin ontology rule tables so CLI
+ * coverage/tests cannot drift from kibi-plugin-builtin.
  */
+import { exactLauncherPredicateArgs as builtinExactLauncherPredicateArgs } from "kibi-plugin-builtin";
 export declare const LAUNCHER_PREDICATE_RULES: readonly [{
     readonly pattern: RegExp;
     readonly name: "dependency_resolution_policy";
+    readonly arity: 4;
     readonly args: (groups: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Consumer-local dependency resolution and acquisition restrictions are a reusable launcher policy predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "ordered_resolution_strategy";
+    readonly arity: 3;
     readonly args: (groups: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "An ordered workspace candidate list with a validated cwd fallback is a deterministic resolution strategy.";
 }, {
     readonly pattern: RegExp;
     readonly name: "resolution_failure_policy";
+    readonly arity: 3;
     readonly args: (groups: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Invalid unresolved placeholders are an explicit resolution failure condition.";
 }, {
     readonly pattern: RegExp;
     readonly name: "resolution_failure_policy";
+    readonly arity: 3;
     readonly args: (groups: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Ambiguous usable roots require a deterministic, clearly reported resolution failure.";
 }, {
     readonly pattern: RegExp;
     readonly name: "exception_rule";
+    readonly arity: 3;
     readonly args: () => string[];
     readonly rationale: "Consumer-scoped package resolution with an explicitly authorized package-manager exception is an exception policy.";
 }, {
     readonly pattern: RegExp;
     readonly name: "process_delegation_contract";
+    readonly arity: 6;
     readonly args: () => string[];
     readonly rationale: "Executable, cwd, environment, stdio, and termination propagation form a reusable process delegation contract.";
 }, {
     readonly pattern: RegExp;
     readonly name: "failure_behavior";
+    readonly arity: 3;
     readonly args: () => string[];
     readonly rationale: "A missing project-local dependency with an actionable error is a reusable launcher failure behavior.";
 }];
-/**
- * Return the reviewed argument tuple for an exact launcher proposition.
- *
- * The modeling route uses this same rule table as the semantic advisor so an
- * inferred apply plan cannot silently drift from the canonical ontology
- * interpretation. Non-exact prose deliberately returns null and must remain
- * reviewable through explicit argument bindings.
- */
-export declare function exactLauncherPredicateArgs(predicateName: string, text: string): readonly string[] | null;
+export declare const exactLauncherPredicateArgs: typeof builtinExactLauncherPredicateArgs;
 //# sourceMappingURL=predicate-rules-launcher.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"predicate-rules-launcher.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/predicate-rules-launcher.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoFQ,CAAC;AAE9C;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,MAAM,GACX,SAAS,MAAM,EAAE,GAAG,IAAI,CAO1B"}
+{"version":3,"file":"predicate-rules-launcher.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/predicate-rules-launcher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAEL,0BAA0B,IAAI,iCAAiC,EAChE,MAAM,qBAAqB,CAAC;AAE7B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAmC,CAAC;AACzE,eAAO,MAAM,0BAA0B,0CAAoC,CAAC"}

package/dist/operations/semantic-advisor/predicate-rules-launcher.js

@@ -1,96 +1,8 @@
-import { normalizeKey, normalizePredicateToken, } from "./predicate-rule.js";
 /**
- * Launcher contracts are deliberately matched as complete, domain-specific
- * propositions. Generic words such as "error" or "workspace" are not enough
- * to route a requirement into this family.
+ * Single source of truth: re-export builtin ontology rule tables so CLI
+ * coverage/tests cannot drift from kibi-plugin-builtin.
  */
-export const LAUNCHER_PREDICATE_RULES = [
-    {
-        pattern: /^(?<subject>.+?)\s+must\s+resolve\s+and\s+execute\s+the\s+(?<dependency>.+?)\s+without\s+downloading\s+packages\s+or\s+using\s+a\s+global\s+or\s+plugin-local\s+runtime\.?$/i,
-        name: "dependency_resolution_policy",
-        args: (groups) => [
-            normalizeKey(groups.subject ?? ""),
-            normalizePredicateToken(groups.dependency ?? "dependency"),
-            "consumer_local",
-            "no_download",
-        ],
-        rationale: "Consumer-local dependency resolution and acquisition restrictions are a reusable launcher policy predicate.",
-    },
-    {
-        pattern: /^it\s+must\s+resolve\s+the\s+consumer\s+workspace\s+in\s+deterministic\s+order:\s*(?<sources>.+?)\s+then\s+cwd\s+only\s+when\s+(?<condition>.+?)\.?$/i,
-        name: "ordered_resolution_strategy",
-        args: (groups) => [
-            "launcher",
-            normalizePredicateToken(groups.sources ?? "ordered_sources"),
-            normalizePredicateToken(groups.condition ?? "cwd_requires_validation"),
-        ],
-        rationale: "An ordered workspace candidate list with a validated cwd fallback is a deterministic resolution strategy.",
-    },
-    {
-        pattern: /^(?<condition>unresolved\s+placeholders?)\s+are\s+invalid\.?$/i,
-        name: "resolution_failure_policy",
-        args: (groups) => [
-            "launcher",
-            normalizePredicateToken(groups.condition ?? "invalid_placeholder"),
-            "reject_input",
-        ],
-        rationale: "Invalid unresolved placeholders are an explicit resolution failure condition.",
-    },
-    {
-        pattern: /^(?<condition>ambiguous\s+(?:multiple\s+)?usable\s+roots?)\s+fail\s+clearly\.?$/i,
-        name: "resolution_failure_policy",
-        args: (groups) => [
-            "launcher",
-            normalizePredicateToken(groups.condition ?? "ambiguous_root"),
-            "clear_error",
-        ],
-        rationale: "Ambiguous usable roots require a deterministic, clearly reported resolution failure.",
-    },
-    {
-        pattern: /^(?<subject>the\s+launcher)\s+must\s+resolve\s+kibi-mcp\s+through\s+consumer-scoped\s+node\s+package\s+semantics\s+including\s+exports-restricted\s+and\s+pnpm-style\s+layouts,\s+and\s+reject\s+packages\s+outside\s+consumer\s+scope\s+unless\s+active\s+package-manager\s+semantics\s+authorize\s+it\.?$/i,
-        name: "exception_rule",
-        args: () => [
-            "launcher",
-            "consumer_scoped_node_package_semantics",
-            "active_package_manager_semantics",
-        ],
-        rationale: "Consumer-scoped package resolution with an explicitly authorized package-manager exception is an exception policy.",
-    },
-    {
-        pattern: /^(?<subject>it)\s+must\s+spawn\s+the\s+declared\s+kibi-mcp\s+bin\s+with\s+cwd\s+and\s+kibi_workspace\s+set\s+to\s+the\s+consumer\s+workspace,\s+preserve\s+stdio,\s+and\s+propagate\s+child\s+exit\s+codes\s+and\s+termination\s+signals\.?$/i,
-        name: "process_delegation_contract",
-        args: () => [
-            "launcher",
-            "resolved_executable",
-            "consumer_cwd",
-            "consumer_workspace_environment",
-            "inherited_stdio",
-            "propagate_exit_and_termination",
-        ],
-        rationale: "Executable, cwd, environment, stdio, and termination propagation form a reusable process delegation contract.",
-    },
-    {
-        pattern: /^(?<subject>missing)\s+project-local\s+kibi-mcp\s+must\s+produce\s+a\s+concise\s+actionable\s+error\.?$/i,
-        name: "failure_behavior",
-        args: () => ["launcher", "missing_dependency", "actionable_error"],
-        rationale: "A missing project-local dependency with an actionable error is a reusable launcher failure behavior.",
-    },
-];
-/**
- * Return the reviewed argument tuple for an exact launcher proposition.
- *
- * The modeling route uses this same rule table as the semantic advisor so an
- * inferred apply plan cannot silently drift from the canonical ontology
- * interpretation. Non-exact prose deliberately returns null and must remain
- * reviewable through explicit argument bindings.
- */
-export function exactLauncherPredicateArgs(predicateName, text) {
-    for (const rule of LAUNCHER_PREDICATE_RULES) {
-        if (rule.name !== predicateName)
-            continue;
-        const match = text.match(rule.pattern);
-        if (match)
-            return [...rule.args(match.groups ?? {})];
-    }
-    return null;
-}
+// implements REQ-capability-plugin-builtin-parity-v1
+import { LAUNCHER_PREDICATE_RULES as BUILTIN_LAUNCHER_PREDICATE_RULES, exactLauncherPredicateArgs as builtinExactLauncherPredicateArgs, } from "kibi-plugin-builtin";
+export const LAUNCHER_PREDICATE_RULES = BUILTIN_LAUNCHER_PREDICATE_RULES;
+export const exactLauncherPredicateArgs = builtinExactLauncherPredicateArgs;

package/dist/operations/semantic-advisor/predicate-rules-policy.d.ts

@@ -1,82 +1,98 @@
 export declare const POLICY_PREDICATE_RULES: readonly [{
     readonly pattern: RegExp;
     readonly name: "data_residency_rule";
+    readonly arity: 2;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Data residency prose defines regional storage or processing constraints and should be queryable as a predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "audit_event_rule";
+    readonly arity: 2;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Audit logging prose defines durable audit evidence and should be queryable as a predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "consent_rule";
+    readonly arity: 3;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Consent prose defines a privacy prerequisite and should be queryable as a predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "lifecycle_rule";
+    readonly arity: 4;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Lifecycle prose defines archive/delete/expiry behavior over time and should be queryable as a predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "conflict_resolution_rule";
+    readonly arity: 2;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Conflict-resolution prose defines synchronization merge behavior and should be queryable as a predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "fallback_rule";
+    readonly arity: 3;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Fallback prose defines degraded behavior under a condition and should be queryable as a predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "batch_operation_rule";
+    readonly arity: 3;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Batching prose defines bounded bulk-processing behavior and should be queryable as a predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "consistency_rule";
+    readonly arity: 2;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Consistency prose defines reference integrity and should be queryable as a predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "build_constraint";
+    readonly arity: 3;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Build-time prose defines deterministic generation or deployment constraints and should be queryable as a predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "environment_safety_rule";
+    readonly arity: 3;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Environment safety prose defines action permissions by deployment environment and should be queryable as a predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "schema_invariant_rule";
+    readonly arity: 3;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Schema invariant prose defines a field-level invariant and should be queryable as a predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "coding_standard_rule";
+    readonly arity: 3;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Coding-standard prose defines developer-facing API or pattern requirements and should be queryable as a predicate.";
     readonly accepts: (statement: string) => boolean;
 }, {
     readonly pattern: RegExp;
     readonly name: "migration_boundary_rule";
+    readonly arity: 3;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Migration-boundary prose defines legacy input usage limits and should be queryable as a predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "absence_requirement";
+    readonly arity: 2;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Absence prose defines negative existence requirements and should be queryable as a predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "absence_requirement";
+    readonly arity: 2;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Declarative no-X prose defines a negative existence requirement and should be queryable as a predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "offline_behavior_rule";
+    readonly arity: 3;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Offline behavior prose defines resilient/non-blocking behavior under offline conditions and should be queryable as a predicate.";
 }];

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

@@ -1 +1 @@
-{"version":3,"file":"predicate-rules-policy.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/predicate-rules-policy.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsLU,CAAC"}
+{"version":3,"file":"predicate-rules-policy.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/predicate-rules-policy.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiC,CAAC"}

package/dist/operations/semantic-advisor/predicate-rules-policy.js

@@ -1,150 +1,7 @@
-import { normalizeKey, normalizePredicateToken, } from "./predicate-rule.js";
-export const POLICY_PREDICATE_RULES = [
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?:stored|processed|kept)\s+in\s+(?:the\s+)?(?<region>.+?\b(?:region|jurisdiction|country|zone|area))\.?$/i,
-        name: "data_residency_rule",
-        args: (g) => [normalizeKey(g.subject ?? ""), normalizeKey(g.region ?? "")],
-        rationale: "Data residency prose defines regional storage or processing constraints and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?:recorded|logged|audited)\s+in\s+(?:the\s+)?(?<log>audit\s+(?:log|trail))\.?$/i,
-        name: "audit_event_rule",
-        args: (g) => [normalizeKey(g.subject ?? ""), normalizeKey(g.log ?? "")],
-        rationale: "Audit logging prose defines durable audit evidence and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+require\s+(?<consent>.+?consent)\s+before\s+(?<purpose>.+?)\.?$/i,
-        name: "consent_rule",
-        args: (g) => [
-            normalizeKey(g.subject ?? ""),
-            normalizeKey(g.consent ?? ""),
-            normalizePredicateToken(g.purpose ?? ""),
-        ],
-        rationale: "Consent prose defines a privacy prerequisite and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?<action>archived|deleted|expired)\s+after\s+(?<duration>\d+)\s+(?<unit>[a-z]+)\.?$/i,
-        name: "lifecycle_rule",
-        args: (g) => [
-            normalizeKey(g.subject ?? ""),
-            normalizeKey(g.action ?? ""),
-            g.duration ?? "",
-            normalizeKey(g.unit ?? ""),
-        ],
-        rationale: "Lifecycle prose defines archive/delete/expiry behavior over time and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^when\s+(?<subject>.+?)\s+conflicts?,\s+(?:the\s+)?(?<strategy>.+?)\.?$/i,
-        name: "conflict_resolution_rule",
-        args: (g) => [
-            normalizeKey(g.subject ?? ""),
-            normalizePredicateToken(g.strategy ?? ""),
-        ],
-        rationale: "Conflict-resolution prose defines synchronization merge behavior and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^if\s+(?<condition>.+?),\s+(?<subject>.+?)\s+(?:must|shall|should)\s+fall\s+back\s+to\s+(?<target>.+?)\.?$/i,
-        name: "fallback_rule",
-        args: (g) => [
-            normalizePredicateToken(g.condition ?? ""),
-            normalizeKey(g.subject ?? ""),
-            normalizePredicateToken(g.target ?? ""),
-        ],
-        rationale: "Fallback prose defines degraded behavior under a condition and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+process\s+(?<resource>.+?)\s+in\s+batches\s+of\s+(?<size>\d+)\.?$/i,
-        name: "batch_operation_rule",
-        args: (g) => [
-            normalizeKey(g.subject ?? ""),
-            normalizeKey(g.resource ?? ""),
-            g.size ?? "",
-        ],
-        rationale: "Batching prose defines bounded bulk-processing behavior and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+reference\s+(?<target>an?\s+existing\s+.+?)\.?$/i,
-        name: "consistency_rule",
-        args: (g) => [
-            normalizeKey(g.subject ?? ""),
-            normalizePredicateToken(g.target ?? ""),
-        ],
-        rationale: "Consistency prose defines reference integrity and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?<property>deterministic)\s+at\s+(?<scope>build\s+time)\.?$/i,
-        name: "build_constraint",
-        args: (g) => [
-            normalizeKey(g.subject ?? ""),
-            normalizePredicateToken(g.property ?? "property"),
-            normalizePredicateToken(g.scope ?? "scope"),
-        ],
-        rationale: "Build-time prose defines deterministic generation or deployment constraints and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<action>.+?)\s+(?:must|shall|should)\s+be\s+(?<decision>forbidden|read-only|allowed)\s+in\s+(?<environment>production|staging|development)\.?$/i,
-        name: "environment_safety_rule",
-        args: (g) => [
-            normalizeKey(g.action ?? ""),
-            normalizePredicateToken(g.decision ?? "decision"),
-            normalizeKey(g.environment ?? ""),
-        ],
-        rationale: "Environment safety prose defines action permissions by deployment environment and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<field>.+?)\s+(?:must|shall|should)\s+be\s+(?<kind>immutable)\s+after\s+(?<scope>.+?)\.?$/i,
-        name: "schema_invariant_rule",
-        args: (g) => [
-            normalizeKey(g.field ?? ""),
-            normalizePredicateToken(g.kind ?? "invariant"),
-            normalizePredicateToken(`after ${g.scope ?? ""}`),
-        ],
-        rationale: "Schema invariant prose defines a field-level invariant and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+(?<action>use|avoid)\s+(?<target>.+?)\.?$/i,
-        name: "coding_standard_rule",
-        args: (g) => [
-            normalizeKey(g.subject ?? ""),
-            normalizePredicateToken(g.action ?? "action"),
-            normalizePredicateToken(g.target ?? ""),
-        ],
-        rationale: "Coding-standard prose defines developer-facing API or pattern requirements and should be queryable as a predicate.",
-        accepts: (statement) => /\b(?:api|apis|code|component|computed|framework|hook|pattern|signal|schema|type)\b/i.test(statement),
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+may\s+only\s+be\s+(?<action>read)\s+as\s+(?<scope>migration\s+input)(?:\s+by\s+.+?)?\.?$/i,
-        name: "migration_boundary_rule",
-        args: (g) => [
-            normalizeKey(g.subject ?? ""),
-            normalizePredicateToken(g.action ?? "action"),
-            normalizePredicateToken(g.scope ?? ""),
-        ],
-        rationale: "Migration-boundary prose defines legacy input usage limits and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?<state>absent|removed)\.?$/i,
-        name: "absence_requirement",
-        args: (g) => [
-            normalizePredicateToken(g.subject ?? ""),
-            normalizePredicateToken(g.state ?? ""),
-        ],
-        rationale: "Absence prose defines negative existence requirements and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^no\s+(?<subject>.+?)\.?$/i,
-        name: "absence_requirement",
-        args: (g) => [normalizePredicateToken(g.subject ?? ""), "absent"],
-        rationale: "Declarative no-X prose defines a negative existence requirement and should be queryable as a predicate.",
-    },
-    {
-        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?<behavior>non-blocking|resilient)\s+during\s+(?<condition>offline\s+conditions)\.?$/i,
-        name: "offline_behavior_rule",
-        args: (g) => [
-            normalizeKey(g.subject ?? ""),
-            normalizePredicateToken(g.behavior ?? "behavior"),
-            normalizePredicateToken(g.condition ?? ""),
-        ],
-        rationale: "Offline behavior prose defines resilient/non-blocking behavior under offline conditions and should be queryable as a predicate.",
-    },
-];
+/**
+ * Single source of truth: re-export builtin ontology rule tables so CLI
+ * coverage/tests cannot drift from kibi-plugin-builtin.
+ */
+// implements REQ-capability-plugin-builtin-parity-v1
+import { POLICY_PREDICATE_RULES as BUILTIN_POLICY_PREDICATE_RULES } from "kibi-plugin-builtin";
+export const POLICY_PREDICATE_RULES = BUILTIN_POLICY_PREDICATE_RULES;

package/dist/operations/semantic-advisor/predicate-rules-product-tail.d.ts

@@ -1,47 +1,56 @@
 export declare const PRODUCT_TAIL_PREDICATE_RULES: readonly [{
     readonly pattern: RegExp;
     readonly name: "throttle_policy_rule";
+    readonly arity: 2;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Throttle-policy prose defines throttling behavior under high-frequency conditions and should be queryable as a predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "temporal_order";
+    readonly arity: 3;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Initializes-after prose defines temporal readiness ordering and should be queryable as a predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "state_transition";
+    readonly arity: 4;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "State transitions have source state, target state, and trigger; model them as predicate facts.";
 }, {
     readonly pattern: RegExp;
     readonly name: "permission_rule";
+    readonly arity: 4;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Prohibitions are negative permission rules and should preserve deny polarity.";
     readonly polarity: "deny";
 }, {
     readonly pattern: RegExp;
     readonly name: "uniqueness_constraint";
+    readonly arity: 2;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Per-scope uniqueness is relational and should be modeled as a predicate rather than a generic count.";
 }, {
     readonly pattern: RegExp;
     readonly name: "default_value";
+    readonly arity: 3;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Defaults are relational product behavior and should be explicit ontology predicates.";
 }, {
     readonly pattern: RegExp;
     readonly name: "state_membership";
+    readonly arity: 2;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "State sets are relational workflow constraints and should be queryable as predicate facts.";
 }, {
     readonly pattern: RegExp;
     readonly name: "rate_limit";
+    readonly arity: 4;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Rate limits are bounded action-window constraints and now map to the production rate_limit predicate.";
 }, {
     readonly pattern: RegExp;
     readonly name: "permission_rule";
+    readonly arity: 4;
     readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
     readonly rationale: "Actor/action/resource permission prose is better represented as an ontology predicate than a scalar property.";
 }];

package/dist/operations/semantic-advisor/predicate-rules-product-tail.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"predicate-rules-product-tail.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/predicate-rules-product-tail.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsHI,CAAC"}
+{"version":3,"file":"predicate-rules-product-tail.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/predicate-rules-product-tail.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EACH,CAAC"}