@smartergpt/lexrunner 1.4.0 → 1.4.1

package/CHANGELOG.md

@@ -6,6 +6,24 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 
 ## [Unreleased]
 
+## [1.4.1] - 2026-08-04
+
+### Added
+
+- **Canonical CLI executable** - Publish `lexrunner` as the primary npm binary alongside
+  `lexrunner-mcp` and the retained `lex-pr` compatibility alias.
+
+### Changed
+
+- **Consistent CLI identity** - Use `lexrunner` in root and subcommand help, completions, diagnostic
+  prefixes, installation guidance, current release documentation, and generated CLI/MCP surface
+  guidance.
+
+### Fixed
+
+- **Package/executable mismatch** - Ensure installing `@smartergpt/lexrunner` exposes an executable
+  matching the package and product name without breaking existing `lex-pr` automation.
+
 ## [1.4.0] - 2026-08-04
 
 ### Added

package/README.md

@@ -1,4 +1,4 @@
-# LexRunner (`lex-pr`)
+# LexRunner (`lexrunner`)
 
 LexRunner turns a changing set of pull requests into a reviewable integration program: discover
 the work, freeze a dependency plan, run bounded gates, preserve evidence, and merge only with
@@ -19,13 +19,13 @@ branch, pushing, opening a PR, or merging requires separate approval.
 
 LexRunner’s supported workflow has grown in layers. A normal user can stop at any layer.
 
-| Layer               | Current capability                                                                                           | First surface                       |
-| ------------------- | ------------------------------------------------------------------------------------------------------------ | ----------------------------------- |
-| Deterministic plan  | Freeze PRs and declared dependencies into schema-versioned `plan.json`                                       | `lex-pr weave plan`                 |
-| Merge-weave         | Compute merge order, preview integration, run gates, and apply authorized merges                             | `lex-pr weave *`, `lex-pr gate run` |
-| Run and evidence    | Persist bounded receipts, independent verification, acceptance, and artifacts                                | `lex-pr attempt *`                  |
-| Fanout              | Harvest and analyze issue/PR evidence for parallel work planning                                             | `lex-pr fanout *`                   |
-| Assisted agent work | Prepare an immutable packet and workspace envelope, attach a foreground-owned worker, then verify its claims | CLI/MCP Attempt lifecycle           |
+| Layer               | Current capability                                                                                           | First surface                             |
+| ------------------- | ------------------------------------------------------------------------------------------------------------ | ----------------------------------------- |
+| Deterministic plan  | Freeze PRs and declared dependencies into schema-versioned `plan.json`                                       | `lexrunner weave plan`                    |
+| Merge-weave         | Compute merge order, preview integration, run gates, and apply authorized merges                             | `lexrunner weave *`, `lexrunner gate run` |
+| Run and evidence    | Persist bounded receipts, independent verification, acceptance, and artifacts                                | `lexrunner attempt *`                     |
+| Fanout              | Harvest and analyze issue/PR evidence for parallel work planning                                             | `lexrunner fanout *`                      |
+| Assisted agent work | Prepare an immutable packet and workspace envelope, attach a foreground-owned worker, then verify its claims | CLI/MCP Attempt lifecycle                 |
 
 The ADR-010 coordination model is accepted and its assisted Attempt lifecycle is implemented.
 LexRunner also has a tested headless reconciliation **application boundary**, but it is not a
@@ -39,21 +39,21 @@ remain unproven. See [ADR-010](docs/adr/ADR-010-agent-work-orchestration-protoco
 First inspect without mutation:
 
 ```bash
-lex-pr --version
-lex-pr workspace doctor --json
-lex-pr weave discover --json
+lexrunner --version
+lexrunner workspace doctor --json
+lexrunner weave discover --json
 ```
 
 After approving a local, reversible artifact, freeze and inspect a plan:
 
 ```bash
-lex-pr weave plan --from-github --output plan.json --json
-lex-pr schema validate plan.json --json
-lex-pr weave merge-order plan.json --json
-lex-pr gate run plan.json --dry-run --json
+lexrunner weave plan --from-github --output plan.json --json
+lexrunner schema validate plan.json --json
+lexrunner weave merge-order plan.json --json
+lexrunner gate run plan.json --dry-run --json
 ```
 
-These commands do not merge. `lex-pr weave apply --execute` is a separate mutation and should be
+These commands do not merge. `lexrunner weave apply --execute` is a separate mutation and should be
 run only after reviewing the frozen plan, authority, gates, and target branch.
 
 For a guided merge-weave walkthrough, use
@@ -94,28 +94,33 @@ organization, so a human with organization access must authenticate the npm CLI
 ```bash
 npm login --scope=@smartergpt --registry=https://registry.npmjs.org/
 npm install --save-dev @smartergpt/lexrunner
-npx lex-pr --version
+npx lexrunner --version
 ```
 
 Global installation is also supported:
 
 ```bash
 npm install --global @smartergpt/lexrunner
-lex-pr --version
+lexrunner --version
 ```
 
 Do not place npm tokens in the repository or a chat transcript. Windows/private-package validation
 is documented in the [Node 24 migration guide](docs/node-24-migration.md).
 
-The checked-in package version is the single source for `lex-pr --version`.
+`lexrunner` is the canonical CLI name. The existing `lex-pr` executable remains an additive
+compatibility alias and invokes the same program, so existing automation does not need to change.
+
+The checked-in package version is the single source for `lexrunner --version` and
+`lex-pr --version`.
 
 <!-- BEGIN GENERATED PACKAGE VERSION -->
 
-Current repository package version: **1.4.0**. npm availability and dist-tags are separate
+Current repository package version: **1.4.1**. npm availability and dist-tags are separate
 release evidence; inspect the registry rather than inferring publication from source metadata.
 <!-- END GENERATED PACKAGE VERSION -->
 
-See the [1.4.0 release notes](docs/releases/1.4.0.md), the
+See the [1.4.1 release notes](docs/releases/1.4.1.md), the
+[1.4.0 native-host boundary release](docs/releases/1.4.0.md), the
 [1.3.0 dogfood release](docs/releases/1.3.0.md), the
 [1.2.1 publication repair](docs/releases/1.2.1.md), and the underlying
 [1.2.0 compatibility decision](docs/releases/1.2.0.md) for package disposition, semver rationale,
@@ -172,7 +177,7 @@ For implementation work, use the touched/adjacent gate selector and let CI prove
 high-risk changes:
 
 ```bash
-lex-pr gate select --base <base-sha> --head <head-sha> --json
+lexrunner gate select --base <base-sha> --head <head-sha> --json
 ```
 
 Release validation remains exhaustive. See [`AGENTS.md`](AGENTS.md),
@@ -182,7 +187,7 @@ Release validation remains exhaustive. See [`AGENTS.md`](AGENTS.md),
 ## Package and licensing
 
 - Package: `@smartergpt/lexrunner`
-- CLI: `lex-pr`
+- CLI: `lexrunner` (`lex-pr` compatibility alias)
 - MCP bin: `lexrunner-mcp`
 - Runtime dependency: `@smartergpt/lex` (MIT)
 - LexRunner license: SmarterGPT Source-Available Personal Use License

package/dist/{audit-5ZUBPZZX.js → audit-SKMMC2U4.js}

@@ -23,7 +23,7 @@ import {
   sanitizeEnv,
   sanitizeFileContent,
   writeManifest
-} from "./chunk-R4DWK6FE.js";
+} from "./chunk-6PZDSWCG.js";
 import {
   generateSARIF,
   writeSARIF

package/dist/{autopilot-JXO4MZ6H.js → autopilot-EBZ44LYS.js}

@@ -16,7 +16,7 @@ import {
   hasCapability,
   parseAutopilotConfig,
   validateAutopilotConfig
-} from "./chunk-WSJEPY7T.js";
+} from "./chunk-4R52WTFO.js";
 import "./chunk-4FFGNTAV.js";
 import "./chunk-6A4IE3TI.js";
 import "./chunk-VAGHAQT2.js";

package/dist/{chunk-WSJEPY7T.js → chunk-4R52WTFO.js}

@@ -2100,7 +2100,7 @@ function validateGateInput(gateName, input) {
   const schema = loadGateSchema(gateName);
   if (!schema) {
     console.warn(
-      "[lex-pr] validator: missing schema for gate; validation skipped (will be required in v1.0.0)"
+      "[lexrunner] validator: missing schema for gate; validation skipped (will be required in v1.0.0)"
     );
     return;
   }

package/dist/{chunk-R4DWK6FE.js → chunk-6PZDSWCG.js}

@@ -514,7 +514,7 @@ var AuditEmitter = class {
           const auditContext = await collectContext(contextTypes);
           this.context = auditContext;
         } catch (err) {
-          console.warn("[lex-pr] audit: context collection failed", err);
+          console.warn("[lexrunner] audit: context collection failed", err);
           this.context = {};
         }
       } else {
@@ -534,7 +534,7 @@ var AuditEmitter = class {
     }
     this.ndjsonStream = fs3.createWriteStream(this.ndjsonPath, { flags: "a", autoClose: true });
     this.ndjsonStream.on("error", (err) => {
-      console.warn("[lex-pr] audit: ndjson stream error (ignored)", String(err));
+      console.warn("[lexrunner] audit: ndjson stream error (ignored)", String(err));
     });
     const schemaPath = path3.join(this.auditDir, "audit.schema.json");
     const schema = {
@@ -627,7 +627,7 @@ var AuditEmitter = class {
         this.ndjsonStream.write(line);
       }
     } catch (e) {
-      console.warn("[lex-pr] audit: ndjson write failed (ignored)", String(e));
+      console.warn("[lexrunner] audit: ndjson write failed (ignored)", String(e));
     }
     this.eventCount++;
     this.eventsByType[event] = (this.eventsByType[event] || 0) + 1;
@@ -652,7 +652,7 @@ var AuditEmitter = class {
       try {
         await this.ingestSidecar();
       } catch (e) {
-        console.warn("[lex-pr] audit: sidecar ingestion error (ignored)", String(e));
+        console.warn("[lexrunner] audit: sidecar ingestion error (ignored)", String(e));
       }
     }, 5e3);
     try {
@@ -689,11 +689,14 @@ var AuditEmitter = class {
             this.eventsByType[event.event] = (this.eventsByType[event.event] || 0) + 1;
           }
         } catch (innerErr) {
-          console.warn("[lex-pr] audit: error ingesting sidecar event (ignored)", String(innerErr));
+          console.warn(
+            "[lexrunner] audit: error ingesting sidecar event (ignored)",
+            String(innerErr)
+          );
         }
       });
     } catch (err) {
-      console.warn("[lex-pr] audit: ingestSidecarFiles failed (ignored)", String(err));
+      console.warn("[lexrunner] audit: ingestSidecarFiles failed (ignored)", String(err));
     }
   }
   /**
@@ -862,11 +865,11 @@ var AuditEmitter = class {
             else if (status === "blocked") totalBlocked++;
           }
         } catch (parseError) {
-          console.warn("[lex-pr] audit: skipping malformed line in audit.ndjson");
+          console.warn("[lexrunner] audit: skipping malformed line in audit.ndjson");
         }
       }
     } catch (e) {
-      console.warn("[lex-pr] audit: failed to read audit.ndjson (ignored)", String(e));
+      console.warn("[lexrunner] audit: failed to read audit.ndjson (ignored)", String(e));
       return;
     }
     const gateMatrix = {
@@ -909,11 +912,11 @@ var AuditEmitter = class {
             vulnEvents.push(event);
           }
         } catch (parseError) {
-          console.warn("[lex-pr] audit: skipping malformed line in audit.ndjson");
+          console.warn("[lexrunner] audit: skipping malformed line in audit.ndjson");
         }
       }
     } catch (e) {
-      console.warn("[lex-pr] audit: failed to read audit.ndjson for SARIF (ignored)", String(e));
+      console.warn("[lexrunner] audit: failed to read audit.ndjson for SARIF (ignored)", String(e));
       return;
     }
     if (vulnEvents.length === 0) {

package/dist/{chunk-WFN4JTZI.js → chunk-LQSRQ6Z3.js}

@@ -213,18 +213,18 @@ function readGovernanceLogs() {
         const [major] = rawLog.schemaVersion.split(".").map(Number);
         if (major > CURRENT_MAJOR_VERSION) {
           console.warn(
-            `[lex-pr] Skipping log ${file}: schema v${rawLog.schemaVersion} not supported (current: v${CURRENT_MAJOR_VERSION}.x.x)`
+            `[lexrunner] Skipping log ${file}: schema v${rawLog.schemaVersion} not supported (current: v${CURRENT_MAJOR_VERSION}.x.x)`
           );
           continue;
         }
       } else {
-        console.warn(`[lex-pr] Skipping log ${file}: missing schemaVersion (legacy format)`);
+        console.warn(`[lexrunner] Skipping log ${file}: missing schemaVersion (legacy format)`);
         continue;
       }
       const parsed = GovernanceComparisonLogSchema.parse(rawLog);
       logs.push(parsed);
     } catch (error) {
-      console.warn(`[lex-pr] Skipping invalid log ${file}:`, error);
+      console.warn(`[lexrunner] Skipping invalid log ${file}:`, error);
     }
   }
   logs.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
@@ -248,7 +248,7 @@ function readGovernanceLogsWithLegacy() {
         const [major] = rawLog.schemaVersion.split(".").map(Number);
         if (major > CURRENT_MAJOR_VERSION) {
           console.warn(
-            `[lex-pr] Skipping log ${file}: schema v${rawLog.schemaVersion} not supported (current: v${CURRENT_MAJOR_VERSION}.x.x)`
+            `[lexrunner] Skipping log ${file}: schema v${rawLog.schemaVersion} not supported (current: v${CURRENT_MAJOR_VERSION}.x.x)`
           );
           continue;
         }
@@ -291,7 +291,7 @@ function readGovernanceLogsWithLegacy() {
         normalizationWarnings: warnings
       });
     } catch (error) {
-      console.warn(`[lex-pr] Skipping invalid log ${file} (even with normalization):`, error);
+      console.warn(`[lexrunner] Skipping invalid log ${file} (even with normalization):`, error);
     }
   }
   results.sort((a, b) => new Date(b.log.timestamp).getTime() - new Date(a.log.timestamp).getTime());