@sangyaahub/pi-marg 1.0.0 → 1.0.1

package/.omp-plugin/marketplace.json

@@ -7,14 +7,14 @@
   },
   "metadata": {
     "description": "PiMarg — a governed development path for Pi Agent and Oh My Pi.",
-    "version": "1.0.0"
+    "version": "1.0.1"
   },
   "plugins": [
     {
       "name": "pi-marg",
       "description": "Intent-led development workflow with live A/B/C/D routing, capability detection, verification, and approval gates.",
       "source": "./",
-      "version": "1.0.0",
+      "version": "1.0.1",
       "author": {
         "name": "Sangyaa",
         "email": "contact@sangyaa.co"

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.0.1 — 2026-09-10
+
+- Added the global `pi-marg start` and `pi-marg "<work prompt>"` OMP launch commands.
+- Canonicalized the npm executable mapping so npm installs the global `pi-marg` command.
+- Added native interactive OMP intake for work boundary, work type, workflow skill, and required A/B/C/D model choices.
+- Changed model pickers to show every authenticated and enabled runtime model while ranking stage-appropriate choices first.
+- Preserved independent-review enforcement: A cannot equal C, and B cannot equal D.
+
 ## 1.0.0 — 2026-09-08
 
 - First PiMarg release for Pi Agent and Oh My Pi.

package/MODEL-SETUP.md

@@ -39,20 +39,22 @@ The Pi adapter reads `ctx.scopedModels` when the session has a model allowlist;
 Use OMP `/login`, then inspect `/model` or:
 
 ```bash
-omp models list
+omp models
 ```
 
-The OMP adapter reads `ctx.models.list()` and activates an exact catalog entry with `pi.setModel()`.
+The OMP adapter reads `ctx.models.list()`, which supplies authenticated and enabled models, and activates an exact catalog entry with `pi.setModel()`.
 
 ## Selection workflow
 
-1. Run `/auto-models choose`.
-2. Request `action: catalog` with the confirmed work type.
-3. Select A and C from frontier candidates.
-4. Select B and D when implementation is required.
+1. Run `/pi-marg` for the full native intake, or `/auto-models choose` to change saved models.
+2. Confirm the work type so PiMarg knows which stages are required.
+3. Select A and C when discovery/review is required; recommended frontier choices appear first.
+4. Select B and D when implementation is required; recommended execution choices appear first.
 5. Resolve any A=C or B=D identity conflict before continuing.
 6. Activate the saved selector immediately before its stage.
 
+Every authenticated and enabled runtime model remains selectable at every required stage. The preferred classes above control ranking, not visibility.
+
 The normalized identity check treats the same underlying model reached through different providers as the same candidate when their identifiers normalize equally.
 
 ## Devin

package/PUBLISHING.md

@@ -5,7 +5,7 @@ This checklist is for maintainers. Public mutations remain subject to PiMarg's o
 ## Before a release
 
 1. Update `package.json`, `.omp-plugin/marketplace.json`, and `CHANGELOG.md` to the same version.
-2. Run `./scripts/validate.sh`, `bun test tests`, and `npm pack --dry-run`.
+2. Run `./scripts/validate.sh`, `bun test tests`, `node bin/pi-marg.js --version`, and `npm pack --dry-run`.
 3. Smoke-test the package root with the supported Pi and OMP versions.
 4. Inspect the packed file list for secrets, generated debris, and missing runtime files.
 

package/README.md

@@ -3,7 +3,7 @@
 </p>
 
 <p align="center">
-  <a href="https://github.com/sangyaahub/pi-marg/releases"><img alt="Version 1.0.0" src="https://img.shields.io/badge/version-1.0.0-0451F7"></a>
+  <a href="https://github.com/sangyaahub/pi-marg/releases"><img alt="Version 1.0.1" src="https://img.shields.io/badge/version-1.0.1-0451F7"></a>
   <a href="LICENSE"><img alt="MIT License" src="https://img.shields.io/badge/license-MIT-C27B1A"></a>
   <a href="https://pi.dev/packages?name=pi-marg"><img alt="Pi package" src="https://img.shields.io/badge/Pi-package-0338A8"></a>
   <a href="https://omp.sh"><img alt="Oh My Pi plugin" src="https://img.shields.io/badge/OMP-plugin-021E5C"></a>
@@ -11,7 +11,7 @@
 
 # PiMarg
 
-**Version 1.0.0 · MIT licensed · Pi Agent + Oh My Pi · by [Sangyaa](https://sangyaa.co)**
+**Version 1.0.1 · MIT licensed · Pi Agent + Oh My Pi · by [Sangyaa](https://sangyaa.co)**
 
 PiMarg turns an ordinary prompt into a governed development path. It identifies the work boundary, selects one engineering method, discovers the models and tools the active runtime really provides, separates thinking from execution, records evidence, and stops before protected actions.
 
@@ -42,7 +42,7 @@ The same model-selection and approval logic lives in `core/`. Runtime-specific c
 - Confirms job/client versus personal work; job/client mode suppresses Sangyaa branding by default.
 - Routes seven work types: idea, new feature, improvement, proactive bug fix, security, repository analysis, and business/sales analysis.
 - Uses one primary Compound Engineering, Superpowers, GSD Core, or automatically selected workflow spine.
-- Discovers current authenticated model selectors instead of pinning dated model names.
+- Shows every current authenticated and enabled model, ranking the best fit for each stage first instead of pinning dated model names.
 - Enforces that A and C use different underlying models, and B and D use different underlying models.
 - Uses CodeGraph for repository architecture and impact when available, with LSP/AST or repository-native tools for exact code questions.
 - Adds conditional testing, debugger, browser/desktop, security, Advisor, task, and memory routes only when detected.
@@ -62,7 +62,7 @@ The same model-selection and approval logic lives in `core/`. Runtime-specific c
 | Advisor, checkpoint, security scan, Hindsight | Extension/fallback when detected | Native capability when enabled |
 | Parallel agents | Only when a compatible task extension exists | Native `task`/workflow routes when available |
 
-Tested locally against Pi Agent `0.85.1` and OMP `18.1.14`. Optional features are always capability-detected, so their absence produces a recorded fallback rather than a false success claim.
+Tested locally against Pi Agent `0.85.1` and OMP `18.1.15`. Optional features are always capability-detected, so their absence produces a recorded fallback rather than a false success claim.
 
 ## Try the demo
 
@@ -98,6 +98,12 @@ Install PiMarg from the Pi package catalog/npm:
 pi install npm:@sangyaahub/pi-marg
 ```
 
+Install the global OMP launcher:
+
+```bash
+npm install --global @sangyaahub/pi-marg
+```
+
 Or install Pi and OMP directly from this GitHub repository:
 
 ```bash
@@ -106,6 +112,8 @@ omp plugin marketplace add sangyaahub/pi-marg
 omp plugin install --scope user pi-marg@pi-marg-marketplace
 ```
 
+The npm command launches OMP; the OMP plugin installation supplies PiMarg's extensions, skills, commands, and rules. Install both when you want to start the complete workflow with `pi-marg` from any repository.
+
 ## Configure models
 
 Authenticate providers using the active runtime's normal login flow, then run:
@@ -114,16 +122,27 @@ Authenticate providers using the active runtime's normal login flow, then run:
 /auto-models choose
 ```
 
-The router builds choices from the live authenticated registry. It does not promise that a subscription route is free or unlimited. See [MODEL-SETUP.md](MODEL-SETUP.md).
+The router shows every model in the live authenticated and enabled registry. Stage-appropriate choices appear first and all other enabled choices remain selectable. It does not promise that a subscription route is free or unlimited. See [MODEL-SETUP.md](MODEL-SETUP.md).
 
 ## Start a workflow
 
-Type a normal request or invoke:
+From a terminal in the repository you want to work on, run either:
+
+```bash
+pi-marg start
+pi-marg "add CSV export to this repository"
+```
+
+`pi-marg start` opens OMP and asks for the work prompt. Supplying a prompt starts the same guided flow immediately. Inside an existing OMP session, invoke:
 
 ```text
+/pi-marg
+/pi-marg add CSV export to this repository
 /auto add CSV export to this repository
 ```
 
+The native picker asks for work boundary, work type, workflow skill, and every model required by that work type. It shows only models reported as authenticated and enabled by OMP, with recommended stage fits first.
+
 Useful entry points:
 
 - `/auto-models choose` — refresh A/B/C/D choices.

package/adapters/omp/extensions/model-router.ts

@@ -1,21 +1,130 @@
 import {
   MODEL_STATE_TYPE,
   STAGES,
+  buildModelCatalog,
   emptyModelRouteState,
   executeModelRoute,
+  requiredStagesForWorkType,
   restoreModelRouteState,
+  type AutoStage,
+  type ModelCandidate,
   type ModelLike,
   type ModelRouteParams,
+  type ModelRouteState,
 } from "../../../core/model-routing";
+import { normalizeCapabilityNames } from "../../../core/runtime-capabilities";
 
-function toolNames(pi: any): string[] {
-  return (pi.getAllTools?.() ?? [])
-    .map((tool: any) => typeof tool === "string" ? tool : String(tool?.name ?? ""))
-    .filter(Boolean);
-}
+const WORK_BOUNDARIES = ["Job/client", "Personal"] as const;
+
+const WORK_TYPES = [
+  "1. New idea or development from scratch",
+  "2. New feature for an existing repository",
+  "3. Improve an existing feature",
+  "4. Pro-active bug fix",
+  "5. Security review or fixes",
+  "6. Thoughts about an existing repository or features",
+  "7. Business, sales, or other non-technical analysis",
+] as const;
+
+const SKILL_MODES = [
+  "1. Compound Engineering",
+  "2. Superpowers",
+  "3. GSD Core",
+  "4. PiMarg chooses the best available skill",
+] as const;
+
+const STAGE_PURPOSE: Record<AutoStage, string> = {
+  A: "thinking/discovery",
+  B: "implementation/execution",
+  C: "plan second-eye review",
+  D: "implementation second-eye review",
+};
 
 function hasExternalDevin(pi: any): boolean {
-  return toolNames(pi).some((name) => /(?:^|[_-])devin(?:[_-]|$)/i.test(name));
+  return normalizeCapabilityNames(pi.getAllTools?.() ?? [])
+    .some((name) => /(?:^|[_-])devin(?:[_-]|$)/i.test(name));
+}
+
+function commandPrompt(args: string): string {
+  const trimmed = args.trim();
+  if (trimmed.toLowerCase() === "start") return "";
+  return trimmed;
+}
+
+function optionLabel(candidate: ModelCandidate): string {
+  return `${candidate.label} — ${candidate.selector}`;
+}
+
+function optionDescription(stage: AutoStage, candidate: ModelCandidate): string {
+  const preferredTier = stage === "A" || stage === "C" ? "frontier" : "execution";
+  const fit = candidate.tier === preferredTier ? "Recommended fit" : "Available";
+  return `${fit} for ${STAGE_PURPOSE[stage]}${candidate.billingNote ? ` · ${candidate.billingNote}` : ""}`;
+}
+
+async function chooseModel(
+  ctx: any,
+  stage: AutoStage,
+  candidates: ModelCandidate[],
+  selected: Partial<Record<AutoStage, ModelCandidate>>,
+): Promise<ModelCandidate | undefined> {
+  const opposite: Record<AutoStage, AutoStage> = { A: "C", C: "A", B: "D", D: "B" };
+  const other = selected[opposite[stage]];
+  const eligible = candidates.filter((candidate) => !other || candidate.identity !== other.identity);
+  if (eligible.length === 0) {
+    ctx.ui.notify(
+      "Paired stages require two distinct authenticated model identities. Configure another model, then run /pi-marg again.",
+      "error",
+    );
+    return undefined;
+  }
+  const options = eligible.map((candidate) => ({
+    label: optionLabel(candidate),
+    description: optionDescription(stage, candidate),
+  }));
+  const answer = await ctx.ui.select(`Stage ${stage} model`, options, {
+    selectionMarker: "radio",
+    helpText: `${eligible.length} authenticated and enabled choices · ${STAGE_PURPOSE[stage]}`,
+  });
+  return eligible.find((candidate) => optionLabel(candidate) === answer);
+}
+
+function selectedState(
+  workType: number,
+  selected: Partial<Record<AutoStage, ModelCandidate>>,
+): ModelRouteState {
+  const selectedAt = new Date().toISOString();
+  return {
+    version: 1,
+    workType,
+    selections: Object.fromEntries(
+      Object.entries(selected).map(([stage, candidate]) => [stage, { ...candidate, selectedAt }]),
+    ) as ModelRouteState["selections"],
+  };
+}
+
+function intakeMessage(
+  request: string,
+  boundary: string,
+  workType: string,
+  skillMode: string,
+  selected: Partial<Record<AutoStage, ModelCandidate>>,
+): string {
+  const models = STAGES
+    .filter((stage) => selected[stage])
+    .map((stage) => `- Stage ${stage} (${STAGE_PURPOSE[stage]}): ${selected[stage]!.selector}`)
+    .join("\n");
+  return [
+    "Start PiMarg for the following request:",
+    request,
+    "",
+    "Interactive intake is already confirmed; do not ask these questions again:",
+    `- Boundary: ${boundary}`,
+    `- Work type: ${workType}`,
+    `- Workflow skill: ${skillMode}`,
+    models,
+    "",
+    "Load auto-mode-router, record these choices in the session ledger, activate each saved model before its stage, and continue the workflow. Ask interactively only for information that is still missing.",
+  ].join("\n");
 }
 
 export default function modelRouter(pi: any) {
@@ -30,6 +139,60 @@ export default function modelRouter(pi: any) {
   pi.on("session_branch", restore);
   pi.on("session_tree", restore);
 
+  pi.registerCommand("pi-marg", {
+    description: "Start PiMarg with interactive intake, or pass a work prompt.",
+    async handler(args: string, ctx: any) {
+      if (typeof ctx.isIdle === "function" && ctx.isIdle() === false) {
+        ctx.ui.notify("PiMarg intake can start after the current turn finishes.", "warning");
+        return;
+      }
+
+      let request = commandPrompt(args);
+      if (!ctx.hasUI) {
+        if (!request) {
+          ctx.ui.notify("PiMarg interactive intake requires an OMP TUI session.", "error");
+          return;
+        }
+        pi.sendUserMessage(`Start PiMarg for this request:\n${request}`);
+        return;
+      }
+      if (!request) {
+        request = (await ctx.ui.input("PiMarg", "What would you like to work on?"))?.trim() ?? "";
+      }
+      if (!request) return;
+
+      const boundaryLabel = await ctx.ui.select("Work boundary", [...WORK_BOUNDARIES], {
+        selectionMarker: "radio",
+      });
+      if (!WORK_BOUNDARIES.includes(boundaryLabel)) return;
+
+      const workTypeLabel = await ctx.ui.select("Work type", [...WORK_TYPES], { selectionMarker: "radio" });
+      const workType = Number.parseInt(workTypeLabel?.match(/^([1-7])\./)?.[1] ?? "", 10);
+      if (!Number.isInteger(workType)) return;
+
+      const skillMode = await ctx.ui.select("Workflow skill", [...SKILL_MODES], { selectionMarker: "radio" });
+      if (!skillMode) return;
+
+      const liveModels = ctx.models.list() as ModelLike[];
+      if (liveModels.length === 0) {
+        ctx.ui.notify("No authenticated and enabled OMP models were found. Configure a provider, then run /pi-marg again.", "error");
+        return;
+      }
+      const catalog = buildModelCatalog(liveModels, hasExternalDevin(pi));
+      const selected: Partial<Record<AutoStage, ModelCandidate>> = {};
+      for (const stage of requiredStagesForWorkType(workType)) {
+        const choice = await chooseModel(ctx, stage, catalog[stage], selected);
+        if (!choice) return;
+        selected[stage] = choice;
+      }
+
+      const nextState = selectedState(workType, selected);
+      state = nextState;
+      pi.appendEntry(MODEL_STATE_TYPE, nextState);
+      pi.sendUserMessage(intakeMessage(request, boundaryLabel, workTypeLabel!, skillMode, selected));
+    },
+  });
+
   pi.registerTool({
     name: "auto_model_route",
     label: "PiMarg Model Router",

package/bin/pi-marg.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+import { readFileSync, realpathSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+export const VERSION = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8"),
+).version;
+
+const HELP = `PiMarg ${VERSION}
+
+Usage:
+  pi-marg start
+  pi-marg "<work prompt>"
+  pi-marg start "<work prompt>"
+
+Starts Oh My Pi and invokes PiMarg's interactive workflow.`;
+
+export function parsePiMargArgs(args) {
+  if (args.length === 1 && (args[0] === "--help" || args[0] === "-h")) {
+    return { action: "help", prompt: "" };
+  }
+  if (args.length === 1 && (args[0] === "--version" || args[0] === "-v")) {
+    return { action: "version", prompt: "" };
+  }
+  const promptParts = args[0]?.toLowerCase() === "start" ? args.slice(1) : args;
+  return { action: "launch", prompt: promptParts.join(" ").trim() };
+}
+
+export function buildOmpInvocation(parsed) {
+  if (parsed.action !== "launch") return [];
+  return [parsed.prompt ? `/pi-marg ${parsed.prompt}` : "/pi-marg"];
+}
+
+export function runPiMarg(args = process.argv.slice(2)) {
+  const parsed = parsePiMargArgs(args);
+  if (parsed.action === "help") {
+    console.log(HELP);
+    return 0;
+  }
+  if (parsed.action === "version") {
+    console.log(VERSION);
+    return 0;
+  }
+
+  const executable = process.env.PIMARG_OMP_BIN || "omp";
+  const result = spawnSync(executable, buildOmpInvocation(parsed), {
+    cwd: process.cwd(),
+    env: process.env,
+    stdio: "inherit",
+    shell: false,
+  });
+  if (result.error) {
+    if (result.error.code === "ENOENT") {
+      console.error("PiMarg could not find the `omp` command. Install Oh My Pi and make sure `omp` is on PATH.");
+      return 127;
+    }
+    console.error(`PiMarg could not start OMP: ${result.error.message}`);
+    return 1;
+  }
+  return result.status ?? (result.signal ? 1 : 0);
+}
+
+function isMainModule() {
+  if (!process.argv[1]) return false;
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+
+if (isMainModule()) {
+  process.exitCode = runPiMarg();
+}

package/core/model-routing.ts

@@ -1,5 +1,5 @@
 export type AutoStage = "A" | "B" | "C" | "D";
-export type CandidateTier = "frontier" | "execution";
+export type CandidateTier = "frontier" | "execution" | "general";
 export type RuntimeName = "OMP" | "Pi";
 
 export interface ModelLike {
@@ -25,6 +25,7 @@ export interface ModelCandidate {
     | "included-cursor"
     | "devin-swe"
     | "included-devin"
+    | "runtime-available"
     | "devin-external";
   access: "runtime-model" | "external-agent";
   billingNote?: string;
@@ -130,7 +131,7 @@ export function normalizeModelIdentity(value: string): string {
   return normalized;
 }
 
-export function classifyModel(model: ModelLike): ModelCandidate | undefined {
+export function classifyModel(model: ModelLike): ModelCandidate {
   const selector = `${model.provider}/${model.id}`;
   const haystack = `${model.provider} ${model.id} ${model.name ?? ""}`;
 
@@ -156,17 +157,20 @@ export function classifyModel(model: ModelLike): ModelCandidate | undefined {
       billingNote: "The runtime reports zero metered token cost; Devin plan quotas or pool limits may still apply.",
     };
   }
-  return undefined;
+  return candidate(model, selector, "runtime-available", "general");
 }
 
 export function buildModelCatalog(models: ModelLike[], hasExternalDevin: boolean) {
-  const candidates = models
-    .map(classifyModel)
-    .filter((item): item is ModelCandidate => Boolean(item))
-    .sort(compareCandidates);
+  const candidates = [...new Map(models.map((model) => {
+    const item = classifyModel(model);
+    return [item.selector, item] as const;
+  })).values()];
+
+  const frontier = [...candidates].sort((left, right) => compareForStage(left, right, "frontier"));
+  const execution = [...candidates].sort((left, right) => compareForStage(left, right, "execution"));
 
   if (hasExternalDevin) {
-    candidates.push({
+    execution.push({
       selector: "devin/external-session",
       identity: "devin-external-session",
       label: "Devin external session",
@@ -176,11 +180,15 @@ export function buildModelCatalog(models: ModelLike[], hasExternalDevin: boolean
       access: "external-agent",
       billingNote: "Uses Devin quota rather than a runtime model slot; session creation requires post-web approval.",
     });
+    execution.sort((left, right) => compareForStage(left, right, "execution"));
   }
 
-  const frontier = candidates.filter((item) => item.tier === "frontier");
-  const execution = candidates.filter((item) => item.tier === "execution");
-  return { A: frontier, B: execution, C: frontier, D: execution } satisfies Record<AutoStage, ModelCandidate[]>;
+  return {
+    A: frontier,
+    B: execution,
+    C: frontier,
+    D: execution,
+  } satisfies Record<AutoStage, ModelCandidate[]>;
 }
 
 export function validateDistinctSelection(
@@ -328,6 +336,16 @@ function compareCandidates(left: ModelCandidate, right: ModelCandidate): number
   return left.selector.localeCompare(right.selector);
 }
 
+function compareForStage(
+  left: ModelCandidate,
+  right: ModelCandidate,
+  preferredTier: Exclude<CandidateTier, "general">,
+): number {
+  const leftRank = left.tier === preferredTier ? 0 : left.tier === "general" ? 1 : 2;
+  const rightRank = right.tier === preferredTier ? 0 : right.tier === "general" ? 1 : 2;
+  return leftRank - rightRank || compareCandidates(left, right);
+}
+
 function toolResult(text: string, details: unknown, isError = false) {
   return {
     content: [{ type: "text" as const, text }],
@@ -338,11 +356,15 @@ function toolResult(text: string, details: unknown, isError = false) {
 
 function catalogNotes(runtimeName: RuntimeName, catalog: Record<AutoStage, ModelCandidate[]>): string[] {
   const notes = [
-    `The catalog is built from ${runtimeName}'s authenticated model registry at call time; selectors are never guessed or pinned.`,
-    "A and C use frontier candidates. B and D use execution candidates, including eligible Cursor or Devin routes when the runtime exposes them.",
+    `The catalog shows every model in ${runtimeName}'s authenticated, enabled registry at call time; selectors are never guessed or pinned.`,
+    "A and C rank frontier fits first. B and D rank execution fits first. Every live model remains selectable for every stage.",
     "Zero-metered describes the runtime's reported token price; it does not promise unlimited subscription usage.",
   ];
-  if (catalog.A.length === 0) notes.push("No frontier matches are authenticated. Connect a provider, then refresh.");
-  if (catalog.B.length === 0) notes.push("No execution matches are authenticated and no external Devin tool was detected.");
+  if (!catalog.A.some((candidate) => candidate.tier === "frontier")) {
+    notes.push("No preferred frontier matches are authenticated; choose another available model or connect a provider.");
+  }
+  if (!catalog.B.some((candidate) => candidate.tier === "execution")) {
+    notes.push("No preferred execution matches are authenticated and no external Devin tool was detected; choose another available model.");
+  }
   return notes;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sangyaahub/pi-marg",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "A governed, model-routed development path for Pi Agent and Oh My Pi.",
   "type": "module",
   "license": "MIT",
@@ -24,6 +24,9 @@
     "multi-agent",
     "sangyaa"
   ],
+  "bin": {
+    "pi-marg": "bin/pi-marg.js"
+  },
   "files": [
     ".mcp.json",
     ".omp-plugin",
@@ -40,6 +43,7 @@
     "adapters",
     "agents",
     "assets",
+    "bin",
     "commands",
     "core",
     "rules",

package/scripts/install.sh

@@ -71,4 +71,4 @@ if [[ "${runtime}" == "omp" || "${runtime}" == "both" ]]; then
   omp plugin install --scope user pi-marg@pi-marg-marketplace
 fi
 
-echo "PiMarg v1.0.0 installed for ${runtime}. Start a fresh runtime session, then run /auto-runtime status."
+echo "PiMarg v1.0.1 installed for ${runtime}. Start a fresh runtime session, then run /pi-marg."

package/scripts/validate.sh

@@ -17,10 +17,13 @@ bun -e '
   const packageJson = await Bun.file("package.json").json();
   const marketplace = await Bun.file(".omp-plugin/marketplace.json").json();
   if (packageJson.name !== "@sangyaahub/pi-marg") throw new Error("Unexpected package name");
-  if (packageJson.version !== "1.0.0") throw new Error("package.json must be v1.0.0");
+  if (packageJson.version !== "1.0.1") throw new Error("package.json must be v1.0.1");
   if (packageJson.license !== "MIT") throw new Error("package.json must declare MIT");
   if (packageJson.author !== "Sangyaa") throw new Error("Unexpected package author");
   if (!packageJson.keywords?.includes("pi-package")) throw new Error("Pi catalog keyword is missing");
+  if (packageJson.bin?.["pi-marg"] !== "bin/pi-marg.js") throw new Error("PiMarg CLI bin mapping is missing");
+  if (!packageJson.files?.includes("bin")) throw new Error("PiMarg CLI is excluded from npm files");
+  if (!existsSync("bin/pi-marg.js")) throw new Error("PiMarg CLI entry point is missing");
   if (marketplace.name !== "pi-marg-marketplace") throw new Error("Unexpected marketplace name");
   if (marketplace.metadata?.version !== packageJson.version) throw new Error("Marketplace version mismatch");
   if (marketplace.plugins?.[0]?.version !== packageJson.version) throw new Error("Plugin version mismatch");