kibi-cli 2.11.0 → 2.13.0

package/dist/operations/modeling/predicate-applyplan.js

@@ -5,12 +5,28 @@ import { inferArgs } from "./predicate-inference.js";
 import { schemaForCandidate } from "./predicate-loader.js";
 import { hashId } from "./predicate-utils.js";
 import { applyArgumentRewrites, predicateArgumentConformance, } from "./predicate-vocabulary.js";
-// implements REQ-mcp-suggest-predicates
+// implements REQ-mcp-suggest-predicates, REQ-model-predicates-requirement-subject-v2, REQ-model-predicates-binding-clauses
 export function buildSuggestion(schema, text, subject, score, argumentBindings = {}, polarityHint, diagnostics) {
     const inferredArgs = inferArgs(schema, text, subject);
     const canonicalLauncherArgs = exactLauncherPredicateArgs(schema.predicate_name, text);
+    const hasExactBinding = (name) => typeof argumentBindings[name] === "string" &&
+        argumentBindings[name].trim().length > 0;
+    // The argument the schema names `subject`, wherever it sits; -1 when the
+    // schema names no subject (permission_rule(actor, action, resource, ...)).
+    const subjectArgument = schema.argument_names.indexOf("subject");
+    const explicitSubject = diagnostics?.explicitSubject === true;
+    // The reviewed subject: subjectHint, else the requirement's constrained
+    // subject. It binds the `subject` argument unless that argument is bound.
+    const reviewedSubject = explicitSubject
+        ? subject
+        : diagnostics?.requirementSubject;
+    const reviewedSubjectArgument = reviewedSubject !== undefined && !hasExactBinding("subject")
+        ? subjectArgument
+        : -1;
     const boundArgs = schema.argument_names.map((name, index) => {
         const exactBinding = argumentBindings[name];
+        if (index === reviewedSubjectArgument)
+            return reviewedSubject ?? "unknown";
         return typeof exactBinding === "string" && exactBinding.trim().length > 0
             ? exactBinding.trim()
             : (inferredArgs[index] ?? "unknown");
@@ -25,30 +41,59 @@ export function buildSuggestion(schema, text, subject, score, argumentBindings =
     const conformance = predicateArgumentConformance(schema.argument_names, boundArgs, vocabulary);
     const predicateArgs = applyArgumentRewrites(boundArgs, conformance.rewrites);
     const undeclaredArguments = new Set(conformance.undeclared.map((value) => value.argumentName));
+    // A schema without a `subject` argument may still lead with the hinted
+    // subject (inference put it there): that value is the agent's reviewed
+    // value, even when the schema names its first argument after it.
+    const hintedFirstArgument = explicitSubject &&
+        subjectArgument < 0 &&
+        !hasExactBinding(schema.argument_names[0] ?? "") &&
+        predicateArgs[0] === subject
+        ? 0
+        : -1;
     const bindingProvenanceByArgument = Object.fromEntries(schema.argument_names.map((name, index) => [
         name,
-        classifyBinding(predicateArgs[index] ?? "unknown", text, (typeof argumentBindings[name] === "string" &&
-            argumentBindings[name].trim().length > 0) ||
-            (diagnostics?.explicitSubject === true && index === 0), canonicalLauncherArgs?.[index] === predicateArgs[index] &&
-            !(index === 0 &&
-                predicateArgs[index] === "launcher" &&
-                diagnostics?.explicitSubject !== true &&
-                typeof argumentBindings[name] !== "string"), 
-        // A subject named through subjectHint is the agent's reviewed
-        // subject, even when the schema names its first argument after it.
-        index === 0 &&
-            diagnostics?.explicitSubject === true &&
-            typeof argumentBindings[name] !== "string"
-            ? { constants: schema.argument_constants?.[name] }
-            : {
-                argumentName: name,
-                argumentNames: schema.argument_names,
-                constants: schema.argument_constants?.[name],
-            }),
+        index === reviewedSubjectArgument && !undeclaredArguments.has(name)
+            ? explicitSubject
+                ? classifyBinding(predicateArgs[index] ?? "unknown", text, true)
+                : "requirement"
+            : classifyBinding(predicateArgs[index] ?? "unknown", text, hasExactBinding(name) || index === hintedFirstArgument, canonicalLauncherArgs?.[index] === predicateArgs[index] &&
+                !(index === 0 &&
+                    predicateArgs[index] === "launcher" &&
+                    !explicitSubject &&
+                    typeof argumentBindings[name] !== "string"), index === hintedFirstArgument
+                ? { constants: schema.argument_constants?.[name] }
+                : {
+                    argumentName: name,
+                    argumentNames: schema.argument_names,
+                    argumentType: schema.argument_types[index],
+                    constants: schema.argument_constants?.[name],
+                }),
     ]));
+    // The subject the planned predicate fact is about, when the requirement
+    // constrains subjects: the `subject` argument's value, or for a schema
+    // without one the reviewed subject, recorded as the fact's subject_key.
+    const constrainedSubjects = diagnostics?.constrainedSubjects ?? [];
+    const subjectKey = constrainedSubjects.length === 0
+        ? null
+        : subjectArgument >= 0
+            ? (predicateArgs[subjectArgument] ?? null)
+            : (reviewedSubject ?? null);
+    const subjectPairing = constrainedSubjects.length === 0
+        ? "not_required"
+        : subjectKey !== null && constrainedSubjects.includes(subjectKey)
+            ? "paired"
+            : "unpaired";
     const bindingProvenance = aggregateBindingProvenance(Object.values(bindingProvenanceByArgument));
     const unboundArguments = schema.argument_names.filter((name) => undeclaredArguments.has(name) ||
         !bindingCanBeApplied(bindingProvenanceByArgument[name] ?? "placeholder"));
+    // An unpaired predicate would leave kb_check's strict-req-fact-pairing on
+    // the requirement, so the subject still needs a binding: the `subject`
+    // argument, or the fact's subject_key for a schema without one.
+    if (subjectPairing === "unpaired") {
+        const missing = subjectArgument >= 0 ? "subject" : "subject_key";
+        if (!unboundArguments.includes(missing))
+            unboundArguments.push(missing);
+    }
     const canonicalKey = `${schema.predicate_name}(${predicateArgs.join(",")})`;
     // Permission-style inference carries the deontic decision as its final
     // argument. Preserve that polarity in the typed suggestion instead of
@@ -68,6 +113,8 @@ export function buildSuggestion(schema, text, subject, score, argumentBindings =
         unbound_arguments: unboundArguments,
         binding_provenance: bindingProvenance,
         binding_provenance_by_argument: bindingProvenanceByArgument,
+        subject_key: subjectKey,
+        subject_pairing: subjectPairing,
         eligibility: diagnostics?.eligibility ?? "eligible",
         rejection_reasons: [...(diagnostics?.rejectionReasons ?? [])],
         applicability_score: diagnostics?.applicabilityScore ?? score,
@@ -86,7 +133,7 @@ export function buildSuggestion(schema, text, subject, score, argumentBindings =
         schema: schemaForCandidate(schema),
     };
 }
-// implements REQ-mcp-suggest-predicates
+// implements REQ-mcp-suggest-predicates, REQ-model-predicates-requirement-subject-v2
 export function buildPredicateApplyPlan(suggestion, args) {
     if (suggestion.binding_status !== "complete" ||
         suggestion.eligibility !== "eligible")
@@ -112,6 +159,11 @@ export function buildPredicateApplyPlan(suggestion, args) {
                     ...suggestion.schema.tags.map((tag) => `predicate:${tag}`),
                 ],
                 fact_kind: "predicate",
+                // The subject the predicate is about, so kb_check pairs it with the
+                // requirement's subject fact whatever argument holds the subject.
+                ...(suggestion.subject_key
+                    ? { subject_key: suggestion.subject_key }
+                    : {}),
                 predicate_name: suggestion.predicate_name,
                 predicate_args: suggestion.predicate_args,
                 canonical_key: suggestion.canonical_key,

package/dist/operations/modeling/predicate-binding-hints.d.ts

@@ -5,7 +5,7 @@ import type { BindingHint, PredicateSuggestion } from "./predicate-types.js";
  * current value was not accepted, so the agent binds from the claim text
  * instead of guessing.
  */
-export declare function buildBindingHints(candidate: PredicateSuggestion, text: string): BindingHint[];
+export declare function buildBindingHints(candidate: PredicateSuggestion, text: string, requirementSubjects?: readonly string[]): BindingHint[];
 /** One line per hint for the text summary: `name (type, e.g. a, b)`. */
 export declare function describeBindingHints(hints: readonly BindingHint[]): string;
 //# sourceMappingURL=predicate-binding-hints.d.ts.map

package/dist/operations/modeling/predicate-binding-hints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"predicate-binding-hints.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-binding-hints.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAoD7E;;;;;GAKG;AAEH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,mBAAmB,EAC9B,IAAI,EAAE,MAAM,GACX,WAAW,EAAE,CA2Bf;AAED,wEAAwE;AACxE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,CAW1E"}
+{"version":3,"file":"predicate-binding-hints.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-binding-hints.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AA0D7E;;;;;GAKG;AAEH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,mBAAmB,EAC9B,IAAI,EAAE,MAAM,EACZ,mBAAmB,GAAE,SAAS,MAAM,EAAO,GAC1C,WAAW,EAAE,CA6Df;AAED,wEAAwE;AACxE,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,MAAM,CAW1E"}

package/dist/operations/modeling/predicate-binding-hints.js

@@ -1,4 +1,4 @@
-import { isGenericPlaceholder, nameOrStopWordReason, } from "./predicate-bindings.js";
+import { bindingCanBeApplied, clauseBindingReason, isGenericPlaceholder, nameOrStopWordReason, } from "./predicate-bindings.js";
 const MAX_EXAMPLES = 5;
 /** Split `name(a, b(c), d)` into its top-level arguments, or [] when it is not a call. */
 function exampleArguments(example) {
@@ -36,6 +36,12 @@ function unboundReason(candidate, name, value, text) {
     });
     if (nameReason !== null)
         return `The value "${value}" is not a binding: ${nameReason}.`;
+    const clauseReason = clauseBindingReason(value, {
+        argumentType: schema.argument_types[schema.argument_names.indexOf(name)],
+        constants: schema.argument_constants?.[name],
+    });
+    if (clauseReason !== null)
+        return `The value "${value}" is not a binding: ${clauseReason}. Bind a noun of at most 3 words, or the requirement's subject key.`;
     if (!value.trim() || isGenericPlaceholder(value))
         return "The claim text names no value for this argument.";
     if (provenance === "inferred")
@@ -50,17 +56,43 @@ function unboundReason(candidate, name, value, text) {
  * current value was not accepted, so the agent binds from the claim text
  * instead of guessing.
  */
-// implements REQ-model-predicates-binding-placeholders
-export function buildBindingHints(candidate, text) {
+// implements REQ-model-predicates-binding-placeholders, REQ-model-predicates-requirement-subject-v2, REQ-model-predicates-binding-clauses
+export function buildBindingHints(candidate, text, requirementSubjects = []) {
     const schema = candidate.schema;
     const parsedExamples = schema.examples.map(exampleArguments);
+    const namesSubject = schema.argument_names.includes("subject");
     return candidate.unbound_arguments.map((name) => {
+        // A schema without a subject argument records the requirement's subject
+        // as the predicate fact's subject_key instead.
+        if (name === "subject_key" && !namesSubject)
+            return {
+                argument: name,
+                position: -1,
+                type: "subject_key",
+                description: "The subject the predicate fact is about; recorded as its subject_key because the schema names no subject argument.",
+                examples: requirementSubjects.slice(0, MAX_EXAMPLES),
+                currentValue: candidate.subject_key ?? "",
+                provenance: "placeholder",
+                reason: `The ${schema.predicate_name} schema does not name the requirement's subject, so kb_check pairs the predicate with the subject fact only through subject_key. Pass subjectHint with one of the subjects the requirement constrains.`,
+            };
         const position = schema.argument_names.indexOf(name);
         const constants = schema.argument_constants?.[name];
         const exampleValues = parsedExamples
             .map((args) => args[position])
             .filter((value) => typeof value === "string");
-        const examples = Array.from(new Set([...(constants ?? []), ...exampleValues])).slice(0, MAX_EXAMPLES);
+        // The subject keys the requirement already constrains come first, so
+        // the predicate and the subject fact use one identifier for the subject.
+        const examples = Array.from(new Set([
+            ...(name === "subject" ||
+                (!namesSubject &&
+                    clauseBindingReason(candidate.predicate_args[position] ?? "", {
+                        argumentType: schema.argument_types[position],
+                    }) !== null)
+                ? requirementSubjects
+                : []),
+            ...(constants ?? []),
+            ...exampleValues,
+        ])).slice(0, MAX_EXAMPLES);
         const current = candidate.predicate_args[position] ?? "";
         const description = schema.argument_descriptions?.[position];
         return {
@@ -72,7 +104,11 @@ export function buildBindingHints(candidate, text) {
             examples,
             currentValue: current,
             provenance: candidate.binding_provenance_by_argument[name] ?? "placeholder",
-            reason: unboundReason(candidate, name, current, text),
+            reason: name === "subject" &&
+                candidate.subject_pairing === "unpaired" &&
+                bindingCanBeApplied(candidate.binding_provenance_by_argument[name] ?? "placeholder")
+                ? `The value "${current}" is not a subject the requirement constrains (${requirementSubjects.join(", ")}), so kb_check would not pair the predicate with the subject fact. Bind one of them.`
+                : unboundReason(candidate, name, current, text),
         };
     });
 }

package/dist/operations/modeling/predicate-bindings.d.ts

@@ -10,6 +10,8 @@ export type BindingContext = Readonly<{
     argumentNames?: readonly string[];
     /** Declared constants of this argument: always valid when matched. */
     constants?: readonly string[] | undefined;
+    /** The argument's declared type (`entity`, `actor`, `resource`, ...). */
+    argumentType?: string | undefined;
     /**
      * The claim text. A value that repeats an argument name is still a real
      * binding when the claim itself names it (a `launcher` argument bound to
@@ -23,6 +25,17 @@ export type BindingContext = Readonly<{
  * word. Declared constants and the booleans `true`/`false` always pass.
  */
 export declare function nameOrStopWordReason(value: string, context?: BindingContext): string | null;
+/** The most words a value of a naming argument may have. */
+export declare const MAX_NAMING_BINDING_WORDS = 3;
+/**
+ * Why a value taken from the claim text cannot name a participant, or null
+ * when it can: a value of an entity-, actor- or resource-like argument with
+ * more than MAX_NAMING_BINDING_WORDS words is a clause of the claim (for
+ * example everything before the modal verb), not the participant's name.
+ * Explicit bindings, requirement subjects and declared constants are not
+ * judged here.
+ */
+export declare function clauseBindingReason(value: string, context?: BindingContext): string | null;
 export declare function classifyBinding(value: string, text: string, explicit: boolean, canonical?: boolean, context?: BindingContext): BindingProvenance;
 export declare function aggregateBindingProvenance(values: readonly BindingProvenance[]): BindingProvenance;
 export declare function bindingCanBeApplied(value: BindingProvenance): boolean;

package/dist/operations/modeling/predicate-bindings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"predicate-bindings.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-bindings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAkG9D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAW3D;AAgED,iEAAiE;AACjE,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMlD;AAED,sDAAsD;AACtD,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,qCAAqC;IACrC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,sEAAsE;IACtE,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;IAC1C;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B,CAAC,CAAC;AAiBH;;;;GAIG;AAEH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,cAAmB,GAC3B,MAAM,GAAG,IAAI,CAYf;AAGD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,OAAO,EACjB,SAAS,UAAQ,EACjB,OAAO,GAAE,cAAmB,GAC3B,iBAAiB,CAmBnB;AASD,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,iBAAiB,EAAE,GACnC,iBAAiB,CAQnB;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAErE"}
+{"version":3,"file":"predicate-bindings.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-bindings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAgH9D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAW3D;AAgED,iEAAiE;AACjE,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMlD;AAED,sDAAsD;AACtD,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,qCAAqC;IACrC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,sEAAsE;IACtE,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;IAC1C,yEAAyE;IACzE,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B,CAAC,CAAC;AAiBH;;;;GAIG;AAEH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,cAAmB,GAC3B,MAAM,GAAG,IAAI,CAYf;AAgBD,4DAA4D;AAC5D,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C;;;;;;;GAOG;AAEH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,cAAmB,GAC3B,MAAM,GAAG,IAAI,CAOf;AAGD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,OAAO,EACjB,SAAS,UAAQ,EACjB,OAAO,GAAE,cAAmB,GAC3B,iBAAiB,CAsBnB;AAUD,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,iBAAiB,EAAE,GACnC,iBAAiB,CAQnB;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAIrE"}

package/dist/operations/modeling/predicate-bindings.js

@@ -67,6 +67,20 @@ const DERIVED_CUE_ALIASES = {
     ],
     actionable_error: ["actionable", "clear error", "report", "error"],
     exception: ["exception", "except", "package-manager", "package manager"],
+    // Wording that names a closed-vocabulary constant without spelling it.
+    deny: [
+        "denied",
+        "must not",
+        "must never",
+        "forbidden",
+        "prohibited",
+        "not allowed",
+        "not be allowed",
+    ],
+    allow: ["is allowed", "are allowed", "permitted"],
+    on_demand: ["on demand", "on request"],
+    timeout: ["times out", "timed out", "time out"],
+    submit: ["submission", "submits", "submitted"],
 };
 function textContainsValue(text, value) {
     const lower = text.toLowerCase();
@@ -195,7 +209,42 @@ export function nameOrStopWordReason(value, context = {}) {
         return `it repeats the argument name ${token} and the claim does not name it`;
     return null;
 }
-// implements REQ-mcp-suggest-predicates, REQ-model-predicates-binding-placeholders
+/**
+ * Argument types that name a participant (who or what), so a value is a
+ * short noun or a subject key, never a clause of the claim.
+ */
+const NAMING_ARGUMENT_TYPES = new Set([
+    "entity",
+    "actor",
+    "actor_scope",
+    "resource",
+    "owner",
+    "role",
+    "component",
+]);
+/** The most words a value of a naming argument may have. */
+export const MAX_NAMING_BINDING_WORDS = 3;
+/**
+ * Why a value taken from the claim text cannot name a participant, or null
+ * when it can: a value of an entity-, actor- or resource-like argument with
+ * more than MAX_NAMING_BINDING_WORDS words is a clause of the claim (for
+ * example everything before the modal verb), not the participant's name.
+ * Explicit bindings, requirement subjects and declared constants are not
+ * judged here.
+ */
+// implements REQ-model-predicates-binding-clauses
+export function clauseBindingReason(value, context = {}) {
+    const type = context.argumentType ? bindingToken(context.argumentType) : "";
+    if (!NAMING_ARGUMENT_TYPES.has(type))
+        return null;
+    if (matchesConstant(value, context))
+        return null;
+    const words = bindingToken(value).split("_").filter(Boolean);
+    if (words.length <= MAX_NAMING_BINDING_WORDS)
+        return null;
+    return `it is a ${words.length}-word clause of the claim, not a short name for this ${type}`;
+}
+// implements REQ-mcp-suggest-predicates, REQ-model-predicates-binding-placeholders, REQ-model-predicates-binding-clauses
 export function classifyBinding(value, text, explicit, canonical = false, context = {}) {
     const normalized = value.trim();
     // A value that only repeats an argument name or a stop word is unbound
@@ -212,12 +261,17 @@ export function classifyBinding(value, text, explicit, canonical = false, contex
         return "explicit";
     if (!normalized || isGenericPlaceholder(normalized))
         return "placeholder";
+    // A clause lifted from the claim names no participant: it stays unbound
+    // like a placeholder so the agent binds a short noun or the subject key.
+    if (clauseBindingReason(normalized, context) !== null)
+        return "placeholder";
     if (textContainsValue(text, normalized))
         return "extracted";
     return "inferred";
 }
 const PROVENANCE_ORDER = [
     "explicit",
+    "requirement",
     "extracted",
     "inferred",
     "placeholder",
@@ -228,5 +282,5 @@ export function aggregateBindingProvenance(values) {
         : worst, "explicit");
 }
 export function bindingCanBeApplied(value) {
-    return value === "explicit" || value === "extracted";
+    return (value === "explicit" || value === "requirement" || value === "extracted");
 }

package/dist/operations/modeling/predicate-catalog-1.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"predicate-catalog-1.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-catalog-1.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,eAAO,MAAM,mBAAmB,EAAE,wBAAwB,EAmNzD,CAAC"}
+{"version":3,"file":"predicate-catalog-1.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-catalog-1.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,eAAO,MAAM,mBAAmB,EAAE,wBAAwB,EAqNzD,CAAC"}

package/dist/operations/modeling/predicate-catalog-1.js

@@ -1,3 +1,4 @@
+import { LIFECYCLE_ACTION_VOCABULARY, TRIGGER_VOCABULARY, closedArguments, } from "./predicate-closed-vocabularies.js";
 // implements REQ-mcp-suggest-predicates
 export const PREDICATE_CATALOG_1 = [
     {
@@ -18,6 +19,7 @@ export const PREDICATE_CATALOG_1 = [
         description: "A subject transitions between states because of a trigger.",
         argument_names: ["subject", "from_state", "to_state", "trigger"],
         argument_types: ["entity", "state", "state", "trigger"],
+        ...closedArguments({ trigger: TRIGGER_VOCABULARY }),
         keywords: [
             "transition",
             "enter",
@@ -193,6 +195,7 @@ export const PREDICATE_CATALOG_1 = [
         description: "An entity must be archived, deleted, expired, or lifecycle-transitioned after a duration.",
         argument_names: ["subject", "action", "duration", "unit"],
         argument_types: ["entity", "action", "number", "unit"],
+        ...closedArguments({ action: LIFECYCLE_ACTION_VOCABULARY }),
         keywords: ["archive", "archived", "delete", "deleted", "expire", "after"],
         examples: ["lifecycle_rule(expired_sessions, archived, 30, days)"],
         tags: ["lifecycle", "retention"],

package/dist/operations/modeling/predicate-catalog-2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"predicate-catalog-2.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-catalog-2.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,eAAO,MAAM,mBAAmB,EAAE,wBAAwB,EAkOzD,CAAC"}
+{"version":3,"file":"predicate-catalog-2.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-catalog-2.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,eAAO,MAAM,mBAAmB,EAAE,wBAAwB,EAoOzD,CAAC"}

package/dist/operations/modeling/predicate-catalog-2.js

@@ -1,3 +1,4 @@
+import { CODING_STANDARD_ACTION_VOCABULARY, ENVIRONMENT_DECISION_VOCABULARY, closedArguments, } from "./predicate-closed-vocabularies.js";
 // implements REQ-mcp-suggest-predicates
 export const PREDICATE_CATALOG_2 = [
     {
@@ -66,6 +67,7 @@ export const PREDICATE_CATALOG_2 = [
         description: "A named action is allowed or forbidden in a deployment environment.",
         argument_names: ["action", "decision", "environment"],
         argument_types: ["action", "decision", "environment"],
+        ...closedArguments({ decision: ENVIRONMENT_DECISION_VOCABULARY }),
         keywords: ["production", "staging", "forbidden", "destructive"],
         examples: [
             "environment_safety_rule(destructive_operations, forbidden, production)",
@@ -90,6 +92,7 @@ export const PREDICATE_CATALOG_2 = [
         description: "Developer-facing code must use or avoid a framework API, pattern, or documentation practice.",
         argument_names: ["subject", "action", "target"],
         argument_types: ["entity", "action", "api"],
+        ...closedArguments({ action: CODING_STANDARD_ACTION_VOCABULARY }),
         keywords: ["computed", "signals", "must use", "must not use"],
         examples: ["coding_standard_rule(derived_state, use, computed_signals)"],
         tags: ["coding-standard", "agent-guidance"],

package/dist/operations/modeling/predicate-catalog-3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"predicate-catalog-3.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-catalog-3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,eAAO,MAAM,mBAAmB,EAAE,wBAAwB,EA0NzD,CAAC"}
+{"version":3,"file":"predicate-catalog-3.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-catalog-3.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,eAAO,MAAM,mBAAmB,EAAE,wBAAwB,EAgOzD,CAAC"}

package/dist/operations/modeling/predicate-catalog-3.js

@@ -1,3 +1,4 @@
+import { DECISION_VOCABULARY, OPERATOR_VOCABULARY, REFRESH_POLICY_VOCABULARY, RETENTION_UNIT_VOCABULARY, TRIGGER_VOCABULARY, closedArguments, } from "./predicate-closed-vocabularies.js";
 // implements REQ-mcp-suggest-predicates
 export const PREDICATE_CATALOG_3 = [
     {
@@ -20,6 +21,7 @@ export const PREDICATE_CATALOG_3 = [
         description: "A subject refreshes a target automatically or by a named policy.",
         argument_names: ["subject", "target", "policy"],
         argument_types: ["entity", "target", "policy"],
+        ...closedArguments({ policy: REFRESH_POLICY_VOCABULARY }),
         keywords: ["automatically refresh", "manual page reload", "refresh"],
         examples: ["refresh_policy_rule(dashboard, processing_videos, automatic)"],
         tags: ["refresh", "ui"],
@@ -31,6 +33,7 @@ export const PREDICATE_CATALOG_3 = [
         description: "A scoped actor is allowed or denied an action because of assignment, ownership, or membership.",
         argument_names: ["actor_scope", "action", "decision"],
         argument_types: ["actor_scope", "action", "decision"],
+        ...closedArguments({ decision: DECISION_VOCABULARY }),
         keywords: ["unassigned", "assigned", "denied", "scoped"],
         examples: [
             "scoped_authorization_rule(unassigned_instructors, signed_url_generation, deny)",
@@ -131,6 +134,7 @@ export const PREDICATE_CATALOG_3 = [
         description: "A trigger commits, saves, or persists a subject within a scope.",
         argument_names: ["subject", "trigger", "scope"],
         argument_types: ["entity", "trigger", "scope"],
+        ...closedArguments({ trigger: TRIGGER_VOCABULARY }),
         keywords: [
             "save",
             "saves",
@@ -153,6 +157,7 @@ export const PREDICATE_CATALOG_3 = [
         description: "A trigger discards or cancels changes for a subject within a scope.",
         argument_names: ["subject", "trigger", "scope"],
         argument_types: ["entity", "trigger", "scope"],
+        ...closedArguments({ trigger: TRIGGER_VOCABULARY }),
         keywords: ["discard", "cancel", "escape", "revert", "without save"],
         examples: ["discard_action(editor.annotation, escape, active_annotation)"],
         tags: ["persistence", "workflow"],
@@ -175,6 +180,7 @@ export const PREDICATE_CATALOG_3 = [
         description: "A subject is retained for a bounded duration.",
         argument_names: ["subject", "duration", "unit"],
         argument_types: ["entity", "number", "unit"],
+        ...closedArguments({ unit: RETENTION_UNIT_VOCABULARY }),
         keywords: ["retain", "retained", "retention", "days", "months", "years"],
         examples: ["retention_policy(customer.data, 7, years)"],
         tags: ["data", "policy"],
@@ -186,6 +192,7 @@ export const PREDICATE_CATALOG_3 = [
         description: "A subject constrains a resource by operator, threshold, and unit.",
         argument_names: ["subject", "resource", "operator", "threshold", "unit"],
         argument_types: ["entity", "resource", "operator", "number", "unit"],
+        ...closedArguments({ operator: OPERATOR_VOCABULARY }),
         keywords: [
             "limit",
             "maximum",

package/dist/operations/modeling/predicate-catalog-4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"predicate-catalog-4.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-catalog-4.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,eAAO,MAAM,mBAAmB,EAAE,wBAAwB,EAoTzD,CAAC"}
+{"version":3,"file":"predicate-catalog-4.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-catalog-4.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,eAAO,MAAM,mBAAmB,EAAE,wBAAwB,EAqTzD,CAAC"}

package/dist/operations/modeling/predicate-catalog-4.js

@@ -1,3 +1,4 @@
+import { DECISION_VOCABULARY, closedArguments, } from "./predicate-closed-vocabularies.js";
 // implements REQ-mcp-suggest-predicates
 export const PREDICATE_CATALOG_4 = [
     {
@@ -201,6 +202,7 @@ export const PREDICATE_CATALOG_4 = [
         description: "An actor is allowed or denied an action against a resource.",
         argument_names: ["actor", "action", "resource", "decision"],
         argument_types: ["actor", "action", "resource", "decision"],
+        ...closedArguments({ decision: DECISION_VOCABULARY }),
         keywords: [
             "may",
             "can",

package/dist/operations/modeling/predicate-closed-vocabularies.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Closed argument vocabularies shared by built-in predicate schemas. An
+ * argument with a natural closed vocabulary declares its constants, so
+ * kb_model binds a constant the claim names (or an alias of it) and lists the
+ * constants as `allowedValues` when the claim names none, instead of minting
+ * a new atom per requirement.
+ */
+/** UI and workflow events that start a commit, discard or transition. */
+export declare const TRIGGER_VOCABULARY: {
+    readonly constants: readonly ["escape", "cancel", "submit", "navigation", "click", "timeout"];
+    readonly aliases: {
+        readonly esc: "escape";
+        readonly escape_key: "escape";
+        readonly cancellation: "cancel";
+        readonly submission: "submit";
+        readonly navigate: "navigation";
+        readonly navigates: "navigation";
+        readonly navigating: "navigation";
+        readonly navigation_away: "navigation";
+        readonly clicks: "click";
+        readonly time_out: "timeout";
+        readonly timed_out: "timeout";
+    };
+};
+/** An authorization outcome. */
+export declare const DECISION_VOCABULARY: {
+    readonly constants: readonly ["allow", "deny"];
+    readonly aliases: {
+        readonly assert: "allow";
+        readonly allowed: "allow";
+        readonly permit: "allow";
+        readonly permitted: "allow";
+        readonly denied: "deny";
+        readonly forbid: "deny";
+        readonly forbidden: "deny";
+    };
+};
+/** How a target is refreshed. */
+export declare const REFRESH_POLICY_VOCABULARY: {
+    readonly constants: readonly ["automatic", "manual", "on_demand"];
+    readonly aliases: {
+        readonly auto: "automatic";
+        readonly automatically: "automatic";
+        readonly manually: "manual";
+        readonly "on-demand": "on_demand";
+    };
+};
+/** What an environment safety rule decides for an action. */
+export declare const ENVIRONMENT_DECISION_VOCABULARY: {
+    readonly constants: readonly ["allowed", "forbidden", "read-only"];
+    readonly aliases: {
+        readonly allow: "allowed";
+        readonly deny: "forbidden";
+        readonly denied: "forbidden";
+        readonly read_only: "read-only";
+        readonly readonly: "read-only";
+    };
+};
+/** Comparison operators, as property_value facts spell them. */
+export declare const OPERATOR_VOCABULARY: {
+    readonly constants: readonly ["lt", "lte", "eq", "neq", "gte", "gt"];
+    readonly aliases: {
+        readonly le: "lte";
+        readonly ge: "gte";
+        readonly ne: "neq";
+    };
+};
+/** Calendar units a retention period is stated in. */
+export declare const RETENTION_UNIT_VOCABULARY: {
+    readonly constants: readonly ["days", "months", "years"];
+    readonly aliases: {
+        readonly day: "days";
+        readonly month: "months";
+        readonly year: "years";
+    };
+};
+/** The two directions of a coding standard. */
+export declare const CODING_STANDARD_ACTION_VOCABULARY: {
+    readonly constants: readonly ["use", "avoid"];
+    readonly aliases: {};
+};
+/** What happens to a subject at the end of its lifecycle. */
+export declare const LIFECYCLE_ACTION_VOCABULARY: {
+    readonly constants: readonly ["archived", "deleted", "expired"];
+    readonly aliases: {
+        readonly archive: "archived";
+        readonly delete: "deleted";
+        readonly expire: "expired";
+    };
+};
+type Vocabulary = Readonly<{
+    constants: readonly string[];
+    aliases: Readonly<Record<string, string>>;
+}>;
+/**
+ * The `argument_constants` and `argument_aliases` fields for a schema whose
+ * listed arguments use the given vocabularies.
+ */
+export declare function closedArguments(byArgument: Readonly<Record<string, Vocabulary>>): {
+    argument_constants: Record<string, string[]>;
+    argument_aliases?: Record<string, Record<string, string>>;
+};
+export {};
+//# sourceMappingURL=predicate-closed-vocabularies.d.ts.map

package/dist/operations/modeling/predicate-closed-vocabularies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-closed-vocabularies.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-closed-vocabularies.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,yEAAyE;AAEzE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;CAerB,CAAC;AAEX,gCAAgC;AAEhC,eAAO,MAAM,mBAAmB;;;;;;;;;;;CAYtB,CAAC;AAEX,iCAAiC;AAEjC,eAAO,MAAM,yBAAyB;;;;;;;;CAQ5B,CAAC;AAEX,6DAA6D;AAE7D,eAAO,MAAM,+BAA+B;;;;;;;;;CASlC,CAAC;AAEX,gEAAgE;AAEhE,eAAO,MAAM,mBAAmB;;;;;;;CAGtB,CAAC;AAEX,sDAAsD;AAEtD,eAAO,MAAM,yBAAyB;;;;;;;CAG5B,CAAC;AAEX,+CAA+C;AAE/C,eAAO,MAAM,iCAAiC;;;CAGpC,CAAC;AAEX,6DAA6D;AAE7D,eAAO,MAAM,2BAA2B;;;;;;;CAG9B,CAAC;AAEX,KAAK,UAAU,GAAG,QAAQ,CAAC;IACzB,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC3C,CAAC,CAAC;AAEH;;;GAGG;AAEH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,GAC/C;IACD,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC7C,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC3D,CAWA"}