phonton-cli 0.2.0

package/LICENSE-APACHE

@@ -0,0 +1,117 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the
+copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other
+entities that control, are controlled by, or are under common control with
+that entity. For the purposes of this definition, "control" means (i) the
+power, direct or indirect, to cause the direction or management of such
+entity, whether by contract or otherwise, or (ii) ownership of fifty percent
+(50%) or more of the outstanding shares, or (iii) beneficial ownership of such
+entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation source, and
+configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object
+code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form,
+made available under the License, as indicated by a copyright notice that is
+included in or attached to the work.
+
+"Derivative Works" shall mean any work, whether in Source or Object form,
+that is based on or derived from the Work and for which the editorial
+revisions, annotations, elaborations, or other modifications represent, as a
+whole, an original work of authorship. For the purposes of this License,
+Derivative Works shall not include works that remain separable from, or merely
+link (or bind by name) to the interfaces of, the Work and Derivative Works
+thereof.
+
+"Contribution" shall mean any work of authorship, including the original
+version of the Work and any modifications or additions to that Work or
+Derivative Works thereof, that is intentionally submitted to Licensor for
+inclusion in the Work by the copyright owner or by an individual or Legal
+Entity authorized to submit on behalf of the copyright owner. For the purposes
+of this definition, "submitted" means any form of electronic, verbal, or
+written communication sent to the Licensor or its representatives, including
+but not limited to communication on electronic mailing lists, source code
+control systems, and issue tracking systems that are managed by, or on behalf
+of, the Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise designated
+in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+reproduce, prepare Derivative Works of, publicly display, publicly perform,
+sublicense, and distribute the Work and such Derivative Works in Source or
+Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable patent license to make,
+have made, use, offer to sell, sell, import, and otherwise transfer the Work.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+Derivative Works thereof in any medium, with or without modifications, and in
+Source or Object form, provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a copy
+of this License; and
+
+(b) You must cause any modified files to carry prominent notices stating that
+You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You
+distribute, all copyright, patent, trademark, and attribution notices from the
+Source form of the Work, excluding those notices that do not pertain to any
+part of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its distribution,
+then any Derivative Works that You distribute must include a readable copy of
+the attribution notices contained within such NOTICE file.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+Contribution intentionally submitted for inclusion in the Work by You to the
+Licensor shall be under the terms and conditions of this License, without any
+additional terms or conditions.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as
+required for reasonable and customary use in describing the origin of the Work.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+writing, Licensor provides the Work on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+tort, contract, or otherwise, unless required by applicable law, shall any
+Contributor be liable to You for damages, including any direct, indirect,
+special, incidental, or consequential damages arising as a result of this
+License or out of the use or inability to use the Work.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or
+Derivative Works thereof, You may choose to offer support, warranty,
+indemnity, or other liability obligations. However, in accepting such
+obligations, You may act only on Your own behalf and on Your sole
+responsibility, not on behalf of any other Contributor.

package/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Phonton contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,349 @@
+<p align="center">
+  <img src="assets/readme/phonton-cli-logo.png" width="112" alt="Phonton CLI logo">
+</p>
+
+<h1 align="center">Phonton CLI · v0.2.0</h1>
+
+<p align="center">
+  <strong>Verified code changes with repo memory.</strong><br>
+  A local-first agentic development environment for developers who want autonomous code changes without giving up review control.
+</p>
+
+<p align="center">
+  <a href="https://github.com/phonton-dev/phonton-cli/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/phonton-dev/phonton-cli/actions/workflows/ci.yml/badge.svg"></a>
+  <a href="https://github.com/phonton-dev/phonton-cli/stargazers"><img alt="GitHub stars" src="https://img.shields.io/github/stars/phonton-dev/phonton-cli?style=flat&label=stars"></a>
+  <img alt="release" src="https://img.shields.io/badge/release-v0.2.0-6c63ff">
+  <img alt="license" src="https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue">
+  <img alt="status" src="https://img.shields.io/badge/status-public_alpha-f97316">
+</p>
+
+---
+
+Phonton plans the work, routes it through local repo context, verifies changes before handoff, and keeps the result reviewable. The goal is not to be the loudest coding agent. The goal is to make AI-assisted development feel less reckless.
+
+> Current status: pre-1.0 public-alpha quality. The core loop is real, the CLI runs, and the Rust workspace is tested. Public launch claims should stay tied to reproducible benchmarks.
+
+<p align="center">
+  <img src="assets/readme/phonton-cli-hero.png" alt="Phonton CLI hero with terminal UI preview">
+</p>
+
+## Why Phonton
+
+Most coding agents start with chat. Phonton starts with the engineering loop:
+
+```mermaid
+flowchart LR
+    A["Goal"] --> B["Plan preview"]
+    B --> C["Repo-aware worker"]
+    C --> D["Verification gate"]
+    D --> E["Reviewable diff"]
+    E --> F["Memory and history"]
+    F --> B
+```
+
+That gives Phonton a different shape from an IDE assistant or a terminal chatbot:
+
+- **Review first:** plans and diffs are first-class surfaces, not buried in a conversation.
+- **Verification first:** generated work is expected to pass checks before it is treated as ready.
+- **Local first:** config, trust, store, memory, and repo context live on your machine.
+- **BYOK:** use your own provider account instead of routing every task through a Phonton-hosted model bill.
+- **Measured claims:** token and cost efficiency should be benchmarked per task, not guessed.
+
+## What Works Today
+
+- Interactive Ratatui TUI with goal, task, ask, settings, git, and flight-log surfaces.
+- `phonton doctor` setup diagnostics for config, provider key, store, trust, git, cargo, and Nexus config.
+- `phonton plan` preview for task DAGs before edits happen.
+- `phonton review` surfaces for verified diff review payloads, approvals, rejections, and rollback.
+- `phonton memory` commands for inspecting, editing, deleting, pinning, and unpinning local decision memory.
+- BYOK provider adapters for Anthropic, OpenAI, OpenRouter, Gemini, AgentRouter, DeepSeek, xAI/Grok, Groq, Together, Ollama, and custom OpenAI-compatible endpoints. `phonton doctor --provider` verifies your configured provider by checking model discovery and a tiny completion call through the same adapter used for runs.
+- Local store, memory, planner, worker, diff, sandbox, verification, and orchestration crates.
+- Semantic indexing behind the CLI stack for repo-aware workflows.
+
+## What Is Still Early
+
+Phonton is not yet as polished as Codex, Claude Code, Cursor, or Windsurf. It has fewer integrations, less onboarding polish, narrower public documentation, and no mature hosted/team workflow yet.
+
+The current release target is a public alpha for real Rust repo tasks. Phonton can ask configured models to write app-sized changes, but quality is only claimed after plan review, sandboxed edits, verification, and human review. Use it if you are comfortable running a Rust binary, reading diagnostics, and filing sharp bug reports.
+
+## Install
+
+The easiest install path is npm. This downloads a prebuilt GitHub Release binary when the package installs.
+
+```bash
+npm install -g phonton-cli
+phonton
+```
+
+Run without installing:
+
+```bash
+npx phonton-cli
+```
+
+Cargo still works if you prefer building from source. Rust is required for the Cargo path.
+
+macOS/Linux:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/phonton-dev/phonton-cli/main/scripts/install.sh | sh
+```
+
+Windows PowerShell:
+
+```powershell
+& ([scriptblock]::Create((irm https://raw.githubusercontent.com/phonton-dev/phonton-cli/main/scripts/install.ps1)))
+```
+
+Direct Cargo install:
+
+```bash
+cargo install --git https://github.com/phonton-dev/phonton-cli --tag v0.2.0 phonton-cli --locked --force
+```
+
+Check the install:
+
+```bash
+phonton version
+phonton doctor
+```
+
+## Release Channels
+
+Phonton uses GitHub branches and releases as install channels:
+
+| Channel | Install | Use when |
+|---|---|---|
+| Stable | `cargo install --git https://github.com/phonton-dev/phonton-cli --tag v0.2.0 phonton-cli --locked --force` | You want the best validated public alpha |
+| Dev | `cargo install --git https://github.com/phonton-dev/phonton-cli --branch dev phonton-cli --locked --force` | You want next-release integration changes |
+| Nightly | `cargo install --git https://github.com/phonton-dev/phonton-cli --branch nightly phonton-cli --locked --force` | You want daily snapshots and can tolerate breakage |
+| Main | `cargo install --git https://github.com/phonton-dev/phonton-cli --branch main phonton-cli --locked --force` | You want the current release branch tip |
+
+For the channel policy and automation, read [docs/RELEASE_CHANNELS.md](docs/RELEASE_CHANNELS.md).
+
+## Build From Source
+
+```bash
+git clone https://github.com/phonton-dev/phonton-cli.git
+cd phonton-cli
+cargo build --release -p phonton-cli
+```
+
+Run the binary:
+
+```bash
+./target/release/phonton
+```
+
+On Windows:
+
+```powershell
+.\target\release\phonton.exe
+```
+
+## Configure A Provider
+
+Phonton reads `~/.phonton/config.toml` and also checks provider-specific environment variables.
+
+Minimal config:
+
+```toml
+[provider]
+name = "gemini"
+model = "gemma-4-31b-it"
+
+[budget]
+max_tokens = 120000
+max_usd_cents = 200
+```
+
+Environment-variable setup examples:
+
+```bash
+export ANTHROPIC_API_KEY="..."
+export OPENAI_API_KEY="..."
+export GEMINI_API_KEY="..."
+export OPENROUTER_API_KEY="..."
+```
+
+Windows PowerShell:
+
+```powershell
+$env:GEMINI_API_KEY = "..."
+```
+
+Check the install:
+
+```bash
+phonton doctor
+phonton doctor --provider
+```
+
+`phonton doctor --provider` proves the configured key/model/base URL can make a real completion call. It does not claim every listed provider works for every account, model name, quota state, or proxy configuration.
+
+## CLI Commands
+
+```text
+phonton                 Launch the interactive TUI
+phonton ask <question>  One-shot Q&A using the configured provider
+phonton doctor          Check config, store, trust, git, cargo, and Nexus
+phonton plan <goal>     Preview the task DAG without changing files
+phonton review          Show verified diff review payloads
+phonton memory list     Inspect local decision memory
+phonton config path     Print the resolved config file path
+phonton config show     Dump resolved config as TOML
+phonton version         Print version
+```
+
+Plan preview:
+
+```bash
+phonton plan --json "add input validation to config loading"
+```
+
+Review latest completed task:
+
+```bash
+phonton review latest
+phonton review approve latest
+phonton review reject latest
+```
+
+Memory management:
+
+```bash
+phonton memory list --json
+phonton memory edit <id> "updated rationale"
+phonton memory pin <id>
+phonton memory delete <id>
+```
+
+## How Phonton Handles Context
+
+<p align="center">
+  <img src="assets/readme/context-efficiency.png" alt="Diagram contrasting whole repo context with compact context packs and verified diffs">
+</p>
+
+Phonton is built around a simple rule: do not blindly dump the whole repo into the model.
+
+```mermaid
+flowchart TD
+    Repo["Local repo"] --> Index["Source index"]
+    Index --> Planner["Planner"]
+    Planner --> Pack["Task-specific context"]
+    Pack --> Worker["Worker"]
+    Worker --> Verify["Verify"]
+    Verify --> Review["Review"]
+    Review --> Store["Memory and event store"]
+    Store --> Planner
+```
+
+The intended result is lower context waste and better reviewability. The honest way to prove that is with benchmarks, so this repo includes a benchmark harness instead of hard-coded marketing numbers.
+
+## Benchmarks
+
+Run the plan benchmark harness:
+
+```powershell
+.\scripts\benchmark-plan.ps1
+```
+
+It runs repeatable planning tasks, captures estimated Phonton tokens versus the planner's naive baseline, and writes Markdown plus JSON reports to `benchmarks/results/`.
+
+Read the methodology in [docs/BENCHMARKS.md](docs/BENCHMARKS.md).
+
+Important: benchmark output is evidence, not a slogan. Do not claim "X percent savings" publicly until you can reproduce it on multiple real tasks and include the raw report.
+
+## Architecture
+
+```mermaid
+flowchart TB
+    CLI["phonton-cli"] --> Planner["phonton-planner"]
+    CLI --> Orchestrator["phonton-orchestrator"]
+    Orchestrator --> Worker["phonton-worker"]
+    Orchestrator --> Verify["phonton-verify"]
+    Worker --> Providers["phonton-providers"]
+    Worker --> Context["phonton-context"]
+    Context --> Index["phonton-index"]
+    Verify --> Diff["phonton-diff"]
+    Verify --> Sandbox["phonton-sandbox"]
+    Planner --> Memory["phonton-memory"]
+    Memory --> Store["phonton-store"]
+    Types["phonton-types"] --> CLI
+    Types --> Orchestrator
+    Types --> Worker
+```
+
+Repository layout:
+
+- `phonton-cli` - terminal UI and user-facing command surface.
+- `phonton-planner` - goal decomposition and plan preview.
+- `phonton-orchestrator` - task state, dependencies, retries, and event flow.
+- `phonton-worker` - model-call loop, tool policy, and patch generation.
+- `phonton-verify` - syntax/type/test/decision checks before review.
+- `phonton-index` - local source indexing and semantic retrieval.
+- `phonton-context` - task-specific context compilation.
+- `phonton-diff` - diff application and rollback support.
+- `phonton-memory` / `phonton-store` - local persistence and decision memory.
+- `phonton-providers` - BYOK provider adapters.
+- `phonton-sandbox` - command execution policy.
+- `phonton-types` - shared domain contracts.
+
+## Release Checks
+
+Before cutting a release:
+
+```powershell
+.\scripts\release-check.ps1
+```
+
+The script runs formatting, clippy, tests, release build, doctor, and the plan benchmark harness.
+
+Manual checks worth doing before a public release:
+
+- Fresh clone install on Windows, macOS, and Linux.
+- `phonton doctor --provider` with at least one hosted provider, confirming both model discovery and a completion call.
+- One real repo task from goal to reviewable verified diff.
+- Benchmark report committed or attached to the release notes.
+- No secrets printed in logs, screenshots, or benchmark output.
+
+## Comparison
+
+Phonton is not trying to win by pretending the incumbents are weak.
+
+| Tool | Strongest fit | Where Phonton is trying to be different |
+|---|---|---|
+| Codex | Mature agent workflow, cloud/editor/CLI integration | Local-first ADE kernel, BYOK, explicit verification and review surfaces |
+| Claude Code | Excellent terminal-native coding agent | Less chat-first, more plan/verify/review oriented |
+| Cursor | Polished AI editor experience | Less editor polish, more auditable repo workflow |
+| Windsurf | Agentic IDE workflow | Narrower release scope, stronger local-first positioning |
+| Phonton CLI | Verified local ADE loop for serious repo tasks | Early product, smaller ecosystem, benchmark claims still being built |
+
+## Development
+
+```bash
+cargo fmt --all -- --check
+cargo clippy --locked --workspace --all-targets -- -D warnings
+cargo test --locked --workspace
+cargo build --locked --release -p phonton-cli
+```
+
+Run from source:
+
+```bash
+cargo run -p phonton-cli -- doctor
+cargo run -p phonton-cli -- plan "add input validation to config loading"
+```
+
+## License
+
+Licensed under either of:
+
+- Apache License, Version 2.0
+- MIT License
+
+at your option.
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/chart?repos=phonton-dev/phonton-cli&type=date&legend=top-left)](https://www.star-history.com/?repos=phonton-dev%2Fphonton-cli&type=date&legend=top-left)

package/npm/bin/phonton.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const { spawn, spawnSync } = require("child_process");
+
+const binaryName = process.platform === "win32" ? "phonton.exe" : "phonton";
+const binaryPath = path.join(__dirname, "..", "vendor", binaryName);
+
+function ensureBinary() {
+  if (fs.existsSync(binaryPath)) {
+    return;
+  }
+
+  const installScript = path.join(__dirname, "..", "install.js");
+  const result = spawnSync(process.execPath, [installScript], { stdio: "inherit" });
+  if (result.status !== 0 || !fs.existsSync(binaryPath)) {
+    process.exit(result.status || 1);
+  }
+}
+
+ensureBinary();
+
+const child = spawn(binaryPath, process.argv.slice(2), { stdio: "inherit" });
+child.on("exit", (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+  process.exit(code ?? 0);
+});

package/npm/install.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const https = require("https");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const packageJson = require("../package.json");
+
+const repo = "phonton-dev/phonton-cli";
+const version = packageJson.version;
+const tag = process.env.PHONTON_RELEASE_TAG || (version.includes("nightly") ? "nightly" : `v${version}`);
+const vendorDir = path.join(__dirname, "vendor");
+
+const targets = {
+  "linux-x64": {
+    asset: "phonton-x86_64-unknown-linux-gnu.tar.gz",
+    binary: "phonton",
+    extract: "tar",
+  },
+  "darwin-arm64": {
+    asset: "phonton-aarch64-apple-darwin.tar.gz",
+    binary: "phonton",
+    extract: "tar",
+  },
+  "win32-x64": {
+    asset: "phonton-x86_64-pc-windows-msvc.zip",
+    binary: "phonton.exe",
+    extract: "zip",
+  },
+};
+
+const target = targets[`${process.platform}-${process.arch}`];
+if (!target) {
+  console.error(`Unsupported platform for prebuilt Phonton CLI: ${process.platform}-${process.arch}`);
+  console.error("Install from source instead:");
+  console.error(`cargo install --git https://github.com/${repo} --tag ${tag} phonton-cli --locked --force`);
+  process.exit(1);
+}
+
+const url = `https://github.com/${repo}/releases/download/${tag}/${target.asset}`;
+const archivePath = path.join(os.tmpdir(), target.asset);
+
+fs.rmSync(vendorDir, { recursive: true, force: true });
+fs.mkdirSync(vendorDir, { recursive: true });
+
+download(url, archivePath)
+  .then(() => extract(archivePath, target.extract))
+  .then(() => {
+    const binaryPath = path.join(vendorDir, target.binary);
+    if (!fs.existsSync(binaryPath)) {
+      throw new Error(`expected binary missing after install: ${binaryPath}`);
+    }
+    if (process.platform !== "win32") {
+      fs.chmodSync(binaryPath, 0o755);
+    }
+    console.log(`Installed Phonton CLI ${tag} for ${process.platform}-${process.arch}`);
+  })
+  .catch((error) => {
+    console.error(error.message || error);
+    process.exit(1);
+  });
+
+function download(from, to) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(to);
+    https
+      .get(from, (response) => {
+        if ([301, 302, 303, 307, 308].includes(response.statusCode)) {
+          file.close();
+          fs.rmSync(to, { force: true });
+          download(response.headers.location, to).then(resolve, reject);
+          return;
+        }
+        if (response.statusCode !== 200) {
+          reject(new Error(`download failed (${response.statusCode}): ${from}`));
+          return;
+        }
+        response.pipe(file);
+        file.on("finish", () => {
+          file.close(resolve);
+        });
+      })
+      .on("error", (error) => {
+        file.close();
+        fs.rmSync(to, { force: true });
+        reject(error);
+      });
+  });
+}
+
+function extract(archive, kind) {
+  if (kind === "tar") {
+    run("tar", ["-xzf", archive, "-C", vendorDir]);
+    return;
+  }
+
+  const command = "powershell";
+  const args = [
+    "-NoProfile",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-Command",
+    `Expand-Archive -LiteralPath '${archive.replace(/'/g, "''")}' -DestinationPath '${vendorDir.replace(/'/g, "''")}' -Force`,
+  ];
+  run(command, args);
+}
+
+function run(command, args) {
+  const result = spawnSync(command, args, { stdio: "inherit" });
+  if (result.status !== 0) {
+    throw new Error(`${command} ${args.join(" ")} failed`);
+  }
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "phonton-cli",
+  "version": "0.2.0",
+  "description": "Local-first agentic development terminal with context packs, source handles, and verification gates.",
+  "license": "MIT OR Apache-2.0",
+  "homepage": "https://github.com/phonton-dev/phonton-cli#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/phonton-dev/phonton-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/phonton-dev/phonton-cli/issues"
+  },
+  "bin": {
+    "phonton": "npm/bin/phonton.js",
+    "phonton-cli": "npm/bin/phonton.js"
+  },
+  "scripts": {
+    "postinstall": "node npm/install.js",
+    "test:npm-wrapper": "node npm/bin/phonton.js version"
+  },
+  "files": [
+    "npm/bin/phonton.js",
+    "npm/install.js",
+    "README.md",
+    "LICENSE-MIT",
+    "LICENSE-APACHE"
+  ],
+  "keywords": [
+    "ai",
+    "agent",
+    "coding-agent",
+    "cli",
+    "terminal",
+    "rust",
+    "developer-tools",
+    "local-first",
+    "code-review",
+    "verification"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}