@smartergpt/lexrunner 1.5.1 → 2.0.0

package/dist/errors/index.cjs

@@ -133,6 +133,10 @@ var CONFIG_ERROR_CODES = {
 var POLICY_ERROR_CODES = {
   /** No policy file found in any search path */
   POLICY_NOT_FOUND: "POLICY_NOT_FOUND",
+  /** A policy output already exists and overwrite was not explicit */
+  POLICY_ALREADY_EXISTS: "POLICY_ALREADY_EXISTS",
+  /** A constrained policy source directory resolves outside the repository */
+  POLICY_SOURCE_DIR_OUTSIDE_ROOT: "POLICY_SOURCE_DIR_OUTSIDE_ROOT",
   /** Policy file exists but has invalid JSON */
   POLICY_PARSE_ERROR: "POLICY_PARSE_ERROR",
   /** Policy file fails schema validation */

package/dist/frames/index.cjs

@@ -9913,6 +9913,10 @@ var CONFIG_ERROR_CODES = {
 var POLICY_ERROR_CODES = {
   /** No policy file found in any search path */
   POLICY_NOT_FOUND: "POLICY_NOT_FOUND",
+  /** A policy output already exists and overwrite was not explicit */
+  POLICY_ALREADY_EXISTS: "POLICY_ALREADY_EXISTS",
+  /** A constrained policy source directory resolves outside the repository */
+  POLICY_SOURCE_DIR_OUTSIDE_ROOT: "POLICY_SOURCE_DIR_OUTSIDE_ROOT",
   /** Policy file exists but has invalid JSON */
   POLICY_PARSE_ERROR: "POLICY_PARSE_ERROR",
   /** Policy file fails schema validation */
@@ -10436,7 +10440,10 @@ var CLI_CAPABILITIES = Object.freeze({
   check: Object.freeze([]),
   timeline: Object.freeze([RUNTIME_OPERATION_CAPABILITIES.FRAME_READ]),
   "frames:export": Object.freeze([RUNTIME_OPERATION_CAPABILITIES.FRAME_READ]),
-  "frames:import": Object.freeze([RUNTIME_OPERATION_CAPABILITIES.FRAME_WRITE]),
+  "frames:import": Object.freeze([
+    RUNTIME_OPERATION_CAPABILITIES.FRAME_READ,
+    RUNTIME_OPERATION_CAPABILITIES.FRAME_WRITE
+  ]),
   "db:vacuum": Object.freeze([RUNTIME_OPERATION_CAPABILITIES.FRAME_ADMIN]),
   "db:backup": Object.freeze([RUNTIME_OPERATION_CAPABILITIES.FRAME_ADMIN]),
   "db:repair": Object.freeze([RUNTIME_OPERATION_CAPABILITIES.FRAME_ADMIN]),
@@ -10447,6 +10454,7 @@ var CLI_CAPABILITIES = Object.freeze({
   "db:encrypt": Object.freeze([RUNTIME_OPERATION_CAPABILITIES.FRAME_ADMIN]),
   "db:stats": Object.freeze([RUNTIME_OPERATION_CAPABILITIES.FRAME_READ]),
   "policy:check": Object.freeze([]),
+  "policy:generate": Object.freeze([]),
   "policy:add-module": Object.freeze([]),
   "instructions:init": Object.freeze([]),
   "instructions:generate": Object.freeze([]),
@@ -10936,6 +10944,7 @@ var FrameSpendMetadata = import_zod5.z.object({
   prompts: import_zod5.z.number().optional(),
   tokens_estimated: import_zod5.z.number().optional()
 });
+var CallerProvenance = import_zod5.z.record(import_zod5.z.string(), import_zod5.z.json());
 var ModuleAttribution = import_zod5.z.object({
   mode: import_zod5.z.enum(["explicit", "inferred", "fallback"]),
   confidence: import_zod5.z.enum(["high", "medium", "low"]),
@@ -10966,7 +10975,8 @@ var FrameStatusSnapshot = import_zod5.z.object({
   next_action: import_zod5.z.string(),
   blockers: import_zod5.z.array(import_zod5.z.string()).optional(),
   merge_blockers: import_zod5.z.array(import_zod5.z.string()).optional(),
-  tests_failing: import_zod5.z.array(import_zod5.z.string()).optional()
+  tests_failing: import_zod5.z.array(import_zod5.z.string()).optional(),
+  provenance: CallerProvenance.optional()
 });
 var CapabilityTier = import_zod5.z.enum(["senior", "mid", "junior"]);
 var TaskComplexity = import_zod5.z.object({
@@ -10994,7 +11004,7 @@ var Frame = import_zod5.z.object({
   status_snapshot: FrameStatusSnapshot,
   keywords: import_zod5.z.array(import_zod5.z.string()).optional(),
   atlas_frame_id: import_zod5.z.string().optional(),
-  // Link to Atlas Frame (spatial neighborhood)
+  // Legacy Policy Neighborhood snapshot reference
   feature_flags: import_zod5.z.array(import_zod5.z.string()).optional(),
   permissions: import_zod5.z.array(import_zod5.z.string()).optional(),
   module_attribution: ModuleAttribution.optional(),
@@ -11218,6 +11228,13 @@ var COMPATIBILITY_OBJECTS = Object.freeze({
 
 // node_modules/@smartergpt/lex/dist/memory/store/postgres/scoped-frame-store.js
 var import_node_crypto14 = require("crypto");
+var FRAME_STORE_PROTECTED_RELATIONS = Object.freeze([
+  "frames",
+  "lex_frame_store_migrations",
+  "lex_frame_store_unowned_frames_v1",
+  "lex_frame_store_recovery_operations",
+  "lex_frame_store_recovery_assignments"
+]);
 
 // node_modules/@smartergpt/lex/dist/memory/store/postgres/behavioral-store.js
 var import_node_crypto15 = require("crypto");

package/mcp-server.mjs

@@ -455,10 +455,23 @@ const tools = {
           type: "string",
           description: "Output directory for gate results",
         },
+        timeoutMs: {
+          type: "integer",
+          minimum: 1,
+          maximum: 86400000,
+          description:
+            "Operation-default gate timeout in milliseconds; a plan gate timeoutMs overrides it exactly",
+        },
       },
     },
     call: async (args) => {
       try {
+        if (
+          args.timeoutMs !== undefined &&
+          (!Number.isInteger(args.timeoutMs) || args.timeoutMs < 1 || args.timeoutMs > 86400000)
+        ) {
+          throw new Error("timeoutMs must be an integer from 1 through 86400000 milliseconds");
+        }
         const artifact = new core.PlanArtifactService().resolve({
           planFile: args.planFile,
           workingDir: process.cwd(),
@@ -472,6 +485,7 @@ const tools = {
           await new core.GateExecutionService().run({
             plan: artifact.plan,
             artifactDir: outDir,
+            timeoutMs: args.timeoutMs,
             onlyItem: args.onlyItem,
             onlyGate: args.onlyGate,
             options: { emitReceipt: false, suppressStdout: true },
@@ -621,7 +635,7 @@ const tools = {
   },
 
   health: {
-    description: "DEPRECATED: use doctor. Compatibility alias scheduled for removal in 2.0.0.",
+    description: "DEPRECATED: use doctor. Compatibility alias scheduled for removal in 3.0.0.",
     inputSchema: {
       type: "object",
       properties: {
@@ -640,7 +654,7 @@ const tools = {
         });
         const health = {
           ...doctor,
-          deprecation: { tool: "health", replacement: "doctor", removeIn: "2.0.0" },
+          deprecation: { tool: "health", replacement: "doctor", removeIn: "3.0.0" },
         };
 
         return {
@@ -884,17 +898,52 @@ const tools = {
           description:
             "Explicit plan.json path (default: repository plan.json, then profile runner fallback)",
         },
+        evidenceFile: {
+          type: "string",
+          minLength: 1,
+          maxLength: 4096,
+          description: "Explicit gate evidence manifest returned by gates.run",
+        },
+        evidenceSha256: {
+          type: "string",
+          pattern: "^sha256:[a-f0-9]{64}$",
+          description: "Expected SHA-256 returned with the gate evidence manifest",
+        },
       },
     },
     call: async (args) => {
       try {
+        const hasEvidenceFile = args.evidenceFile !== undefined;
+        const hasEvidenceDigest = args.evidenceSha256 !== undefined;
+        if (hasEvidenceFile !== hasEvidenceDigest) {
+          throw new Error("evidenceFile and evidenceSha256 must be supplied together");
+        }
+        if (
+          hasEvidenceFile &&
+          (typeof args.evidenceFile !== "string" ||
+            args.evidenceFile.length < 1 ||
+            Buffer.byteLength(args.evidenceFile, "utf8") > 4096 ||
+            typeof args.evidenceSha256 !== "string" ||
+            !/^sha256:[a-f0-9]{64}$/u.test(args.evidenceSha256))
+        ) {
+          throw new Error("evidenceFile or evidenceSha256 is invalid");
+        }
         const artifact = new core.PlanArtifactService().resolve({
           planFile: args.planFile,
           workingDir: process.cwd(),
           profileDir: config.profileDir,
         });
         const result = {
-          ...new core.IntegrationStatusQueryService().run(artifact.plan),
+          ...new core.IntegrationStatusQueryService().run(
+            artifact.plan,
+            args.evidenceFile
+              ? {
+                  evidenceFile: args.evidenceFile,
+                  evidenceSha256: args.evidenceSha256,
+                  repoRoot: process.cwd(),
+                }
+              : undefined
+          ),
           planArtifact: artifact.identity,
         };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartergpt/lexrunner",
-  "version": "1.5.1",
+  "version": "2.0.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -131,7 +131,7 @@
     "@modelcontextprotocol/sdk": "^1.18.2",
     "@octokit/auth-token": "^6.0.0",
     "@octokit/rest": "^22.0.0",
-    "@smartergpt/lex": "^4.0.0",
+    "@smartergpt/lex": "4.0.3",
     "@types/babel__traverse": "^7.28.0",
     "ajv": "^8.20.0",
     "better-sqlite3-multiple-ciphers": "^12.6.2",

package/schemas/gate-evidence-manifest.schema.json

@@ -0,0 +1,86 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://smartergpt.dev/schemas/lexrunner/gate-evidence-manifest-v1.json",
+  "title": "LexRunner Gate Evidence Manifest v1",
+  "type": "object",
+  "required": ["schemaVersion", "createdAt", "plan", "candidate", "selection", "entries"],
+  "properties": {
+    "schemaVersion": { "const": "lexrunner-gate-evidence-manifest/v1" },
+    "createdAt": { "type": "string" },
+    "plan": {
+      "type": "object",
+      "required": ["digest", "schemaVersion", "target", "itemCount"],
+      "properties": {
+        "digest": { "$ref": "#/$defs/sha256" },
+        "schemaVersion": { "type": "string" },
+        "target": { "type": "string" },
+        "itemCount": { "type": "integer", "minimum": 0 }
+      },
+      "additionalProperties": false
+    },
+    "candidate": {
+      "type": "object",
+      "required": ["repositoryRoot", "head", "worktreeDigest"],
+      "properties": {
+        "repositoryRoot": { "type": "string", "minLength": 1 },
+        "head": { "type": "string", "pattern": "^[a-f0-9]{40,64}$" },
+        "worktreeDigest": { "$ref": "#/$defs/sha256" }
+      },
+      "additionalProperties": false
+    },
+    "selection": {
+      "type": "object",
+      "required": ["onlyItem", "onlyGate"],
+      "properties": {
+        "onlyItem": { "type": ["string", "null"] },
+        "onlyGate": { "type": ["string", "null"] }
+      },
+      "additionalProperties": false
+    },
+    "entries": {
+      "type": "array",
+      "maxItems": 16384,
+      "items": {
+        "type": "object",
+        "required": ["item", "gate", "declaredGateDigest", "result", "receipt"],
+        "properties": {
+          "item": { "type": "string", "minLength": 1, "maxLength": 512 },
+          "gate": { "type": "string", "minLength": 1, "maxLength": 512 },
+          "declaredGateDigest": { "$ref": "#/$defs/sha256" },
+          "result": {
+            "type": "object",
+            "required": ["status", "attempts"],
+            "properties": {
+              "status": {
+                "enum": ["pass", "fail", "blocked", "skipped", "retrying"]
+              },
+              "exitCode": { "type": "number" },
+              "duration": { "type": "number", "minimum": 0 },
+              "timeoutMs": { "type": "integer", "minimum": 1 },
+              "failureKind": {
+                "enum": ["nonzero_exit", "spawn_error", "timeout", "evidence_error"]
+              },
+              "attempts": { "type": "integer", "minimum": 0 },
+              "lastAttempt": { "type": "string" }
+            },
+            "additionalProperties": false
+          },
+          "receipt": {
+            "type": "object",
+            "required": ["path", "sha256"],
+            "properties": {
+              "path": { "type": "string", "minLength": 1, "maxLength": 4096 },
+              "sha256": { "$ref": "#/$defs/sha256" }
+            },
+            "additionalProperties": false
+          }
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "$defs": {
+    "sha256": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" }
+  },
+  "additionalProperties": false
+}

package/schemas/gate-execution-receipt.schema.json

@@ -8,6 +8,7 @@
   "required": [
     "schemaVersion",
     "attempt",
+    "binding",
     "declaredGate",
     "execution",
     "outcome",
@@ -15,8 +16,27 @@
     "artifacts"
   ],
   "properties": {
-    "schemaVersion": { "const": "lexrunner-gate-execution-receipt/v1" },
+    "schemaVersion": { "const": "lexrunner-gate-execution-receipt/v2" },
     "attempt": { "type": "integer", "minimum": 1 },
+    "binding": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["item", "declaredGateDigest", "candidateDigest", "timeoutMs"],
+      "properties": {
+        "item": { "type": ["string", "null"], "minLength": 1 },
+        "declaredGateDigest": {
+          "type": "string",
+          "pattern": "^sha256:[a-f0-9]{64}$"
+        },
+        "candidateDigest": {
+          "anyOf": [
+            { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
+            { "type": "null" }
+          ]
+        },
+        "timeoutMs": { "type": "integer", "minimum": 1 }
+      }
+    },
     "declaredGate": {
       "type": "object",
       "additionalProperties": false,

package/schemas/plan.schema.json

@@ -139,7 +139,7 @@
               "additionalProperties": false,
               "default": {}
             },
-            "security": {
+        "security": {
               "type": "object",
               "properties": {
                 "blockCritical": {
@@ -272,6 +272,11 @@
                     "input": {
                       "type": "object",
                       "additionalProperties": {}
+                    },
+                    "timeoutMs": {
+                      "type": "integer",
+                      "exclusiveMinimum": 0,
+                      "maximum": 86400000
                     }
                   },
                   "required": [
@@ -297,4 +302,4 @@
       "additionalProperties": false
     }
   }
-}
+}