@idevelopers/agentgate 0.1.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
+  "name": "agentgate-marketplace",
+  "description": "Local marketplace for AgentGate, a validation gate and budget guardrail plugin for autonomous coding agents.",
+  "owner": {
+    "name": "iDevelopers"
+  },
+  "plugins": [
+    {
+      "name": "agentgate",
+      "description": "Validation gates + token-budget kill switch for autonomous coding agents",
+      "author": {
+        "name": "iDevelopers"
+      },
+      "category": "development",
+      "source": "./",
+      "version": "0.1.0",
+      "homepage": "https://www.npmjs.com/package/@idevelopers/agentgate"
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "agentgate",
+  "version": "0.1.0",
+  "description": "Validation gates + token-budget kill switch for autonomous coding agents",
+  "author": {
+    "name": "iDevelopers",
+    "url": "https://github.com/manish-1988"
+  },
+  "repository": "https://www.npmjs.com/package/@idevelopers/agentgate",
+  "license": "MIT"
+}

package/.mcp.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "agentgate": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@idevelopers/agentgate"
+      ]
+    }
+  }
+}

package/README.md

@@ -0,0 +1,136 @@
+# AgentGate
+
+Stop autonomous coding agents from burning tokens and marking broken code as done.
+
+AgentGate is an MCP server plus Claude Code and Codex plugin packaging. It wraps agent work in explicit slices, runs real validation gates, blocks done status while gates fail, and adds Pro guardrails for multi-slice plans, token budgets, advanced gates, and analytics.
+
+## Install
+
+Install the MCP server directly from npm in Claude Code:
+
+```text
+claude mcp add agentgate -- npx -y @idevelopers/agentgate
+```
+
+Or install the Claude Code plugin from the public installer marketplace:
+
+```text
+/plugin marketplace add https://github.com/manish-1988/agentgate-installer
+/plugin install agentgate@agentgate-marketplace
+```
+
+For local source development from this private repository:
+
+```sh
+npm install
+npm run build
+node dist/index.js
+```
+
+Polar handles paid licenses; npm distributes the runtime package. The public installer repository contains only plugin metadata and points Claude/Codex at `npx -y @idevelopers/agentgate`.
+
+## Free, Pro, Team
+
+| Capability | Free | Pro | Team |
+| --- | --- | --- | --- |
+| Single-slice run + basic gates | Yes | Yes | Yes |
+| Multi-slice orchestration | No | Yes | Yes |
+| Token-budget kill switch | No | Yes | Yes |
+| Advanced gates: typecheck, build, custom | No | Yes | Yes |
+| Run analytics export | No | Yes | Yes |
+| Shared policies and seats | No | No | Yes |
+
+Pro is intended for `$19/mo` or `$190/yr`. Team is intended for `$49/mo` with seats.
+Buy Pro or Team through the live Polar checkout:
+
+```text
+https://buy.polar.sh/polar_cl_VxlhG8lCO6IUcLcveJ51YOXYXMHWdUNorKr0U1bhyqm
+```
+
+## Configuration
+
+Create `agentgate.config.json` in your repo. Start from `agentgate.config.example.json`:
+
+```json
+{
+  "version": 1,
+  "gates": [
+    {
+      "id": "test",
+      "type": "test",
+      "command": "npm",
+      "args": ["test", "--", "--run"]
+    }
+  ],
+  "slices": [
+    {
+      "id": "slice-1",
+      "description": "Implement one focused change",
+      "fileScope": ["src/**", "test/**"],
+      "acceptance": ["Tests pass"],
+      "gates": ["test"]
+    }
+  ]
+}
+```
+
+For smoke tests or nonstandard filenames, point AgentGate at a specific config:
+
+```sh
+export AGENTGATE_CONFIG=agentgate.config.example.json
+```
+
+## Tools
+
+- `agentgate_define_slice`: register or update a slice in the active run.
+- `agentgate_run_gate`: run gates for one slice.
+- `agentgate_run_plan`: Pro multi-slice DAG execution with bounded retries.
+- `agentgate_budget_status`: report token usage, remaining budget, estimated cost, and state.
+- `agentgate_activate_license`: store and verify a Polar license key.
+
+## License Activation
+
+AgentGate ships with the public Polar organization id for production license validation:
+
+```sh
+POLAR_ORGANIZATION_ID=534c0711-1ded-497c-aa46-d1a7dfa46d6e
+```
+
+You only need to override it when testing against a different Polar organization. For sandbox checks, set both values:
+
+```sh
+export POLAR_ENVIRONMENT=sandbox
+export POLAR_ORGANIZATION_ID="your_sandbox_org_id"
+```
+
+Then call `agentgate_activate_license` with the Polar license key. AgentGate caches successful validation in `~/.agentgate/license.json` and allows a 72-hour offline grace window for Pro and Team licenses.
+Because AgentGate license keys use Polar activation limits, activation also caches a local activation id. By default the activation label is `agentgate-local`; override it with `AGENTGATE_ACTIVATION_LABEL` if you want a more specific device label in Polar.
+When a user hits a paid feature without a Pro or Team license, AgentGate returns the live Polar checkout URL and tells them to activate the issued key with `agentgate_activate_license`.
+
+## Launch Status
+
+Soft-launch validation was completed on 2026-06-11:
+
+- Polar sandbox checkout issued a real sandbox license key.
+- `agentgate_activate_license` activated that key and cached a Polar activation id.
+- `agentgate_run_plan` passed the example Pro plan with `config` and `typecheck` slices.
+- Free users can run non-Pro gates, while Pro plan execution is blocked without a valid license.
+- Dogfood runs passed against AgentGate, Shipnote, PocketScan, and the mushroom tracker syntax check.
+- The live Polar finance page showed account approval complete, payout account setup complete, and identity verification complete.
+- A production free smoke checkout issued a live Pro license key and AgentGate activated it successfully.
+
+Current distribution model: private source repository, public npm package, public installer marketplace, and Polar license monetization.
+
+## Security
+
+AgentGate runs locally and does not send repo contents to an AgentGate server. It does spawn the commands listed in `agentgate.config.json`, using `child_process.spawn` with `shell:false`. Treat the config like a CI file: review it before running, and only run trusted gate commands.
+
+## Development
+
+```sh
+npm install
+npm run build
+npx vitest run
+```
+
+The package binary is `agentgate`, mapped to `dist/index.js`.

package/agentgate.config.example.json

@@ -0,0 +1,63 @@
+{
+  "version": 1,
+  "gates": [
+    {
+      "id": "test",
+      "type": "test",
+      "command": "npm",
+      "args": [
+        "test",
+        "--",
+        "--run"
+      ]
+    },
+    {
+      "id": "typecheck",
+      "type": "typecheck",
+      "command": "tsc",
+      "args": [
+        "--noEmit"
+      ],
+      "proOnly": true
+    }
+  ],
+  "slices": [
+    {
+      "id": "config",
+      "description": "Validate the AgentGate config loader and schema.",
+      "fileScope": [
+        "src/config/**",
+        "test/config.test.ts"
+      ],
+      "acceptance": [
+        "Valid configs parse.",
+        "Invalid configs report readable field paths."
+      ],
+      "gates": [
+        "test"
+      ]
+    },
+    {
+      "id": "typecheck",
+      "description": "Run strict TypeScript checks.",
+      "fileScope": [
+        "src/**",
+        "test/**"
+      ],
+      "acceptance": [
+        "TypeScript emits without errors."
+      ],
+      "gates": [
+        "typecheck"
+      ],
+      "dependsOn": [
+        "config"
+      ]
+    }
+  ],
+  "budget": {
+    "maxTokens": 200000,
+    "warnAtPct": 0.8,
+    "model": "opus"
+  }
+}

package/codex-plugin/plugin.json

@@ -0,0 +1,23 @@
+{
+  "name": "agentgate",
+  "version": "0.1.0",
+  "description": "Validation gates + token-budget kill switch for autonomous coding agents",
+  "author": "iDevelopers",
+  "license": "MIT",
+  "mcpServers": {
+    "agentgate": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@idevelopers/agentgate"
+      ]
+    }
+  },
+  "skills": [
+    "skills/agentgate-workflow/SKILL.md"
+  ],
+  "commands": [
+    "commands/gate.md",
+    "commands/plan.md"
+  ]
+}

package/commands/gate.md

@@ -0,0 +1,6 @@
+---
+description: Run AgentGate validation gates for a slice
+argument-hint: "[sliceId]"
+---
+
+Run `agentgate_run_gate` for the provided slice id. Inspect every returned gate result. If any gate failed, errored, or timed out, fix the issue within the configured file scope and rerun this command.

package/commands/plan.md

@@ -0,0 +1,6 @@
+---
+description: Run the AgentGate Pro multi-slice plan
+argument-hint: ""
+---
+
+Run `agentgate_run_plan`. This is a Pro command. Stop on the first failed slice, inspect the returned gate results, and rerun after fixing the cause.

package/dist/analytics/export.js

@@ -0,0 +1,39 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { requirePro } from "../license/gate.js";
+import { runsDir } from "../util/paths.js";
+export async function toJSON(runId, tier) {
+    requirePro("analytics_export", tier);
+    const raw = await readFile(path.join(runsDir(), `${runId}.jsonl`), "utf8");
+    return raw
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
+export async function toCSV(runId, tier) {
+    const events = await toJSON(runId, tier);
+    const rows = events.map(flattenRecord);
+    const headers = [...new Set(rows.flatMap((row) => Object.keys(row)))];
+    const lines = [
+        headers.join(","),
+        ...rows.map((row) => headers.map((header) => csvEscape(row[header] ?? "")).join(",")),
+    ];
+    return lines.join("\n");
+}
+function flattenRecord(value) {
+    const record = typeof value === "object" && value !== null
+        ? value
+        : { value };
+    return Object.fromEntries(Object.entries(record).map(([key, nestedValue]) => [
+        key,
+        typeof nestedValue === "string"
+            ? nestedValue
+            : JSON.stringify(nestedValue),
+    ]));
+}
+function csvEscape(value) {
+    if (!/[",\n]/.test(value)) {
+        return value;
+    }
+    return `"${value.replaceAll("\"", "\"\"")}"`;
+}

package/dist/analytics/logger.js

@@ -0,0 +1,12 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { runsDir } from "../util/paths.js";
+export async function appendEvent(runId, event) {
+    const dir = runsDir();
+    await mkdir(dir, { recursive: true });
+    const eventWithTime = {
+        at: new Date().toISOString(),
+        ...event,
+    };
+    await appendFile(path.join(dir, `${runId}.jsonl`), `${JSON.stringify(eventWithTime)}\n`, "utf8");
+}

package/dist/budget/killswitch.js

@@ -0,0 +1,11 @@
+export class BudgetExceeded extends Error {
+    constructor(message = "AgentGate token budget exceeded.") {
+        super(message);
+        this.name = "BudgetExceeded";
+    }
+}
+export function enforceBudget(ledger, budget) {
+    if (ledger.used() >= budget.maxTokens) {
+        throw new BudgetExceeded(`Token budget exceeded: used ${ledger.used()} of ${budget.maxTokens}.`);
+    }
+}

package/dist/budget/ledger.js

@@ -0,0 +1,24 @@
+export class TokenLedger {
+    tokensUsed = 0;
+    add(tokens) {
+        if (!Number.isFinite(tokens) || tokens < 0) {
+            throw new Error("Token count must be a non-negative finite number.");
+        }
+        this.tokensUsed += Math.floor(tokens);
+    }
+    used() {
+        return this.tokensUsed;
+    }
+    remaining(maxTokens) {
+        return Math.max(0, maxTokens - this.tokensUsed);
+    }
+    check(budget) {
+        if (this.tokensUsed >= budget.maxTokens) {
+            return "stopped";
+        }
+        if (this.tokensUsed >= budget.warnAtPct * budget.maxTokens) {
+            return "warn";
+        }
+        return "ok";
+    }
+}

package/dist/config/loader.js

@@ -0,0 +1,38 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { ZodError } from "zod";
+import { configSchema } from "./schema.js";
+export async function loadConfig(cwd = process.cwd()) {
+    const configPath = process.env.AGENTGATE_CONFIG
+        ? path.resolve(cwd, process.env.AGENTGATE_CONFIG)
+        : path.join(cwd, "agentgate.config.json");
+    const raw = await readFile(configPath, "utf8");
+    try {
+        return configSchema.parse(JSON.parse(raw));
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON in ${configPath}: ${error.message}`);
+        }
+        if (error instanceof ZodError) {
+            const details = error.issues
+                .map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`)
+                .join("; ");
+            throw new Error(`Invalid AgentGate config at ${configPath}: ${details}`);
+        }
+        throw error;
+    }
+}
+export async function loadPolicy(policyPath) {
+    const resolvedPath = path.resolve(policyPath);
+    const raw = await readFile(resolvedPath, "utf8");
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON in policy file ${resolvedPath}: ${error.message}`);
+        }
+        throw error;
+    }
+}

package/dist/config/schema.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export const gateTypeSchema = z.enum([
+    "test",
+    "lint",
+    "typecheck",
+    "build",
+    "custom",
+]);
+export const gateSchema = z.object({
+    id: z.string().min(1),
+    type: gateTypeSchema,
+    command: z.string().min(1),
+    args: z.array(z.string()),
+    cwd: z.string().optional(),
+    timeoutMs: z.number().int().positive().default(120000),
+    proOnly: z.boolean().optional(),
+});
+export const sliceSchema = z.object({
+    id: z.string().min(1),
+    description: z.string().min(1),
+    fileScope: z.array(z.string()),
+    acceptance: z.array(z.string()),
+    gates: z.array(z.string()),
+    dependsOn: z.array(z.string()).optional(),
+    maxRetries: z.number().int().nonnegative().default(2),
+});
+export const budgetSchema = z.object({
+    maxTokens: z.number().int().positive(),
+    warnAtPct: z.number().min(0).max(1),
+    model: z.string().min(1),
+});
+export const configSchema = z.object({
+    version: z.literal(1),
+    gates: z.array(gateSchema),
+    slices: z.array(sliceSchema),
+    budget: budgetSchema.optional(),
+    policyFile: z.string().optional(),
+});

package/dist/gates/runner.js

@@ -0,0 +1,77 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+const OUTPUT_TAIL_BYTES = 4096;
+const GATE_ENV_DENYLIST = ["AGENTGATE_CONFIG", "AGENTGATE_ACTIVATION_LABEL"];
+function appendTail(current, chunk) {
+    const next = current + chunk.toString("utf8");
+    if (Buffer.byteLength(next, "utf8") <= OUTPUT_TAIL_BYTES) {
+        return next;
+    }
+    return Buffer.from(next, "utf8")
+        .subarray(-OUTPUT_TAIL_BYTES)
+        .toString("utf8");
+}
+export class GateRunner {
+    async run(gate) {
+        const startedAt = Date.now();
+        const timeoutMs = gate.timeoutMs ?? 120000;
+        let stdoutTail = "";
+        let stderrTail = "";
+        let settled = false;
+        let timedOut = false;
+        return new Promise((resolve) => {
+            const finish = (status, exitCode) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timer);
+                resolve({
+                    gateId: gate.id,
+                    status,
+                    exitCode,
+                    durationMs: Date.now() - startedAt,
+                    stdoutTail,
+                    stderrTail,
+                });
+            };
+            const child = spawn(gate.command, gate.args, {
+                cwd: gate.cwd,
+                env: gateEnvironment(gate.cwd),
+                shell: false,
+            });
+            const timer = setTimeout(() => {
+                timedOut = true;
+                child.kill();
+            }, timeoutMs);
+            child.stdout?.on("data", (chunk) => {
+                stdoutTail = appendTail(stdoutTail, chunk);
+            });
+            child.stderr?.on("data", (chunk) => {
+                stderrTail = appendTail(stderrTail, chunk);
+            });
+            child.on("error", (error) => {
+                stderrTail = appendTail(stderrTail, Buffer.from(error.message));
+                finish("error", null);
+            });
+            child.on("close", (code) => {
+                if (timedOut) {
+                    finish("timeout", code);
+                    return;
+                }
+                finish(code === 0 ? "pass" : "fail", code);
+            });
+        });
+    }
+}
+function gateEnvironment(cwd) {
+    const env = { ...process.env };
+    const pathKey = process.platform === "win32" ? "Path" : "PATH";
+    const currentPath = env[pathKey] ?? "";
+    const localBin = path.join(cwd ?? process.cwd(), "node_modules", ".bin");
+    env[pathKey] = currentPath ? `${localBin}${path.delimiter}${currentPath}` : localBin;
+    for (const key of GATE_ENV_DENYLIST) {
+        delete env[key];
+    }
+    return env;
+}

package/dist/gates/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerTools } from "./server.js";
+async function main() {
+    const server = new McpServer({
+        name: "agentgate",
+        version: "0.1.0",
+    });
+    registerTools(server);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/license/constants.js

@@ -0,0 +1 @@
+export const AGENTGATE_CHECKOUT_URL = "https://buy.polar.sh/polar_cl_VxlhG8lCO6IUcLcveJ51YOXYXMHWdUNorKr0U1bhyqm";

package/dist/license/gate.js

@@ -0,0 +1,6 @@
+import { AGENTGATE_CHECKOUT_URL } from "./constants.js";
+export function requirePro(feature, tier) {
+    if (tier === "free") {
+        throw new Error(`Pro license required: ${feature}. Buy a license at ${AGENTGATE_CHECKOUT_URL}, then activate it with agentgate_activate_license.`);
+    }
+}

package/dist/license/validator.js

@@ -0,0 +1,187 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { Polar } from "@polar-sh/sdk";
+import { licenseCachePath } from "../util/paths.js";
+const OFFLINE_GRACE_MS = 72 * 60 * 60 * 1000;
+export const AGENTGATE_POLAR_ORGANIZATION_ID = "534c0711-1ded-497c-aa46-d1a7dfa46d6e";
+export class PolarLicenseValidator {
+    options;
+    cachePath;
+    constructor(options = {}) {
+        this.options = options;
+        this.cachePath = options.cachePath ?? licenseCachePath();
+    }
+    async verify() {
+        const cache = await readLicenseCache(this.cachePath);
+        if (!cache.key) {
+            return { tier: "free" };
+        }
+        const organizationId = this.options.organizationId ??
+            process.env.POLAR_ORGANIZATION_ID ??
+            defaultOrganizationId();
+        if (!organizationId) {
+            return cachedWithinGrace(cache) ?? { tier: "free" };
+        }
+        try {
+            const polar = new Polar({
+                server: process.env.POLAR_ENVIRONMENT === "sandbox" ? "sandbox" : "production",
+            });
+            const activationId = cache.activationId ??
+                (await activateLicenseKey(polar, cache.key, organizationId, this.cachePath, cache));
+            const validated = await polar.customerPortal.licenseKeys.validate({
+                key: cache.key,
+                organizationId,
+                activationId,
+            }, {
+                timeoutMs: 10000,
+            });
+            if (!isGrantedLicense(validated)) {
+                return { tier: "free" };
+            }
+            const verification = verificationFromPolarResponse(validated);
+            await writeLicenseCache(this.cachePath, {
+                ...cache,
+                activationId,
+                ...verification,
+                validatedAt: new Date().toISOString(),
+            });
+            return verification;
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                return cachedWithinGrace(cache) ?? { tier: "free" };
+            }
+            return { tier: "free" };
+        }
+    }
+}
+function defaultOrganizationId() {
+    if (process.env.POLAR_ENVIRONMENT === "sandbox") {
+        return undefined;
+    }
+    return AGENTGATE_POLAR_ORGANIZATION_ID;
+}
+export async function storeLicenseKey(key, cachePath = licenseCachePath()) {
+    const existing = await readLicenseCache(cachePath);
+    if (existing.key === key) {
+        await writeLicenseCache(cachePath, {
+            ...existing,
+            key,
+        });
+        return;
+    }
+    await writeLicenseCache(cachePath, { key });
+}
+async function activateLicenseKey(polar, key, organizationId, cachePath, cache) {
+    const activation = await polar.customerPortal.licenseKeys.activate({
+        key,
+        organizationId,
+        label: process.env.AGENTGATE_ACTIVATION_LABEL ?? "agentgate-local",
+        meta: {
+            app: "agentgate",
+        },
+    }, {
+        timeoutMs: 10000,
+    });
+    await writeLicenseCache(cachePath, {
+        ...cache,
+        activationId: activation.id,
+    });
+    return activation.id;
+}
+async function readLicenseCache(cachePath) {
+    try {
+        const raw = await readFile(cachePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return {};
+        }
+        throw error;
+    }
+}
+async function writeLicenseCache(cachePath, cache) {
+    await mkdir(path.dirname(cachePath), { recursive: true });
+    await writeFile(cachePath, JSON.stringify(cache, null, 2), "utf8");
+}
+function cachedWithinGrace(cache) {
+    if (!cache.tier || cache.tier === "free" || !cache.validatedAt) {
+        return undefined;
+    }
+    const validatedAt = new Date(cache.validatedAt).getTime();
+    if (Number.isNaN(validatedAt) || Date.now() - validatedAt > OFFLINE_GRACE_MS) {
+        return undefined;
+    }
+    return {
+        tier: cache.tier,
+        validUntil: cache.validUntil,
+        seats: cache.seats,
+    };
+}
+function isGrantedLicense(response) {
+    const record = asRecord(response);
+    if (record["valid"] === false) {
+        return false;
+    }
+    const status = record["status"];
+    if (typeof status === "string" && status !== "granted") {
+        return false;
+    }
+    return true;
+}
+function verificationFromPolarResponse(response) {
+    const record = asRecord(response);
+    const tier = inferTier(record);
+    const expiresAt = record["expiresAt"];
+    const limitActivations = numberValue(record["limitActivations"]);
+    return {
+        tier,
+        validUntil: expiresAt instanceof Date
+            ? expiresAt.toISOString()
+            : typeof expiresAt === "string"
+                ? expiresAt
+                : undefined,
+        seats: tier === "team" ? limitActivations ?? undefined : undefined,
+    };
+}
+function inferTier(record) {
+    const explicitTier = nestedString(record, ["metadata", "tier"]) ??
+        nestedString(record, ["benefit", "metadata", "tier"]) ??
+        nestedString(record, ["product", "metadata", "tier"]);
+    if (explicitTier === "team") {
+        return "team";
+    }
+    if (explicitTier === "pro") {
+        return "pro";
+    }
+    const limitActivations = numberValue(record["limitActivations"]);
+    if (limitActivations && limitActivations > 1) {
+        return "team";
+    }
+    return "pro";
+}
+function nestedString(record, pathParts) {
+    let current = record;
+    for (const part of pathParts) {
+        current = asRecord(current)[part];
+    }
+    return typeof current === "string" ? current.toLowerCase() : undefined;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null
+        ? value
+        : {};
+}
+function isNetworkError(error) {
+    const record = asRecord(error);
+    const name = String(record["name"] ?? "");
+    const message = String(record["message"] ?? "");
+    return /(connection|network|timeout|abort|econn|enotfound|etimedout)/i.test(`${name} ${message}`);
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}

package/dist/orchestrator/orchestrator.js

@@ -0,0 +1,145 @@
+import { enforceBudget } from "../budget/killswitch.js";
+import { TokenLedger } from "../budget/ledger.js";
+import { requirePro } from "../license/gate.js";
+import { appendEvent } from "../analytics/logger.js";
+import { estimateCostUsd } from "../util/cost.js";
+export class Orchestrator {
+    config;
+    gateRunner;
+    ledger;
+    licenseTier;
+    runId;
+    constructor(config, gateRunner, ledger = new TokenLedger(), licenseTier = "free", runId) {
+        this.config = config;
+        this.gateRunner = gateRunner;
+        this.ledger = ledger;
+        this.licenseTier = licenseTier;
+        this.runId = runId;
+    }
+    async runSlice(sliceId) {
+        const slice = this.config.slices.find((candidate) => candidate.id === sliceId);
+        if (!slice) {
+            throw new Error(`Unknown slice: ${sliceId}`);
+        }
+        await this.log({
+            type: "slice_start",
+            sliceId: slice.id,
+        });
+        const gateResults = [];
+        for (const gateId of slice.gates) {
+            if (this.config.budget) {
+                enforceBudget(this.ledger, this.config.budget);
+            }
+            const gate = this.findGate(gateId);
+            if (this.gateRequiresPro(gate)) {
+                requirePro("advanced_gates", this.licenseTier);
+            }
+            const gateResult = await this.gateRunner.run(gate);
+            gateResults.push(gateResult);
+            await this.log({
+                type: "gate_result",
+                sliceId: slice.id,
+                gateResult,
+            });
+        }
+        const tokensUsed = this.ledger.used();
+        const result = {
+            sliceId: slice.id,
+            passed: gateResults.every((result) => result.status === "pass"),
+            attempts: 1,
+            gateResults,
+            tokensUsed,
+            costUsd: this.config.budget
+                ? estimateCostUsd(tokensUsed, this.config.budget.model)
+                : 0,
+        };
+        await this.log({
+            type: "slice_end",
+            sliceId: slice.id,
+            passed: result.passed,
+            tokensUsed: result.tokensUsed,
+            costUsd: result.costUsd,
+        });
+        return result;
+    }
+    async runPlan() {
+        requirePro("run_plan", this.licenseTier);
+        const orderedSlices = this.topologicalSlices();
+        const results = [];
+        for (const slice of orderedSlices) {
+            const maxRetries = slice.maxRetries ?? 2;
+            const allGateResults = [];
+            let attempts = 0;
+            let latestResult;
+            while (attempts <= maxRetries) {
+                attempts += 1;
+                latestResult = await this.runSlice(slice.id);
+                allGateResults.push(...latestResult.gateResults);
+                if (latestResult.passed) {
+                    break;
+                }
+            }
+            if (!latestResult) {
+                throw new Error(`No attempts ran for slice: ${slice.id}`);
+            }
+            const result = {
+                ...latestResult,
+                attempts,
+                gateResults: allGateResults,
+            };
+            results.push(result);
+            if (!result.passed) {
+                break;
+            }
+        }
+        return results;
+    }
+    findGate(gateId) {
+        const gate = this.config.gates.find((candidate) => candidate.id === gateId);
+        if (!gate) {
+            throw new Error(`Unknown gate: ${gateId}`);
+        }
+        return gate;
+    }
+    gateRequiresPro(gate) {
+        return (gate.proOnly === true ||
+            gate.type === "typecheck" ||
+            gate.type === "build" ||
+            gate.type === "custom");
+    }
+    topologicalSlices() {
+        const sliceById = new Map(this.config.slices.map((slice) => [slice.id, slice]));
+        const permanent = new Set();
+        const temporary = new Set();
+        const ordered = [];
+        const visit = (sliceId) => {
+            if (permanent.has(sliceId)) {
+                return;
+            }
+            if (temporary.has(sliceId)) {
+                throw new Error(`Cycle detected in slice dependencies at ${sliceId}`);
+            }
+            const slice = sliceById.get(sliceId);
+            if (!slice) {
+                throw new Error(`Unknown slice dependency: ${sliceId}`);
+            }
+            temporary.add(sliceId);
+            for (const dependency of slice.dependsOn ?? []) {
+                visit(dependency);
+            }
+            temporary.delete(sliceId);
+            permanent.add(sliceId);
+            ordered.push(slice);
+        };
+        for (const slice of this.config.slices) {
+            visit(slice.id);
+        }
+        return ordered;
+    }
+    async log(event) {
+        if (!this.runId) {
+            return;
+        }
+        await appendEvent(this.runId, event);
+    }
+}

package/dist/orchestrator/slice.js

@@ -0,0 +1 @@
+export {};

package/dist/server.js

@@ -0,0 +1,12 @@
+import { registerActivateLicenseTool } from "./tools/activate_license.js";
+import { registerBudgetStatusTool } from "./tools/budget_status.js";
+import { registerDefineSliceTool } from "./tools/define_slice.js";
+import { registerRunGateTool } from "./tools/run_gate.js";
+import { registerRunPlanTool } from "./tools/run_plan.js";
+export function registerTools(server) {
+    registerDefineSliceTool(server);
+    registerRunGateTool(server);
+    registerBudgetStatusTool(server);
+    registerActivateLicenseTool(server);
+    registerRunPlanTool(server);
+}

package/dist/tools/activate_license.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { PolarLicenseValidator, storeLicenseKey, } from "../license/validator.js";
+import { AGENTGATE_CHECKOUT_URL } from "../license/constants.js";
+import { jsonToolResult } from "./response.js";
+const activateLicenseInputSchema = {
+    key: z.string().min(1),
+};
+export function registerActivateLicenseTool(server) {
+    server.registerTool("agentgate_activate_license", {
+        title: "Activate AgentGate License",
+        description: "Store and verify a Polar license key.",
+        inputSchema: activateLicenseInputSchema,
+    }, async ({ key }) => {
+        await storeLicenseKey(key);
+        const verification = await new PolarLicenseValidator().verify();
+        return jsonToolResult({
+            tier: verification.tier,
+            validUntil: verification.validUntil,
+            checkoutUrl: verification.tier === "free" ? AGENTGATE_CHECKOUT_URL : undefined,
+        });
+    });
+}

package/dist/tools/budget_status.js

@@ -0,0 +1,31 @@
+import { loadConfig } from "../config/loader.js";
+import { estimateCostUsd } from "../util/cost.js";
+import { jsonToolResult } from "./response.js";
+import { activeTokenLedger } from "./runtime.js";
+export function registerBudgetStatusTool(server) {
+    server.registerTool("agentgate_budget_status", {
+        title: "AgentGate Budget Status",
+        description: "Report token usage, estimated cost, and budget state.",
+    }, async () => {
+        const config = await loadConfig(process.cwd());
+        const tokensUsed = activeTokenLedger.used();
+        if (!config.budget) {
+            return jsonToolResult({
+                tokensUsed,
+                maxTokens: null,
+                remaining: null,
+                costUsd: 0,
+                model: null,
+                state: "ok",
+            });
+        }
+        return jsonToolResult({
+            tokensUsed,
+            maxTokens: config.budget.maxTokens,
+            remaining: activeTokenLedger.remaining(config.budget.maxTokens),
+            costUsd: estimateCostUsd(tokensUsed, config.budget.model),
+            model: config.budget.model,
+            state: activeTokenLedger.check(config.budget),
+        });
+    });
+}

package/dist/tools/config.js

@@ -0,0 +1,19 @@
+import { loadConfig } from "../config/loader.js";
+import { listActiveSlices } from "./define_slice.js";
+export async function loadRuntimeConfig(cwd = process.cwd()) {
+    return withActiveSlices(await loadConfig(cwd));
+}
+export function withActiveSlices(config) {
+    const activeSlices = listActiveSlices();
+    if (activeSlices.length === 0) {
+        return config;
+    }
+    const slices = new Map(config.slices.map((slice) => [slice.id, slice]));
+    for (const slice of activeSlices) {
+        slices.set(slice.id, slice);
+    }
+    return {
+        ...config,
+        slices: [...slices.values()],
+    };
+}

package/dist/tools/define_slice.js

@@ -0,0 +1,24 @@
+import { sliceSchema } from "../config/schema.js";
+import { jsonToolResult } from "./response.js";
+const activeSlices = new Map();
+export function upsertActiveSlice(slice) {
+    activeSlices.set(slice.id, slice);
+    return slice;
+}
+export function listActiveSlices() {
+    return [...activeSlices.values()];
+}
+export function registerDefineSliceTool(server) {
+    server.registerTool("agentgate_define_slice", {
+        title: "Define AgentGate Slice",
+        description: "Register or update a slice in the active AgentGate run.",
+        inputSchema: sliceSchema.shape,
+    }, async (input) => {
+        const slice = sliceSchema.parse(input);
+        upsertActiveSlice(slice);
+        return jsonToolResult({
+            ok: true,
+            slice,
+        });
+    });
+}

package/dist/tools/response.js

@@ -0,0 +1,10 @@
+export function jsonToolResult(value) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(value, null, 2),
+            },
+        ],
+    };
+}

package/dist/tools/run_gate.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { GateRunner } from "../gates/runner.js";
+import { PolarLicenseValidator } from "../license/validator.js";
+import { Orchestrator } from "../orchestrator/orchestrator.js";
+import { loadRuntimeConfig } from "./config.js";
+import { jsonToolResult } from "./response.js";
+import { activeRunId, activeTokenLedger } from "./runtime.js";
+const runGateInputSchema = {
+    sliceId: z.string().min(1),
+};
+export function registerRunGateTool(server) {
+    server.registerTool("agentgate_run_gate", {
+        title: "Run AgentGate Gates",
+        description: "Run the configured validation gates for a slice.",
+        inputSchema: runGateInputSchema,
+    }, async ({ sliceId }) => {
+        const config = await loadRuntimeConfig(process.cwd());
+        const license = await new PolarLicenseValidator().verify();
+        const orchestrator = new Orchestrator(config, new GateRunner(), activeTokenLedger, license.tier, activeRunId);
+        const result = await orchestrator.runSlice(sliceId);
+        return jsonToolResult({
+            passed: result.passed,
+            gateResults: result.gateResults,
+        });
+    });
+}

package/dist/tools/run_plan.js

@@ -0,0 +1,17 @@
+import { GateRunner } from "../gates/runner.js";
+import { PolarLicenseValidator } from "../license/validator.js";
+import { Orchestrator } from "../orchestrator/orchestrator.js";
+import { loadRuntimeConfig } from "./config.js";
+import { jsonToolResult } from "./response.js";
+import { activeRunId, activeTokenLedger } from "./runtime.js";
+export function registerRunPlanTool(server) {
+    server.registerTool("agentgate_run_plan", {
+        title: "Run AgentGate Plan",
+        description: "Run the full Pro multi-slice plan with retries.",
+    }, async () => {
+        const config = await loadRuntimeConfig(process.cwd());
+        const license = await new PolarLicenseValidator().verify();
+        const orchestrator = new Orchestrator(config, new GateRunner(), activeTokenLedger, license.tier, activeRunId);
+        return jsonToolResult(await orchestrator.runPlan());
+    });
+}

package/dist/tools/runtime.js

@@ -0,0 +1,3 @@
+import { TokenLedger } from "../budget/ledger.js";
+export const activeTokenLedger = new TokenLedger();
+export const activeRunId = `run-${Date.now()}`;

package/dist/util/cost.js

@@ -0,0 +1,15 @@
+const MODEL_RATES_PER_1K_TOKENS_USD = {
+    opus: 0.015,
+    sonnet: 0.003,
+    haiku: 0.0008,
+    "gpt-5": 0.01,
+    "gpt-4.1": 0.005,
+    default: 0.005,
+};
+export function estimateCostUsd(tokens, model) {
+    const normalizedModel = model.toLowerCase();
+    const exactRate = MODEL_RATES_PER_1K_TOKENS_USD[normalizedModel];
+    const fuzzyRate = Object.entries(MODEL_RATES_PER_1K_TOKENS_USD).find(([key]) => normalizedModel.includes(key))?.[1];
+    const rate = exactRate ?? fuzzyRate ?? MODEL_RATES_PER_1K_TOKENS_USD.default;
+    return Number(((tokens / 1000) * rate).toFixed(4));
+}

package/dist/util/paths.js

@@ -0,0 +1,11 @@
+import os from "node:os";
+import path from "node:path";
+export function agentgateHome() {
+    return path.join(os.homedir(), ".agentgate");
+}
+export function runsDir() {
+    return path.join(agentgateHome(), "runs");
+}
+export function licenseCachePath() {
+    return path.join(agentgateHome(), "license.json");
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@idevelopers/agentgate",
+  "version": "0.1.0",
+  "description": "Validation gates and token-budget guardrails for autonomous coding agents.",
+  "type": "module",
+  "bin": {
+    "agentgate": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "test": "vitest run"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "agentgate.config.example.json",
+    ".mcp.json",
+    ".claude-plugin",
+    "codex-plugin",
+    "skills",
+    "commands"
+  ],
+  "keywords": [
+    "mcp",
+    "codex",
+    "claude-code",
+    "agents",
+    "validation"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.13.0",
+    "@polar-sh/sdk": "^0.48.1",
+    "zod": "^3.25.67"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.1",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/skills/agentgate-workflow/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: agentgate-workflow
+description: Use when implementing code under AgentGate validation gates, slice scopes, token budgets, or Pro multi-slice plans.
+version: 0.1.0
+---
+
+# AgentGate Workflow
+
+Use this skill when implementing work under AgentGate guardrails.
+
+1. Load `agentgate.config.json` and identify the slice to run.
+2. If the slice is created during the session, call `agentgate_define_slice` with its `id`, `description`, `fileScope`, `acceptance`, and `gates`.
+3. Implement only inside the slice's `fileScope`.
+4. Call `agentgate_run_gate` with the slice id after implementation.
+5. Treat any failed, errored, or timed-out gate as blocking. Read the returned tails, fix the issue, and rerun the gate.
+6. Do not mark a slice complete until all returned gates pass.
+7. Between slices, call `agentgate_budget_status` and stop if the state is `stopped`.
+8. For Pro multi-slice work, call `agentgate_run_plan` to execute slices in dependency order with bounded retries.