kibi-cli 0.12.8 → 0.16.1

package/dist/operations/semantic-advisor/predicate-rule.js

@@ -0,0 +1,22 @@
+import { normalizeKey, normalizePredicateToken, normalizeSubjectKey, predicateSuggestion, singularize, } from "./shared.js";
+export { normalizeKey, normalizePredicateToken, normalizeSubjectKey, singularize, };
+// implements REQ-mcp-semantic-advisor-preflight
+export function detectPredicateRules(payload, statement, rules) {
+    for (const rule of rules) {
+        if (rule.accepts && !rule.accepts(statement))
+            continue;
+        const match = statement.match(rule.pattern);
+        if (!match?.groups)
+            continue;
+        return predicateSuggestion(payload, match[0], rule.name, rule.args(match.groups), rule.rationale, rule.polarity);
+    }
+    return null;
+}
+// implements REQ-mcp-semantic-advisor-preflight
+export function commaList(value, separator = /,|\band\b/i) {
+    return value
+        .split(separator)
+        .map((part) => normalizeKey(part.trim()))
+        .filter(Boolean)
+        .join(",");
+}

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

@@ -0,0 +1,79 @@
+import { commaList } from "./predicate-rule.js";
+export declare const CORE_PREDICATE_RULES: readonly [{
+    readonly pattern: RegExp;
+    readonly name: "guard";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Disabled-until prose defines a condition that guards behavior availability and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "temporal_order";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Before/after ordering is relational temporal logic and should be modeled as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "conditional_behavior";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "If/then requirement prose is conditional behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "conditional_behavior";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "When/must prose is conditional behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "exception_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Unless/except prose defines an explicit exception to required behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "mutual_exclusion";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Mutual-exclusion prose is a relational constraint and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "dependency_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Requires-before prose defines a prerequisite relationship and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "ownership_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Ownership prose assigns responsibility for a resource or behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "merge_policy";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Same-slot merge prose defines ontology-lite merge behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "retry_policy";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Retry prose defines bounded recovery behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "escalation_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Escalation prose defines delayed handoff behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "availability_sla";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Availability SLA prose defines a service target over a window and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "notification_route";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Notification routing prose defines a recipient and channel and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "idempotency_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Idempotency prose defines deduplication behavior and should be queryable as a predicate.";
+}, {
+    readonly pattern: RegExp;
+    readonly name: "idempotency_rule";
+    readonly args: (g: Readonly<Record<string, string | undefined>>) => string[];
+    readonly rationale: "Deduplication prose defines idempotent handling of repeated or concurrent operations and should be queryable as a predicate.";
+}];
+export { commaList };
+//# sourceMappingURL=predicate-rules-core.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-rules-core.d.ts","sourceRoot":"","sources":["../../../src/operations/semantic-advisor/predicate-rules-core.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAKV,MAAM,qBAAqB,CAAC;AAE7B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuKY,CAAC;AAE9C,OAAO,EAAE,SAAS,EAAE,CAAC"}

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

@@ -0,0 +1,140 @@
+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 };

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

@@ -0,0 +1,83 @@
+export declare const POLICY_PREDICATE_RULES: readonly [{
+    readonly pattern: RegExp;
+    readonly name: "data_residency_rule";
+    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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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.";
+}];
+//# sourceMappingURL=predicate-rules-policy.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,150 @@
+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.",
+    },
+];

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

@@ -0,0 +1,48 @@
+export declare const PRODUCT_TAIL_PREDICATE_RULES: readonly [{
+    readonly pattern: RegExp;
+    readonly name: "throttle_policy_rule";
+    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 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 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 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 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 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 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 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 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.";
+}];
+//# sourceMappingURL=predicate-rules-product-tail.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,102 @@
+import { normalizeKey, normalizePredicateToken, normalizeSubjectKey, singularize, } from "./predicate-rule.js";
+export const PRODUCT_TAIL_PREDICATE_RULES = [
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+throttled\s+for\s+(?<condition>.+?)\.?$/i,
+        name: "throttle_policy_rule",
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            normalizePredicateToken(g.condition ?? ""),
+        ],
+        rationale: "Throttle-policy prose defines throttling behavior under high-frequency conditions and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^(?:the\s+)?(?<subject>.+?)\s+initializes\s+after\s+(?:the\s+)?(?<ready>.+?)\s+is\s+ready\.?$/i,
+        name: "temporal_order",
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            `${normalizeKey(g.ready ?? "")}_ready`,
+            "initializes",
+        ],
+        rationale: "Initializes-after prose defines temporal readiness ordering and should be queryable as a predicate.",
+    },
+    {
+        pattern: /^when\s+(?<trigger>.+?),\s*(?:the\s+)?(?<subject>[a-z][a-z\s_-]*?)\s+transitions?\s+from\s+(?<from>[a-z][a-z0-9_-]*)\s+to\s+(?<to>[a-z][a-z0-9_-]*)\.?$/i,
+        name: "state_transition",
+        args: (g) => [
+            normalizeSubjectKey(g.subject ?? ""),
+            normalizePredicateToken(g.from ?? ""),
+            normalizePredicateToken(g.to ?? ""),
+            normalizePredicateToken(g.trigger ?? ""),
+        ],
+        rationale: "State transitions have source state, target state, and trigger; model them as predicate facts.",
+    },
+    {
+        pattern: /^(?<actor>[a-z][a-z\s_-]*?)\s+(?:must\s+not|cannot|can't|is\s+forbidden\s+to)\s+(?<action>[a-z][a-z_-]*)\s+(?<resource>.+?)\.?$/i,
+        name: "permission_rule",
+        args: (g) => [
+            singularize(normalizeKey(g.actor ?? "")),
+            normalizePredicateToken(g.action ?? ""),
+            normalizePredicateToken(g.resource ?? ""),
+            "deny",
+        ],
+        rationale: "Prohibitions are negative permission rules and should preserve deny polarity.",
+        polarity: "deny",
+    },
+    {
+        pattern: /^(?:there\s+)?(?:must|shall|should)\s+be\s+at\s+most\s+one\s+(?<subject>[a-z][a-z\s_-]*?)\s+per\s+(?<scope>.+?)\.?$/i,
+        name: "uniqueness_constraint",
+        args: (g) => [
+            normalizeKey(g.subject ?? ""),
+            (g.scope ?? "")
+                .split(/\s+per\s+/i)
+                .map(normalizePredicateToken)
+                .join(","),
+        ],
+        rationale: "Per-scope uniqueness is relational and should be modeled as a predicate rather than a generic count.",
+    },
+    {
+        pattern: /^(?:the\s+)?(?<subject>[a-z][a-z\s_-]*?)\s+defaults?\s+to\s+(?<value>[a-z][a-z0-9\s_-]*?)(?:\s+(?<property>mode|state|status))?\.?$/i,
+        name: "default_value",
+        args: (g) => [
+            normalizeSubjectKey(g.subject ?? ""),
+            normalizeKey(g.property ?? "value"),
+            normalizeKey(g.value ?? ""),
+        ],
+        rationale: "Defaults are relational product behavior and should be explicit ontology predicates.",
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:terminal\s+)?states\s+are\s+(?<states>.+?)\.?$/i,
+        name: "state_membership",
+        args: (g) => [
+            normalizeSubjectKey(g.subject ?? ""),
+            (g.states ?? "")
+                .split(/,|\band\b|\bor\b/i)
+                .map((value) => normalizePredicateToken(value.trim()))
+                .filter(Boolean)
+                .join(","),
+        ],
+        rationale: "State sets are relational workflow constraints and should be queryable as predicate facts.",
+    },
+    {
+        pattern: /^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+rate\s+limited\s+to\s+(?<count>\d+)\s+(?<action>[a-z][a-z\s_-]*?)\s+per\s+(?<window>[a-z]+)\.?$/i,
+        name: "rate_limit",
+        args: (g) => [
+            `${normalizeKey(g.subject ?? "").replace(/_requests?$/, "")}.request`,
+            normalizePredicateToken(g.action ?? ""),
+            normalizePredicateToken(g.window ?? ""),
+            g.count ?? "",
+        ],
+        rationale: "Rate limits are bounded action-window constraints and now map to the production rate_limit predicate.",
+    },
+    {
+        pattern: /^only\s+(?<actor>[a-z][a-z\s_-]*?)\s+can\s+(?<action>[a-z][a-z_-]*)\s+(?<resource>.+?)(?:\s+when\s+.+)?\.?$/i,
+        name: "permission_rule",
+        args: (g) => [
+            singularize(normalizeKey(g.actor ?? "")),
+            normalizeKey(g.action ?? ""),
+            normalizeKey(g.resource ?? ""),
+            "assert",
+        ],
+        rationale: "Actor/action/resource permission prose is better represented as an ontology predicate than a scalar property.",
+    },
+];