chiasmus 0.1.0

package/dist/skills/starters.js

@@ -0,0 +1,381 @@
+export const STARTER_TEMPLATES = [
+    // ─── Z3 Templates ────────────────────────────────────────
+    {
+        name: "policy-contradiction",
+        domain: "authorization",
+        solver: "z3",
+        signature: "Check if access control rules can ever produce contradictory allow/deny decisions for the same request",
+        skeleton: `
+; Principals, resources, and actions as enumerated types
+{{SLOT:type_declarations}}
+
+; Decision variables
+(declare-const principal {{SLOT:principal_type}})
+(declare-const resource {{SLOT:resource_type}})
+(declare-const action {{SLOT:action_type}})
+(declare-const allowed Bool)
+(declare-const denied Bool)
+
+; Policy rules
+{{SLOT:policy_rules}}
+
+; Check: can both allowed and denied be true simultaneously?
+(assert allowed)
+(assert denied)`,
+        slots: [
+            {
+                name: "type_declarations",
+                description: "SMT-LIB declare-datatypes for principals, resources, actions",
+                format: "(declare-datatypes ((Principal 0)) (((alice) (bob) ...)))",
+            },
+            {
+                name: "principal_type",
+                description: "The type name for principals",
+                format: "Principal",
+            },
+            {
+                name: "resource_type",
+                description: "The type name for resources",
+                format: "Resource",
+            },
+            {
+                name: "action_type",
+                description: "The type name for actions",
+                format: "Action",
+            },
+            {
+                name: "policy_rules",
+                description: "Implications mapping (principal, resource, action) to allowed/denied",
+                format: "(assert (=> (and (= principal alice) (= action read)) allowed))",
+            },
+        ],
+        normalizations: [
+            {
+                source: "AWS IAM JSON",
+                transform: "Map each Statement's Effect/Principal/Action/Resource to allow/deny implications",
+            },
+            {
+                source: "Kubernetes RBAC",
+                transform: "Expand rules[].{verbs, resources, apiGroups} into action/resource allow implications",
+            },
+            {
+                source: "natural language",
+                transform: "Extract entities, classify as principal/resource/action, map to implications",
+            },
+        ],
+    },
+    {
+        name: "policy-reachability",
+        domain: "authorization",
+        solver: "z3",
+        signature: "Check if a specific principal can ever access a specific resource through any combination of roles or rules",
+        skeleton: `
+{{SLOT:type_declarations}}
+
+(declare-const principal {{SLOT:principal_type}})
+(declare-const resource {{SLOT:resource_type}})
+(declare-const action {{SLOT:action_type}})
+(declare-const can_access Bool)
+
+; Role assignments and permission rules
+{{SLOT:role_rules}}
+
+; Target: can this specific principal access this specific resource?
+(assert (= principal {{SLOT:target_principal}}))
+(assert (= resource {{SLOT:target_resource}}))
+(assert can_access)`,
+        slots: [
+            {
+                name: "type_declarations",
+                description: "SMT-LIB declare-datatypes for principals, resources, actions",
+                format: "(declare-datatypes ...)",
+            },
+            { name: "principal_type", description: "Type name for principals", format: "Principal" },
+            { name: "resource_type", description: "Type name for resources", format: "Resource" },
+            { name: "action_type", description: "Type name for actions", format: "Action" },
+            {
+                name: "role_rules",
+                description: "Rules that derive can_access from roles and permissions",
+                format: "(assert (=> (and (= principal alice) ...) can_access))",
+            },
+            { name: "target_principal", description: "The principal to check", format: "alice" },
+            { name: "target_resource", description: "The resource to check", format: "secret_doc" },
+        ],
+        normalizations: [
+            {
+                source: "Django permissions",
+                transform: "Extract user/group assignments and permission checks into role rules",
+            },
+            {
+                source: "natural language",
+                transform: "Identify the target principal and resource, extract role hierarchy",
+            },
+        ],
+    },
+    {
+        name: "config-equivalence",
+        domain: "configuration",
+        solver: "z3",
+        signature: "Check if two configurations are functionally equivalent or find an input where they differ",
+        skeleton: `
+; Input variables representing all possible inputs
+{{SLOT:input_declarations}}
+
+; Output of config A
+{{SLOT:config_a_logic}}
+
+; Output of config B
+{{SLOT:config_b_logic}}
+
+; Check: is there any input where the two configs produce different outputs?
+(assert (not (= {{SLOT:output_a}} {{SLOT:output_b}})))`,
+        slots: [
+            {
+                name: "input_declarations",
+                description: "Declare input variables covering the input space",
+                format: "(declare-const port Int) (declare-const src_ip Int)",
+            },
+            {
+                name: "config_a_logic",
+                description: "Assertions encoding the first configuration's behavior",
+                format: "(declare-const result_a Bool) (assert (=> (> port 80) result_a))",
+            },
+            {
+                name: "config_b_logic",
+                description: "Assertions encoding the second configuration's behavior",
+                format: "(declare-const result_b Bool) (assert (=> (>= port 80) result_b))",
+            },
+            { name: "output_a", description: "Output variable from config A", format: "result_a" },
+            { name: "output_b", description: "Output variable from config B", format: "result_b" },
+        ],
+        normalizations: [
+            {
+                source: "firewall rules",
+                transform: "Encode each rule set as boolean logic over port/protocol/address variables",
+            },
+            {
+                source: "Kubernetes NetworkPolicy",
+                transform: "Map ingress/egress rules to boolean expressions over pod labels and ports",
+            },
+        ],
+    },
+    {
+        name: "constraint-satisfaction",
+        domain: "dependency",
+        solver: "z3",
+        signature: "Find a valid assignment satisfying version constraints, dependency requirements, and compatibility rules",
+        skeleton: `
+; Version variables for each package
+{{SLOT:version_declarations}}
+
+; Version range constraints (available versions)
+{{SLOT:range_constraints}}
+
+; Dependency requirements (A requires B >= version)
+{{SLOT:dependency_rules}}
+
+; Incompatibility constraints
+{{SLOT:incompatibility_rules}}`,
+        slots: [
+            {
+                name: "version_declarations",
+                description: "Declare an Int variable for each package version",
+                format: "(declare-const pkg_a Int) (declare-const pkg_b Int)",
+            },
+            {
+                name: "range_constraints",
+                description: "Constrain each package to its available version range",
+                format: "(assert (and (>= pkg_a 1) (<= pkg_a 3)))",
+            },
+            {
+                name: "dependency_rules",
+                description: "Conditional version requirements between packages",
+                format: "(assert (=> (>= pkg_a 2) (>= pkg_b 3)))",
+            },
+            {
+                name: "incompatibility_rules",
+                description: "Pairs of versions that cannot coexist",
+                format: "(assert (not (and (= pkg_a 2) (= pkg_b 1))))",
+            },
+        ],
+        normalizations: [
+            {
+                source: "package.json",
+                transform: "Parse semver ranges into integer constraints, map peer/optional deps to conditional rules",
+            },
+            {
+                source: "requirements.txt",
+                transform: "Parse version specifiers (>=, ==, !=) into SMT constraints",
+            },
+        ],
+    },
+    {
+        name: "schema-consistency",
+        domain: "validation",
+        solver: "z3",
+        signature: "Check if data validation rules are contradictory, redundant, or have gaps — find inputs that pass some rules but fail others",
+        skeleton: `
+; Input field variables
+{{SLOT:field_declarations}}
+
+; Validation rule set A
+{{SLOT:rule_set_a}}
+
+; Validation rule set B
+{{SLOT:rule_set_b}}
+
+; Check: is there an input that passes A but fails B (or vice versa)?
+(assert (and {{SLOT:passes_a}} (not {{SLOT:passes_b}})))`,
+        slots: [
+            {
+                name: "field_declarations",
+                description: "Declare variables for each input field",
+                format: "(declare-const age Int) (declare-const name_len Int)",
+            },
+            {
+                name: "rule_set_a",
+                description: "Assertions for the first set of validation rules",
+                format: "(declare-const valid_a Bool) (assert (=> (and (>= age 18) ...) valid_a))",
+            },
+            {
+                name: "rule_set_b",
+                description: "Assertions for the second set of validation rules",
+                format: "(declare-const valid_b Bool) (assert (=> (and (> age 17) ...) valid_b))",
+            },
+            { name: "passes_a", description: "Variable indicating input passes rule set A", format: "valid_a" },
+            { name: "passes_b", description: "Variable indicating input passes rule set B", format: "valid_b" },
+        ],
+        normalizations: [
+            {
+                source: "JSON Schema",
+                transform: "Map minimum/maximum/pattern/required to integer/boolean constraints",
+            },
+            {
+                source: "Zod schema",
+                transform: "Extract .min()/.max()/.refine() chains into SMT assertions",
+            },
+        ],
+    },
+    // ─── Prolog Templates ────────────────────────────────────
+    {
+        name: "rule-inference",
+        domain: "rules",
+        solver: "prolog",
+        signature: "Given a set of facts and rules, derive what conclusions follow — determine eligibility, compliance, or derived properties",
+        skeleton: `
+% Facts about entities
+{{SLOT:facts}}
+
+% Rules that derive new conclusions
+{{SLOT:rules}}`,
+        slots: [
+            {
+                name: "facts",
+                description: "Ground facts about the domain",
+                format: "role(alice, admin). department(alice, engineering).",
+            },
+            {
+                name: "rules",
+                description: "Prolog rules that derive conclusions from facts",
+                format: "can_approve(X) :- role(X, admin), department(X, Dept).",
+            },
+        ],
+        normalizations: [
+            {
+                source: "business rules document",
+                transform: "Extract if-then rules and entity facts into Prolog clauses",
+            },
+            {
+                source: "natural language",
+                transform: "Identify entities, properties, and conditional relationships",
+            },
+        ],
+    },
+    {
+        name: "graph-reachability",
+        domain: "analysis",
+        solver: "prolog",
+        signature: "Check if node A can reach node B through any path in a directed graph — data flow, dependency chains, call graphs",
+        skeleton: `
+% Direct edges in the graph
+{{SLOT:edges}}
+
+% Transitive reachability
+reaches(A, B) :- edge(A, B).
+reaches(A, B) :- edge(A, Mid), reaches(Mid, B).`,
+        slots: [
+            {
+                name: "edges",
+                description: "Direct edges as edge(from, to) facts",
+                format: "edge(user_input, handler). edge(handler, database).",
+            },
+        ],
+        normalizations: [
+            {
+                source: "import graph",
+                transform: "Map import statements to edge(importer, imported) facts",
+            },
+            {
+                source: "data flow",
+                transform: "Map data transformations to edge(source, sink) facts",
+            },
+            {
+                source: "call graph",
+                transform: "Map function calls to edge(caller, callee) facts",
+            },
+        ],
+    },
+    {
+        name: "permission-derivation",
+        domain: "authorization",
+        solver: "prolog",
+        signature: "Given a role hierarchy and permission assignments, derive what actions a user can perform on which resources",
+        skeleton: `
+% Role assignments
+{{SLOT:role_assignments}}
+
+% Role hierarchy (parent inherits child permissions)
+{{SLOT:role_hierarchy}}
+
+% Permission assignments to roles
+{{SLOT:permissions}}
+
+% Inheritance logic
+has_role(User, Role) :- role(User, Role).
+has_role(User, Role) :- role(User, R), inherits(R, Role).
+has_role(User, Role) :- role(User, R), inherits(R, Mid), has_role_via(Mid, Role).
+has_role_via(Role, Role).
+has_role_via(Start, End) :- inherits(Start, Mid), has_role_via(Mid, End).
+
+% Permission check
+can(User, Action, Resource) :- has_role(User, Role), permission(Role, Action, Resource).`,
+        slots: [
+            {
+                name: "role_assignments",
+                description: "Which users have which roles",
+                format: "role(alice, admin). role(bob, editor).",
+            },
+            {
+                name: "role_hierarchy",
+                description: "Role inheritance relationships",
+                format: "inherits(admin, editor). inherits(editor, viewer).",
+            },
+            {
+                name: "permissions",
+                description: "What each role can do",
+                format: "permission(viewer, read, docs). permission(editor, write, docs).",
+            },
+        ],
+        normalizations: [
+            {
+                source: "Django groups/permissions",
+                transform: "Map Group→Permission assignments to role/permission facts, group hierarchy to inherits",
+            },
+            {
+                source: "Kubernetes RBAC",
+                transform: "Map ClusterRole/Role bindings to role facts, aggregate rules to permission facts",
+            },
+        ],
+    },
+];
+//# sourceMappingURL=starters.js.map

package/dist/skills/starters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"starters.js","sourceRoot":"","sources":["../../src/skills/starters.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,iBAAiB,GAAoB;IAChD,4DAA4D;IAE5D;QACE,IAAI,EAAE,sBAAsB;QAC5B,MAAM,EAAE,eAAe;QACvB,MAAM,EAAE,IAAI;QACZ,SAAS,EACP,wGAAwG;QAC1G,QAAQ,EAAE;;;;;;;;;;;;;;;;gBAgBE;QACZ,KAAK,EAAE;YACL;gBACE,IAAI,EAAE,mBAAmB;gBACzB,WAAW,EAAE,8DAA8D;gBAC3E,MAAM,EAAE,2DAA2D;aACpE;YACD;gBACE,IAAI,EAAE,gBAAgB;gBACtB,WAAW,EAAE,8BAA8B;gBAC3C,MAAM,EAAE,WAAW;aACpB;YACD;gBACE,IAAI,EAAE,eAAe;gBACrB,WAAW,EAAE,6BAA6B;gBAC1C,MAAM,EAAE,UAAU;aACnB;YACD;gBACE,IAAI,EAAE,aAAa;gBACnB,WAAW,EAAE,2BAA2B;gBACxC,MAAM,EAAE,QAAQ;aACjB;YACD;gBACE,IAAI,EAAE,cAAc;gBACpB,WAAW,EACT,sEAAsE;gBACxE,MAAM,EAAE,iEAAiE;aAC1E;SACF;QACD,cAAc,EAAE;YACd;gBACE,MAAM,EAAE,cAAc;gBACtB,SAAS,EACP,kFAAkF;aACrF;YACD;gBACE,MAAM,EAAE,iBAAiB;gBACzB,SAAS,EACP,sFAAsF;aACzF;YACD;gBACE,MAAM,EAAE,kBAAkB;gBAC1B,SAAS,EAAE,8EAA8E;aAC1F;SACF;KACF;IAED;QACE,IAAI,EAAE,qBAAqB;QAC3B,MAAM,EAAE,eAAe;QACvB,MAAM,EAAE,IAAI;QACZ,SAAS,EACP,6GAA6G;QAC/G,QAAQ,EAAE;;;;;;;;;;;;;;oBAcM;QAChB,KAAK,EAAE;YACL;gBACE,IAAI,EAAE,mBAAmB;gBACzB,WAAW,EAAE,8DAA8D;gBAC3E,MAAM,EAAE,yBAAyB;aAClC;YACD,EAAE,IAAI,EAAE,gBAAgB,EAAE,WAAW,EAAE,0BAA0B,EAAE,MAAM,EAAE,WAAW,EAAE;YACxF,EAAE,IAAI,EAAE,eAAe,EAAE,WAAW,EAAE,yBAAyB,EAAE,MAAM,EAAE,UAAU,EAAE;YACrF,EAAE,IAAI,EAAE,aAAa,EAAE,WAAW,EAAE,uBAAuB,EAAE,MAAM,EAAE,QAAQ,EAAE;YAC/E;gBACE,IAAI,EAAE,YAAY;gBAClB,WAAW,EAAE,yDAAyD;gBACtE,MAAM,EAAE,wDAAwD;aACjE;YACD,EAAE,IAAI,EAAE,kBAAkB,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,EAAE,OAAO,EAAE;YACpF,EAAE,IAAI,EAAE,iBAAiB,EAAE,WAAW,EAAE,uBAAuB,EAAE,MAAM,EAAE,YAAY,EAAE;SACxF;QACD,cAAc,EAAE;YACd;gBACE,MAAM,EAAE,oBAAoB;gBAC5B,SAAS,EAAE,sEAAsE;aAClF;YACD;gBACE,MAAM,EAAE,kBAAkB;gBAC1B,SAAS,EAAE,oEAAoE;aAChF;SACF;KACF;IAED;QACE,IAAI,EAAE,oBAAoB;QAC1B,MAAM,EAAE,eAAe;QACvB,MAAM,EAAE,IAAI;QACZ,SAAS,EACP,4FAA4F;QAC9F,QAAQ,EAAE;;;;;;;;;;;uDAWyC;QACnD,KAAK,EAAE;YACL;gBACE,IAAI,EAAE,oBAAoB;gBAC1B,WAAW,EAAE,kDAAkD;gBAC/D,MAAM,EAAE,qDAAqD;aAC9D;YACD;gBACE,IAAI,EAAE,gBAAgB;gBACtB,WAAW,EAAE,wDAAwD;gBACrE,MAAM,EAAE,kEAAkE;aAC3E;YACD;gBACE,IAAI,EAAE,gBAAgB;gBACtB,WAAW,EAAE,yDAAyD;gBACtE,MAAM,EAAE,mEAAmE;aAC5E;YACD,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,+BAA+B,EAAE,MAAM,EAAE,UAAU,EAAE;YACtF,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,+BAA+B,EAAE,MAAM,EAAE,UAAU,EAAE;SACvF;QACD,cAAc,EAAE;YACd;gBACE,MAAM,EAAE,gBAAgB;gBACxB,SAAS,EACP,4EAA4E;aAC/E;YACD;gBACE,MAAM,EAAE,0BAA0B;gBAClC,SAAS,EAAE,2EAA2E;aACvF;SACF;KACF;IAED;QACE,IAAI,EAAE,yBAAyB;QAC/B,MAAM,EAAE,YAAY;QACpB,MAAM,EAAE,IAAI;QACZ,SAAS,EACP,0GAA0G;QAC5G,QAAQ,EAAE;;;;;;;;;;;+BAWiB;QAC3B,KAAK,EAAE;YACL;gBACE,IAAI,EAAE,sBAAsB;gBAC5B,WAAW,EAAE,kDAAkD;gBAC/D,MAAM,EAAE,qDAAqD;aAC9D;YACD;gBACE,IAAI,EAAE,mBAAmB;gBACzB,WAAW,EAAE,uDAAuD;gBACpE,MAAM,EAAE,0CAA0C;aACnD;YACD;gBACE,IAAI,EAAE,kBAAkB;gBACxB,WAAW,EAAE,mDAAmD;gBAChE,MAAM,EAAE,yCAAyC;aAClD;YACD;gBACE,IAAI,EAAE,uBAAuB;gBAC7B,WAAW,EAAE,uCAAuC;gBACpD,MAAM,EAAE,8CAA8C;aACvD;SACF;QACD,cAAc,EAAE;YACd;gBACE,MAAM,EAAE,cAAc;gBACtB,SAAS,EACP,2FAA2F;aAC9F;YACD;gBACE,MAAM,EAAE,kBAAkB;gBAC1B,SAAS,EAAE,4DAA4D;aACxE;SACF;KACF;IAED;QACE,IAAI,EAAE,oBAAoB;QAC1B,MAAM,EAAE,YAAY;QACpB,MAAM,EAAE,IAAI;QACZ,SAAS,EACP,8HAA8H;QAChI,QAAQ,EAAE;;;;;;;;;;;yDAW2C;QACrD,KAAK,EAAE;YACL;gBACE,IAAI,EAAE,oBAAoB;gBAC1B,WAAW,EAAE,wCAAwC;gBACrD,MAAM,EAAE,sDAAsD;aAC/D;YACD;gBACE,IAAI,EAAE,YAAY;gBAClB,WAAW,EAAE,kDAAkD;gBAC/D,MAAM,EAAE,0EAA0E;aACnF;YACD;gBACE,IAAI,EAAE,YAAY;gBAClB,WAAW,EAAE,mDAAmD;gBAChE,MAAM,EAAE,yEAAyE;aAClF;YACD,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,6CAA6C,EAAE,MAAM,EAAE,SAAS,EAAE;YACnG,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,6CAA6C,EAAE,MAAM,EAAE,SAAS,EAAE;SACpG;QACD,cAAc,EAAE;YACd;gBACE,MAAM,EAAE,aAAa;gBACrB,SAAS,EACP,qEAAqE;aACxE;YACD;gBACE,MAAM,EAAE,YAAY;gBACpB,SAAS,EAAE,4DAA4D;aACxE;SACF;KACF;IAED,4DAA4D;IAE5D;QACE,IAAI,EAAE,gBAAgB;QACtB,MAAM,EAAE,OAAO;QACf,MAAM,EAAE,QAAQ;QAChB,SAAS,EACP,2HAA2H;QAC7H,QAAQ,EAAE;;;;;eAKC;QACX,KAAK,EAAE;YACL;gBACE,IAAI,EAAE,OAAO;gBACb,WAAW,EAAE,+BAA+B;gBAC5C,MAAM,EAAE,qDAAqD;aAC9D;YACD;gBACE,IAAI,EAAE,OAAO;gBACb,WAAW,EAAE,iDAAiD;gBAC9D,MAAM,EAAE,wDAAwD;aACjE;SACF;QACD,cAAc,EAAE;YACd;gBACE,MAAM,EAAE,yBAAyB;gBACjC,SAAS,EAAE,4DAA4D;aACxE;YACD;gBACE,MAAM,EAAE,kBAAkB;gBAC1B,SAAS,EAAE,8DAA8D;aAC1E;SACF;KACF;IAED;QACE,IAAI,EAAE,oBAAoB;QAC1B,MAAM,EAAE,UAAU;QAClB,MAAM,EAAE,QAAQ;QAChB,SAAS,EACP,mHAAmH;QACrH,QAAQ,EAAE;;;;;;gDAMkC;QAC5C,KAAK,EAAE;YACL;gBACE,IAAI,EAAE,OAAO;gBACb,WAAW,EAAE,sCAAsC;gBACnD,MAAM,EAAE,qDAAqD;aAC9D;SACF;QACD,cAAc,EAAE;YACd;gBACE,MAAM,EAAE,cAAc;gBACtB,SAAS,EAAE,yDAAyD;aACrE;YACD;gBACE,MAAM,EAAE,WAAW;gBACnB,SAAS,EACP,sDAAsD;aACzD;YACD;gBACE,MAAM,EAAE,YAAY;gBACpB,SAAS,EAAE,kDAAkD;aAC9D;SACF;KACF;IAED;QACE,IAAI,EAAE,uBAAuB;QAC7B,MAAM,EAAE,eAAe;QACvB,MAAM,EAAE,QAAQ;QAChB,SAAS,EACP,8GAA8G;QAChH,QAAQ,EAAE;;;;;;;;;;;;;;;;;;yFAkB2E;QACrF,KAAK,EAAE;YACL;gBACE,IAAI,EAAE,kBAAkB;gBACxB,WAAW,EAAE,8BAA8B;gBAC3C,MAAM,EAAE,wCAAwC;aACjD;YACD;gBACE,IAAI,EAAE,gBAAgB;gBACtB,WAAW,EAAE,gCAAgC;gBAC7C,MAAM,EAAE,oDAAoD;aAC7D;YACD;gBACE,IAAI,EAAE,aAAa;gBACnB,WAAW,EAAE,uBAAuB;gBACpC,MAAM,EAAE,kEAAkE;aAC3E;SACF;QACD,cAAc,EAAE;YACd;gBACE,MAAM,EAAE,2BAA2B;gBACnC,SAAS,EACP,wFAAwF;aAC3F;YACD;gBACE,MAAM,EAAE,iBAAiB;gBACzB,SAAS,EACP,kFAAkF;aACrF;SACF;KACF;CACF,CAAC"}

package/dist/skills/types.d.ts

@@ -0,0 +1,54 @@
+import type { SolverType } from "../solvers/types.js";
+/** A slot in a template skeleton that must be filled */
+export interface SlotDef {
+    /** Slot name, matches {{SLOT:name}} in skeleton */
+    name: string;
+    /** What this slot expects */
+    description: string;
+    /** Expected format/type hint */
+    format: string;
+}
+/** A normalization recipe for mapping domain inputs to slot values */
+export interface Normalization {
+    /** What kind of input this handles */
+    source: string;
+    /** How to transform it */
+    transform: string;
+}
+/** A reusable formalization template */
+export interface SkillTemplate {
+    /** Unique identifier */
+    name: string;
+    /** Problem domain (authorization, configuration, dependency, validation, rules, analysis) */
+    domain: string;
+    /** Which solver this targets */
+    solver: SolverType;
+    /** Natural language description for search/matching */
+    signature: string;
+    /** The formal spec with {{SLOT:name}} markers */
+    skeleton: string;
+    /** Slots that need to be filled */
+    slots: SlotDef[];
+    /** Known normalization recipes */
+    normalizations: Normalization[];
+}
+/** Runtime metadata tracked per template */
+export interface SkillMetadata {
+    name: string;
+    reuseCount: number;
+    successCount: number;
+    lastUsed: string | null;
+    promoted: boolean;
+}
+/** Template with its metadata attached */
+export interface SkillWithMetadata {
+    template: SkillTemplate;
+    metadata: SkillMetadata;
+}
+/** Search result from the skill library */
+export interface SkillSearchResult {
+    template: SkillTemplate;
+    metadata: SkillMetadata;
+    score: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/skills/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/skills/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,wDAAwD;AACxD,MAAM,WAAW,OAAO;IACtB,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,6BAA6B;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,sEAAsE;AACtE,MAAM,WAAW,aAAa;IAC5B,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,0BAA0B;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wCAAwC;AACxC,MAAM,WAAW,aAAa;IAC5B,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,6FAA6F;IAC7F,MAAM,EAAE,MAAM,CAAC;IACf,gCAAgC;IAChC,MAAM,EAAE,UAAU,CAAC;IACnB,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,QAAQ,EAAE,MAAM,CAAC;IACjB,mCAAmC;IACnC,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,kCAAkC;IAClC,cAAc,EAAE,aAAa,EAAE,CAAC;CACjC;AAED,4CAA4C;AAC5C,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,0CAA0C;AAC1C,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,aAAa,CAAC;IACxB,QAAQ,EAAE,aAAa,CAAC;CACzB;AAED,2CAA2C;AAC3C,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,aAAa,CAAC;IACxB,QAAQ,EAAE,aAAa,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;CACf"}

package/dist/skills/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/skills/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/skills/types.ts"],"names":[],"mappings":""}

package/dist/solvers/correction-loop.d.ts

@@ -0,0 +1,34 @@
+import type { SolverInput, SolverResult } from "./types.js";
+/** A function that takes a broken spec + error and returns a patched spec */
+export type SpecFixer = (attempt: SolverInput, error: string, round: number) => Promise<SolverInput | null>;
+/** Record of a single correction attempt */
+export interface CorrectionAttempt {
+    round: number;
+    input: SolverInput;
+    result: SolverResult;
+}
+/** Result of the full correction loop */
+export interface CorrectionResult {
+    /** Final solver result (may be success or the last error) */
+    result: SolverResult;
+    /** Whether the loop converged to a valid result */
+    converged: boolean;
+    /** Number of rounds taken */
+    rounds: number;
+    /** Full history of attempts */
+    history: CorrectionAttempt[];
+}
+export interface CorrectionLoopOptions {
+    maxRounds?: number;
+}
+/**
+ * Run a bounded correction loop: submit spec to solver, if it errors
+ * call the fixer to patch it, resubmit, repeat up to maxRounds.
+ *
+ * The loop stops when:
+ * - The solver returns a non-error result (sat/unsat/unknown/success) → converged
+ * - The fixer returns null (gives up) → not converged
+ * - Max rounds reached → not converged
+ */
+export declare function correctionLoop(initialInput: SolverInput, fixer: SpecFixer, options?: CorrectionLoopOptions): Promise<CorrectionResult>;
+//# sourceMappingURL=correction-loop.d.ts.map

package/dist/solvers/correction-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correction-loop.d.ts","sourceRoot":"","sources":["../../src/solvers/correction-loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAK5D,6EAA6E;AAC7E,MAAM,MAAM,SAAS,GAAG,CACtB,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,KACV,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;AAEjC,4CAA4C;AAC5C,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,WAAW,CAAC;IACnB,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,yCAAyC;AACzC,MAAM,WAAW,gBAAgB;IAC/B,6DAA6D;IAC7D,MAAM,EAAE,YAAY,CAAC;IACrB,mDAAmD;IACnD,SAAS,EAAE,OAAO,CAAC;IACnB,6BAA6B;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,+BAA+B;IAC/B,OAAO,EAAE,iBAAiB,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,qBAAqB;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAClC,YAAY,EAAE,WAAW,EACzB,KAAK,EAAE,SAAS,EAChB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,gBAAgB,CAAC,CA+C3B"}

package/dist/solvers/correction-loop.js

@@ -0,0 +1,52 @@
+import { SolverSession } from "./session.js";
+const DEFAULT_MAX_ROUNDS = 5;
+/**
+ * Run a bounded correction loop: submit spec to solver, if it errors
+ * call the fixer to patch it, resubmit, repeat up to maxRounds.
+ *
+ * The loop stops when:
+ * - The solver returns a non-error result (sat/unsat/unknown/success) → converged
+ * - The fixer returns null (gives up) → not converged
+ * - Max rounds reached → not converged
+ */
+export async function correctionLoop(initialInput, fixer, options = {}) {
+    const maxRounds = options.maxRounds ?? DEFAULT_MAX_ROUNDS;
+    const history = [];
+    let currentInput = initialInput;
+    for (let round = 1; round <= maxRounds; round++) {
+        const solverType = currentInput.type === "z3" ? "z3" : "prolog";
+        const session = await SolverSession.create(solverType);
+        let result;
+        try {
+            result = await session.solve(currentInput);
+        }
+        finally {
+            session.dispose();
+        }
+        history.push({ round, input: currentInput, result });
+        // Non-error results mean the solver accepted the spec
+        if (result.status !== "error") {
+            return { result, converged: true, rounds: round, history };
+        }
+        // Last round — don't try to fix, just return
+        if (round === maxRounds) {
+            return { result, converged: false, rounds: round, history };
+        }
+        // Ask fixer to patch the spec
+        const patched = await fixer(currentInput, result.error, round);
+        if (patched === null) {
+            // Fixer gave up
+            return { result, converged: false, rounds: round, history };
+        }
+        currentInput = patched;
+    }
+    // Should not reach here, but satisfy TypeScript
+    const lastAttempt = history[history.length - 1];
+    return {
+        result: lastAttempt.result,
+        converged: false,
+        rounds: history.length,
+        history,
+    };
+}
+//# sourceMappingURL=correction-loop.js.map

package/dist/solvers/correction-loop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"correction-loop.js","sourceRoot":"","sources":["../../src/solvers/correction-loop.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C,MAAM,kBAAkB,GAAG,CAAC,CAAC;AAgC7B;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,YAAyB,EACzB,KAAgB,EAChB,UAAiC,EAAE;IAEnC,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,kBAAkB,CAAC;IAC1D,MAAM,OAAO,GAAwB,EAAE,CAAC;IAExC,IAAI,YAAY,GAAG,YAAY,CAAC;IAEhC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,IAAI,SAAS,EAAE,KAAK,EAAE,EAAE,CAAC;QAChD,MAAM,UAAU,GAAG,YAAY,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,IAAa,CAAC,CAAC,CAAC,QAAiB,CAAC;QAClF,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QAEvD,IAAI,MAAoB,CAAC;QACzB,IAAI,CAAC;YACH,MAAM,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QAC7C,CAAC;gBAAS,CAAC;YACT,OAAO,CAAC,OAAO,EAAE,CAAC;QACpB,CAAC;QAED,OAAO,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC,CAAC;QAErD,sDAAsD;QACtD,IAAI,MAAM,CAAC,MAAM,KAAK,OAAO,EAAE,CAAC;YAC9B,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;QAC7D,CAAC;QAED,6CAA6C;QAC7C,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;QAC9D,CAAC;QAED,8BAA8B;QAC9B,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,YAAY,EAAE,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC/D,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;YACrB,gBAAgB;YAChB,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;QAC9D,CAAC;QAED,YAAY,GAAG,OAAO,CAAC;IACzB,CAAC;IAED,gDAAgD;IAChD,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAChD,OAAO;QACL,MAAM,EAAE,WAAW,CAAC,MAAM;QAC1B,SAAS,EAAE,KAAK;QAChB,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,OAAO;KACR,CAAC;AACJ,CAAC"}

package/dist/solvers/prolog-solver.d.ts

@@ -0,0 +1,3 @@
+import type { Solver } from "./types.js";
+export declare function createPrologSolver(): Solver;
+//# sourceMappingURL=prolog-solver.d.ts.map

package/dist/solvers/prolog-solver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prolog-solver.d.ts","sourceRoot":"","sources":["../../src/solvers/prolog-solver.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAA2C,MAAM,YAAY,CAAC;AA6ClF,wBAAgB,kBAAkB,IAAI,MAAM,CAyD3C"}

package/dist/solvers/prolog-solver.js

@@ -0,0 +1,93 @@
+import pl from "tau-prolog";
+const MAX_ANSWERS = 1000;
+const MAX_INFERENCES = 100_000;
+// Tau Prolog is callback-based; these wrap it in promises.
+function consult(session, program) {
+    return new Promise((resolve, reject) => {
+        session.consult(program, {
+            success: () => resolve(),
+            error: (err) => reject(err),
+        });
+    });
+}
+function query(session, goal) {
+    return new Promise((resolve, reject) => {
+        session.query(goal, {
+            success: () => resolve(),
+            error: (err) => reject(err),
+        });
+    });
+}
+function nextAnswer(session) {
+    return new Promise((resolve, reject) => {
+        session.answer({
+            success: (ans) => resolve(ans),
+            fail: () => resolve(null),
+            error: (err) => reject(err),
+            limit: () => reject(new Error("inference limit exceeded")),
+        });
+    });
+}
+function formatError(session, err) {
+    if (err instanceof Error)
+        return err.message;
+    try {
+        return session.format_answer(err) || String(err);
+    }
+    catch {
+        return String(err);
+    }
+}
+export function createPrologSolver() {
+    let disposed = false;
+    return {
+        type: "prolog",
+        async solve(input) {
+            if (input.type !== "prolog") {
+                return { status: "error", error: "Expected prolog input type" };
+            }
+            const session = pl.create(MAX_INFERENCES);
+            try {
+                await consult(session, input.program);
+            }
+            catch (e) {
+                return { status: "error", error: formatError(session, e) };
+            }
+            try {
+                await query(session, input.query);
+            }
+            catch (e) {
+                return { status: "error", error: formatError(session, e) };
+            }
+            const answers = [];
+            try {
+                for (let i = 0; i < MAX_ANSWERS; i++) {
+                    const ans = await nextAnswer(session);
+                    if (ans === null)
+                        break;
+                    const bindings = {};
+                    const links = ans.links;
+                    if (links) {
+                        for (const [name, term] of Object.entries(links)) {
+                            bindings[name] = term.toString?.()
+                                ?? term.id
+                                ?? String(term);
+                        }
+                    }
+                    const formatted = pl.format_answer(ans) ?? "";
+                    answers.push({ bindings, formatted });
+                }
+            }
+            catch (e) {
+                return { status: "error", error: formatError(session, e) };
+            }
+            return { status: "success", answers };
+        },
+        dispose() {
+            if (!disposed) {
+                disposed = true;
+            }
+        },
+    };
+}
+//# sourceMappingURL=prolog-solver.js.map

package/dist/solvers/prolog-solver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prolog-solver.js","sourceRoot":"","sources":["../../src/solvers/prolog-solver.ts"],"names":[],"mappings":"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"}