@langgexyz/anycode 0.0.0-stage → 0.4.6

package/README.md

@@ -1,3 +1,130 @@
-# Temporary Holding Version
+# AnyCode
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+AnyCode 是原子 capability 执行层。它负责能力注册、项目 binding、Provider
+调用、幂等记录和 evidence；宿主负责组合、调度和最终交付判断。
+
+## 唯一运行路径
+
+```text
+Native host session (OpenCode / Claude Code / other host)
+  -> host adapter
+  -> anycode capability invoke
+  -> atomic catalog
+  -> project binding
+  -> provider
+  -> result + evidence
+```
+
+一次调用只包含请求、项目配置和原子输入。OpenCode、Claude Code 和其他宿主使用各自的
+Host Adapter 和同一 capability protocol；AnyCode 不提供宿主编排入口。
+
+## 原子调用
+
+```bash
+anycode capability invoke \
+  --protocol-version anycode.capability.invoke.v1 \
+  --request-id <request-id> \
+  --contract-version <contract-version> \
+  --session-id <native-session-id> \
+  --execution-root <workspace-directory> \
+  --capability <domain.capability> \
+  --config-root <project>/.anycode \
+  --target <target> \
+  --component <component> \
+  --idempotency-key <key> \
+  --timeout-ms 30000 < input.json
+```
+
+`execution-root` 是 provider 执行时使用的 workspace/worktree 目录，不是权限边界。
+AnyCode 校验项目配置、target binding 和 capability 输入；workspace 内文件操作不做
+应用层权限判断。结果使用稳定协议：
+
+```json
+{
+  "status": "pass | na | blocked | failed",
+  "certainty": "confirmed | unknown",
+  "side_effect": "none | possible | confirmed",
+  "output": {},
+  "evidence": []
+}
+```
+
+`certainty=unknown` 表示 Provider 可能已经产生副作用但结果未确认，AnyCode 不自动
+重放；由宿主决定查询、重试或暂停。
+
+## 配置与安装
+
+项目配置位于 `.anycode/`，由宿主或 Connector 作为 capability request 的输入提供；runtime
+不再维护第二套高层 CLI。安装和更新通过 anycode.me 的原生发布包完成，能力执行统一使用
+`capability invoke`。
+
+组合、并发、取消、重试和结果聚合由宿主原生机制负责。OpenCode runtime 对 Provider 错误
+只做统一分类并提示安全的下一步，不在失败后盲目重放或偷偷切换模型；其他宿主只需适配同一
+原子协议。
+
+产品安装与宿主接入：
+
+```bash
+curl -fsSL https://anycode.me/install.sh | sh
+curl -fsSL https://anycode.me/install.sh | ANYCODE_VERSION=<version> sh
+anycode --help
+anycode doctor
+```
+
+发布渠道提供 stable 和 rc。稳定版发布完成后，站点更新
+`https://anycode.me/releases/latest.json`；不指定版本默认安装 stable。发布包支持 macOS 和 Linux 的 `arm64`、`x64` 以及 Windows `x64`；安装器支持
+macOS 和 Linux，Windows 用户从 `https://anycode.me/releases/v<版本>/` 手动下载。安装目录为
+`~/.local/share/anycode`，启动器为 `~/.local/bin/anycode`。本地工程操作不要求登录；需要访问
+AnyCode 账户的操作使用 `anycode login`，升级使用 `anycode update`；Windows 暂不支持自动更新，需手动下载指定版本。
+
+仓库内没有 workflow 推送 tag；维护者从具备仓库写权限的 Git 环境推送 tag，测试机只用于构建与测试。
+
+发版前使用 `release-prepare` 取得版本号，脚本会刷新远端 tags，并读取标题包含“发布 AnyCode
+<版本号>”的 open PR。正式模式在写入 `package.json` 前再次读取这两类占用状态，发现竞争时自动重新取号；
+`--dry-run` 只输出计划。输出为单行 JSON，便于脚本消费：
+
+```bash
+bun scripts/release-prepare.ts --channel rc --dry-run
+bun scripts/release-prepare.ts --channel rc
+bun scripts/release-prepare.ts --channel stable
+```
+
+正式模式写入版本后，按 JSON 中的 `commands` 创建分支、提交并发起版本 PR；创建 PR 前应再次确认远端没有
+新增同版本 tag 或 open 版本 PR。输出 JSON 的 `status` 为 `ready` 表示已确认并写入版本；若连续 10 次复核
+都检测到版本号竞争，脚本以 `status: "blocked"`、`version: null`、空 `commands` 和非零退出码结束，且不改动
+`package.json`，此时应等待竞争版本落地后重试。
+
+新机器的依赖、Harness 接入、`doctor`、升级和回滚流程见
+[安装与首次启动](docs/installation.md)。
+
+Agent 安装后的 Harness 接入、渐进式 Connector/账号引导和任务启动/完成门禁见
+[Agent onboarding and Harness usage](docs/agent-onboarding.md)。
+
+安装只替换单一 immutable 安装目录；Host Adapter 由对应 Harness 的原生安装机制管理，并通过
+已安装版本提供的稳定 entrypoint/manifest 接入，不依赖源码路径，不创建 workspace 权限或工作流状态。
+
+## 验证
+
+```bash
+npm run catalog:check
+npm run typecheck
+npm run architecture:doctor
+bun scripts/run-bounded-test.ts --max-concurrency=4
+```
+
+当前完整测试覆盖原子 catalog、workspace 执行上下文、幂等/不确定结果、Provider、配置和
+delivery capability。发布时必须同时验证 capability protocol、实际 CLI 和 immutable package。
+
+## 维护 capability catalog 文档
+
+`docs/capability-catalog.md` 由 `runtime/providers/src/catalog.ts` 生成，禁止手工编辑生成段落。
+任何改动 `catalog.ts`（新增/删除/重命名能力，或修改 domain、inputs、outputs、effect、
+providerKind、evidence、compensation）的 PR，都必须在更新后的 main 上重新生成并提交文档：
+
+```bash
+npm run catalog:generate
+npm run catalog:check
+```
+
+`npm run catalog:check` 已接入 `.github/workflows/ci.yml`，未重新生成文档的 PR 会因
+catalog 漂移而 CI 失败。合并前请先 rebase/merge 最新 main 再重跑上述两条命令，避免与并行改动冲突。

package/npm/README.md

@@ -0,0 +1,41 @@
+# `@langgexyz/anycode`
+
+The primary install channel for AnyCode is `anycode.me`. The npm package is an
+additional channel: it bootstraps the same verified native runtime, and any
+non-`install` command is forwarded to the activated native runtime.
+
+## npm / npx
+
+```bash
+# Download, verify, and activate the native runtime for this platform
+npx @langgexyz/anycode install
+npx @langgexyz/anycode install --version <version> --harness opencode-v1
+npx @langgexyz/anycode install --version <version> --harness opencode-v2
+npx @langgexyz/anycode install --version <version> --harness claude
+npx @langgexyz/anycode install --version <version> --harness pi
+
+# Global install
+npm install -g @langgexyz/anycode
+
+# Forward any command to the installed native runtime
+npx @langgexyz/anycode <command>
+```
+
+`--harness` accepts `opencode-v1`, `opencode-v2`, `claude`, or `pi`.
+
+## anycode.me
+
+```bash
+curl -fsSL https://anycode.me/install.sh | sh
+curl -fsSL https://anycode.me/install.sh | ANYCODE_VERSION=<version> sh
+anycode update
+```
+
+The release packages support macOS and Linux on `arm64` and `x64`, plus Windows
+`x64`. The installer supports macOS and Linux; Windows users can manually
+download the `windows-x64` package from
+`https://anycode.me/releases/v<version>/`. During preview, the default install
+command resolves the stable manifest published by the release workflow. The
+installer places the launcher at
+`~/.local/bin/anycode` and the runtime at `~/.local/share/anycode`. Windows does
+not support automatic `anycode update`; manually download a versioned package.

package/npm/dist/cli.mjs

@@ -0,0 +1,914 @@
+#!/usr/bin/env node
+
+// npm/src/cli.ts
+import { createHash as createHash3 } from "node:crypto";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname as dirname3, join as join4 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+// runtime/archive/src/index.ts
+import { gunzipSync, gzipSync } from "node:zlib";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, posix, relative, resolve } from "node:path";
+function readTarGzip(archive) {
+  const bytes = gunzipSync(readFileSync(archive));
+  const entries = [];
+  let offset = 0;
+  let pendingPath = "";
+  let pendingPax = {};
+  while (offset + 512 <= bytes.length) {
+    const header = bytes.subarray(offset, offset + 512);
+    offset += 512;
+    if (header.every((value) => value === 0))
+      break;
+    verifyChecksum(header);
+    const typeFlag = text(header, 156, 1) || "0";
+    const size = octal(header, 124, 12);
+    const bodySize = Math.ceil(size / 512) * 512;
+    if (offset + bodySize > bytes.length)
+      throw new Error("archive entry exceeds archive size");
+    const body = bytes.subarray(offset, offset + size);
+    offset += bodySize;
+    if (typeFlag === "x" || typeFlag === "g") {
+      pendingPax = typeFlag === "x" ? parsePax(body) : pendingPax;
+      continue;
+    }
+    if (typeFlag === "L") {
+      pendingPath = body.toString("utf8").replace(/\0+$/u, "").replace(/\n+$/u, "");
+      continue;
+    }
+    const path = pendingPax["path"] || pendingPath || join(text(header, 345, 155), text(header, 0, 100));
+    pendingPath = "";
+    pendingPax = {};
+    if (!path)
+      throw new Error("archive entry path is empty");
+    const mode = pendingNumber(header, 100, 8, "mode");
+    const type = typeFlag === "0" || typeFlag === "" ? "file" : typeFlag === "5" ? "directory" : "unsupported";
+    entries.push({ path, type, mode, data: Buffer.from(body) });
+  }
+  return entries;
+}
+function extractTarGzip(archive, destination) {
+  const entries = readTarGzip(archive);
+  const seen = new Set;
+  for (const entry of entries) {
+    const path = safeArchivePath(destination, entry.path);
+    const normalized = normalizeArchivePath(entry.path);
+    if (seen.has(normalized))
+      throw new Error(`archive contains duplicate member: ${entry.path}`);
+    seen.add(normalized);
+    if (entry.type === "unsupported")
+      throw new Error("package contains unsupported archive member type");
+    if (entry.type === "directory") {
+      mkdirSync(path, { recursive: true });
+      continue;
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, entry.data, { mode: entry.mode || 420 });
+    chmodSync(path, entry.mode & 4095 || 420);
+  }
+  return entries;
+}
+function parsePax(body) {
+  const result = {};
+  let offset = 0;
+  while (offset < body.length) {
+    const space = body.indexOf(32, offset);
+    if (space < 0)
+      throw new Error("invalid archive PAX header");
+    const length = Number(body.subarray(offset, space).toString("ascii"));
+    if (!Number.isInteger(length) || length <= 0 || offset + length > body.length)
+      throw new Error("invalid archive PAX length");
+    const record = body.subarray(space + 1, offset + length - 1).toString("utf8");
+    const equal = record.indexOf("=");
+    if (equal <= 0)
+      throw new Error("invalid archive PAX record");
+    result[record.slice(0, equal)] = record.slice(equal + 1);
+    offset += length;
+  }
+  return result;
+}
+function safeArchivePath(root, value) {
+  const normalized = normalizeArchivePath(value);
+  const path = resolve(root, normalized);
+  const relativePath = relative(resolve(root), path);
+  if (!relativePath || relativePath === ".." || relativePath.startsWith(`..${"/"}`) || relativePath.startsWith("/"))
+    throw new Error(`package contains unsafe path: ${value}`);
+  return path;
+}
+function normalizeArchivePath(value) {
+  const normalized = posix.normalize(value.replaceAll("\\", "/")).replace(/^\.\//u, "");
+  if (!normalized || normalized === "." || normalized.startsWith("..") || normalized.includes("/../") || normalized.startsWith("/"))
+    throw new Error(`package contains unsafe path: ${value}`);
+  return normalized;
+}
+function verifyChecksum(header) {
+  const expected = octal(header, 148, 8);
+  const copy = Buffer.from(header);
+  copy.fill(32, 148, 156);
+  const actual = [...copy].reduce((sum, value) => sum + value, 0);
+  if (expected !== actual)
+    throw new Error("archive header checksum mismatch");
+}
+function text(buffer, offset, length) {
+  return buffer.subarray(offset, offset + length).toString("utf8").replace(/\0+$/u, "").trim();
+}
+function octal(buffer, offset, length) {
+  const value = text(buffer, offset, length).replace(/\0/g, "").trim();
+  return value ? Number.parseInt(value, 8) : 0;
+}
+function pendingNumber(buffer, offset, length, field) {
+  const value = octal(buffer, offset, length);
+  if (!Number.isSafeInteger(value) || value < 0)
+    throw new Error(`archive ${field} is invalid`);
+  return value;
+}
+
+// runtime/core/src/connector.ts
+class ConnectorRegistry {
+  connectors = new Map;
+  capabilityOwners = new Map;
+  capabilitySetups = new Map;
+  constructor(connectors = [], setups = []) {
+    for (const setup of setups)
+      this.registerSetup(setup);
+    for (const connector of connectors)
+      this.register(connector);
+  }
+  register(connector) {
+    validateConnector(connector);
+    if (this.connectors.has(connector.id))
+      throw new Error(`duplicate connector: ${connector.id}`);
+    for (const capability of connector.capabilities) {
+      const setup = connector.setup?.[capability];
+      if (setup !== undefined) {
+        validateSetup(setup);
+        if (setup.connectorId !== connector.id || setup.capability !== capability) {
+          throw new Error(`Connector setup identity does not match its owner: ${connector.id}/${capability}`);
+        }
+        if (this.capabilitySetups.has(setupKey(connector.id, capability)))
+          throw new Error(`capability setup already registered: ${capability}`);
+      }
+    }
+    this.connectors.set(connector.id, connector);
+    for (const capability of connector.capabilities) {
+      const owners = this.capabilityOwners.get(capability) ?? [];
+      owners.push(connector);
+      this.capabilityOwners.set(capability, owners);
+      const setup = connector.setup?.[capability];
+      if (setup !== undefined)
+        this.capabilitySetups.set(setupKey(connector.id, capability), setup);
+    }
+  }
+  registerSetup(setup) {
+    validateSetup(setup);
+    const key = setupKey(setup.connectorId, setup.capability);
+    if (this.capabilitySetups.has(key))
+      throw new Error(`capability setup already registered: ${setup.capability}`);
+    this.capabilitySetups.set(key, setup);
+  }
+  resolve(capabilityId, connectorId) {
+    const owners = this.capabilityOwners.get(capabilityId) ?? [];
+    if (connectorId !== undefined)
+      return owners.find((connector) => connector.id === connectorId);
+    return owners.length === 1 ? owners[0] : undefined;
+  }
+  all() {
+    return [...this.connectors.values()];
+  }
+  declaredCapabilities() {
+    return [...new Set([...this.capabilityOwners.keys(), ...[...this.capabilitySetups.values()].map((setup) => setup.capability)])];
+  }
+  async execute(request, connectorId) {
+    validateCapabilityRequest(request);
+    const owners = this.capabilityOwners.get(request.capabilityId) ?? [];
+    if (connectorId !== undefined && !owners.some((connector2) => connector2.id === connectorId)) {
+      return unavailable(request, this.capabilitySetups.get(setupKey(connectorId, request.capabilityId)));
+    }
+    if (connectorId === undefined && owners.length > 1) {
+      return failed(request, `multiple Connectors implement ${request.capabilityId}; select one in the project binding`, "connector_binding_required");
+    }
+    const connector = connectorId === undefined ? owners[0] : this.resolve(request.capabilityId, connectorId);
+    if (!connector) {
+      const setups = [...this.capabilitySetups.values()].filter((setup) => setup.capability === request.capabilityId);
+      return unavailable(request, connectorId === undefined && setups.length === 1 ? setups[0] : undefined);
+    }
+    try {
+      const result = await connector.execute(request);
+      validateCapabilityResult(result);
+      if (result.capability !== request.capabilityId || result.runId !== request.runId)
+        return failed(request, "connector result identity does not match capability request", "connector_identity_mismatch");
+      return result;
+    } catch (error) {
+      return failed(request, error instanceof Error ? error.message : String(error), "connector_execution_failed");
+    }
+  }
+}
+function setupKey(connectorId, capability) {
+  return `${connectorId}\x00${capability}`;
+}
+function validateSetup(setup) {
+  if (!setup.connectorId.trim() || !setup.capability.trim())
+    throw new Error("Connector setup requires connectorId and capability");
+}
+function validateConnector(connector) {
+  if (!connector.id.trim())
+    throw new Error("connector id must not be empty");
+  if (connector.capabilities.length === 0)
+    throw new Error(`connector requires capabilities: ${connector.id}`);
+  const unique = new Set;
+  for (const capability of connector.capabilities) {
+    if (!/^[a-z0-9][a-z0-9-]*\.[a-z0-9][a-z0-9-]*$/u.test(capability))
+      throw new Error(`connector capability must use domain.name form: ${capability}`);
+    if (unique.has(capability))
+      throw new Error(`connector declares duplicate capability: ${capability}`);
+    unique.add(capability);
+  }
+}
+function unavailable(request, setup) {
+  return {
+    capability: request.capabilityId,
+    runId: request.runId,
+    status: "blocked",
+    inputs: request.inputs,
+    outputs: {},
+    evidence: [],
+    reason: `connector unavailable for capability: ${request.capabilityId}`,
+    certainty: "confirmed",
+    sideEffect: "none",
+    errorCode: "connector_unavailable",
+    declaration: "real",
+    recovery: {
+      action: "configure_connector",
+      capability: request.capabilityId,
+      target: request.trace.target,
+      idempotencyKey: request.idempotencyKey,
+      ...setup === undefined ? {} : { setup }
+    }
+  };
+}
+function failed(request, reason, errorCode) {
+  return {
+    capability: request.capabilityId,
+    runId: request.runId,
+    status: "failed",
+    inputs: request.inputs,
+    outputs: {},
+    evidence: [],
+    reason,
+    certainty: "unknown",
+    sideEffect: "possible",
+    errorCode,
+    declaration: "real",
+    recovery: {
+      action: "probe_connector",
+      capability: request.capabilityId,
+      target: request.trace.target,
+      idempotencyKey: request.idempotencyKey
+    }
+  };
+}
+// runtime/core/src/protection.ts
+var LOCAL_CAPABILITY_DOMAINS = new Set(["change", "project", "verification", "git"]);
+var TARGETS = new Set(["workstation", "test", "beta", "prod", "external"]);
+// runtime/core/src/index.ts
+class CapabilityRegistry {
+  specs = new Map;
+  constructor(specs = []) {
+    for (const spec of specs)
+      this.register(spec);
+  }
+  register(spec) {
+    if (this.specs.has(spec.capabilityId))
+      throw new Error(`duplicate capability: ${spec.capabilityId}`);
+    this.specs.set(spec.capabilityId, spec);
+  }
+  resolve(capabilityId) {
+    const spec = this.specs.get(capabilityId);
+    if (!spec)
+      throw new Error(`capability is not registered: ${capabilityId}`);
+    return spec;
+  }
+  all() {
+    return [...this.specs.values()];
+  }
+}
+function validateCapabilityResult(result) {
+  if (!result.capability.trim() || !result.runId.trim())
+    throw new Error("capability and runId must not be empty");
+  if (result.declaration !== "real" && result.declaration !== "probe")
+    throw new Error("declaration must be real or probe");
+  if (result.status === "pass" && result.evidence.length === 0)
+    throw new Error("pass result must include evidence");
+  if (result.status !== "pass" && !result.reason.trim())
+    throw new Error(`${result.status} result must include reason`);
+  if (result.recovery?.retryAfterMs !== undefined && (!Number.isFinite(result.recovery.retryAfterMs) || result.recovery.retryAfterMs < 0))
+    throw new Error("recovery retryAfterMs must be a non-negative finite number");
+}
+function validateCapabilityRequest(request) {
+  if (!request.capabilityId.trim() || !request.runId.trim())
+    throw new Error("capabilityId and runId must not be empty");
+  if (!request.trace.traceId.trim() || !request.trace.requestId.trim() || !request.trace.sessionId.trim()) {
+    throw new Error("trace requires traceId, requestId and sessionId");
+  }
+  if (request.timeoutMs !== undefined && (!Number.isInteger(request.timeoutMs) || request.timeoutMs <= 0)) {
+    throw new Error("timeoutMs must be a positive integer");
+  }
+}
+
+// runtime/providers/src/installation/package-build.ts
+var LAUNCHER = `#!/bin/sh
+` + `script="$0"
+` + `while [ -L "$script" ]; do
+` + `  target="$(readlink "$script")"
+` + `  case "$target" in
+` + `    /*) script="$target" ;;
+` + `    *) script="$(dirname "$script")/$target" ;;
+` + `  esac
+` + `done
+` + `root="$(CDPATH= cd -- "$(dirname -- "$script")/.." && pwd)"
+` + `if [ "$1" = "claude-hook" ]; then
+` + '  exec "${ANYCODE_NODE:-node}" "$root/runtime/claude/dist/cli.mjs" "$@"\n' + `fi
+` + 'exec "${ANYCODE_NODE:-node}" "$root/runtime/providers/dist/cli.mjs" "$@"\n';
+var WINDOWS_LAUNCHER = `@echo off\r
+` + `set "script=%~dp0"\r
+` + `set "root=%script%.."\r
+` + `if "%ANYCODE_NODE%"=="" set "ANYCODE_NODE=node"\r
+` + `if "%~1"=="claude-hook" (\r
+` + `  "%ANYCODE_NODE%" "%root%\\runtime\\claude\\dist\\cli.mjs" %*\r
+` + `  exit /b %ERRORLEVEL%\r
+` + `)\r
+` + `"%ANYCODE_NODE%" "%root%\\runtime\\providers\\dist\\cli.mjs" %*\r
+`;
+// runtime/providers/src/installation/package-installed.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2, lstatSync as lstatSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, readlinkSync } from "node:fs";
+import { join as join2, posix as posix2, relative as relative2, sep } from "node:path";
+var PACKAGE_SCHEMA = "anycode.package.v1";
+var FULL_REVISION = /^[0-9a-f]{40}$/u;
+function validateExistingInstall(root) {
+  let stat;
+  try {
+    stat = lstatSync2(root);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  if (!stat.isDirectory() || stat.isSymbolicLink())
+    throw new Error(`AnyCode install path must be a directory: ${root}`);
+  const names = readdirSync2(root);
+  if (!names.length)
+    return;
+  if (isLegacyVersionedInstall(root, names))
+    return;
+  const manifestPath = join2(root, "package-manifest.json");
+  if (!names.includes("package-manifest.json"))
+    throw new Error(`AnyCode install directory contains unrecognized files: ${root}`);
+  try {
+    JSON.parse(readFileSync2(manifestPath, "utf8"));
+  } catch {
+    throw new Error(`旧版扁平安装清单解析失败：${manifestPath}`);
+  }
+  verifyInstalledPackage(root);
+}
+function isLegacyVersionedInstall(root, names) {
+  if (!names.includes("current") || names.some((name) => name !== "current" && !/^v\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u.test(name)))
+    return false;
+  try {
+    const currentPath = join2(root, "current");
+    if (!lstatSync2(currentPath).isSymbolicLink())
+      return false;
+    const target = readlinkSync(currentPath);
+    if (target.includes("\\") || target.startsWith("/") || target.includes("..") || !names.includes(target))
+      return false;
+    for (const name of names) {
+      if (name === "current")
+        continue;
+      const versionRoot = join2(root, name);
+      if (!lstatSync2(versionRoot).isDirectory())
+        return false;
+      const manifest = verifyInstalledPackage(versionRoot);
+      if (name !== `v${manifest.version}`)
+        return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function verifyInstalledPackage(root) {
+  if (!existsSync2(root) || !lstatSync2(root).isDirectory())
+    throw new Error(`installed package does not exist: ${root}`);
+  const manifestPath = join2(root, "package-manifest.json");
+  if (!existsSync2(manifestPath) || !lstatSync2(manifestPath).isFile())
+    throw new Error(`installed package is missing manifest: ${manifestPath}`);
+  const value = JSON.parse(readFileSync2(manifestPath, "utf8"));
+  if (!isRecord(value))
+    throw new Error("installed package manifest is invalid");
+  if (value["schema"] !== PACKAGE_SCHEMA || value["name"] !== "anycode")
+    throw new Error("installed package manifest identity is invalid");
+  if (typeof value["version"] !== "string" || !value["version"])
+    throw new Error("installed package version is invalid");
+  if (typeof value["source_revision"] !== "string" || !FULL_REVISION.test(value["source_revision"]))
+    throw new Error("installed package source_revision is invalid");
+  if (!isRecord(value["files"]) || Object.keys(value["files"]).length === 0)
+    throw new Error("installed package files are invalid");
+  if (!Object.hasOwn(value["files"], "bin/anycode") && !Object.hasOwn(value["files"], "bin/anycode.exe"))
+    throw new Error("installed package is missing launcher: bin/anycode");
+  const files = {};
+  for (const [name, digest] of Object.entries(value["files"])) {
+    const relative3 = normalizeMember(name);
+    if (typeof digest !== "string" || !/^sha256:[0-9a-f]{64}$/u.test(digest))
+      throw new Error(`installed package file digest is invalid: ${name}`);
+    files[relative3] = digest;
+    const path = join2(root, ...relative3.split("/"));
+    if (!existsSync2(path) || !lstatSync2(path).isFile() || lstatSync2(path).isSymbolicLink())
+      throw new Error(`installed package verification failed: ${relative3}`);
+    if (fileDigest(path) !== digest)
+      throw new Error(`installed package verification failed: ${relative3}`);
+  }
+  if (typeof value["payload_digest"] !== "string" || value["payload_digest"] !== payloadDigest(files))
+    throw new Error("installed package payload digest is invalid");
+  const extras = installedFiles(root).filter((name) => !(name in files) && name !== "package-manifest.json");
+  if (extras.length > 0)
+    throw new Error(`installed package contains untracked files: ${extras.slice(0, 10).join(", ")}`);
+  return { schema: value["schema"], name: value["name"], version: value["version"], source_revision: value["source_revision"], files, payload_digest: value["payload_digest"] };
+}
+function installedFiles(root) {
+  const result = [];
+  const walk = (path) => {
+    for (const name of readdirSync2(path).sort()) {
+      const child = join2(path, name);
+      if (lstatSync2(child).isSymbolicLink())
+        throw new Error(`installed package contains unsupported symlink: ${child}`);
+      if (lstatSync2(child).isFile())
+        result.push(relative2(root, child).split(sep).join("/"));
+      else if (lstatSync2(child).isDirectory())
+        walk(child);
+    }
+  };
+  walk(root);
+  return result;
+}
+function normalizeMember(value) {
+  const normalized = posix2.normalize(value.replace(/^\.\//u, ""));
+  if (!value || value.includes("\\") || normalized === "." || normalized === ".." || normalized.startsWith("../") || value.startsWith("/"))
+    throw new Error(`installed package contains unsafe path: ${value}`);
+  return normalized;
+}
+function payloadDigest(files) {
+  const ordered = Object.fromEntries(Object.entries(files).sort(([left], [right]) => left.localeCompare(right)));
+  return digestText(JSON.stringify(ordered));
+}
+function fileDigest(path) {
+  return digestBytes(readFileSync2(path));
+}
+function digestText(value) {
+  return digestBytes(new TextEncoder().encode(value));
+}
+function digestBytes(value) {
+  return `sha256:${createHash("sha256").update(value).digest("hex")}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// runtime/providers/src/installation/activation.ts
+import { copyFileSync, existsSync as existsSync3, lstatSync as lstatSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readlinkSync as readlinkSync2, realpathSync, renameSync, rmSync, statSync as statSync2, symlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join3, relative as relative3, resolve as resolve2 } from "node:path";
+function activatePackage(stagedPackage, installRoot, launcherPath, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const executable = options.executable ?? (platform === "win32" ? "anycode.exe" : "anycode");
+  mkdirSync2(dirname2(installRoot), { recursive: true });
+  const releaseLock = acquireActivationLock(installRoot);
+  const previous = `${installRoot}.previous`;
+  let movedCurrent = false;
+  let installedNew = false;
+  try {
+    recoverInterruptedActivation(installRoot, previous);
+    const manifest = verifyInstalledPackage(stagedPackage);
+    validateExistingInstall(installRoot);
+    validateLauncherOwnership(launcherPath, installRoot, stagedPackage, executable, platform);
+    if (existsSync3(installRoot)) {
+      rmSync(previous, { recursive: true, force: true });
+      renameSync(installRoot, previous);
+      movedCurrent = true;
+    }
+    renameSync(stagedPackage, installRoot);
+    installedNew = true;
+    const installed = verifyInstalledPackage(installRoot);
+    if (installed.version !== manifest.version || installed.payload_digest !== manifest.payload_digest)
+      throw new Error("安装后的 AnyCode 包校验失败");
+    linkLauncher(join3(installRoot, "bin", executable), launcherPath, platform);
+    return installRoot;
+  } catch (error) {
+    if (installedNew && existsSync3(installRoot)) {
+      rmSync(installRoot, { recursive: true, force: true });
+    }
+    if (movedCurrent && existsSync3(previous) && !existsSync3(installRoot))
+      renameSync(previous, installRoot);
+    throw error;
+  } finally {
+    releaseLock();
+  }
+}
+function acquireActivationLock(installRoot) {
+  const lock = `${installRoot}.activation-lock`;
+  const deadline = Date.now() + 30000;
+  const token = `${process.pid}:${Date.now()}:${Math.random().toString(16).slice(2)}`;
+  while (true) {
+    try {
+      mkdirSync2(lock);
+      writeFileSync2(join3(lock, "owner"), token, { flag: "wx", mode: 384 });
+      return () => {
+        try {
+          if (readFileSync3(join3(lock, "owner"), "utf8") === token)
+            rmSync(lock, { recursive: true, force: true });
+        } catch {}
+      };
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+      const ownerPath = join3(lock, "owner");
+      let stale = false;
+      try {
+        const owner = readFileSync3(ownerPath, "utf8");
+        const pid = Number(owner.split(":", 1)[0]);
+        if (Number.isSafeInteger(pid) && pid > 0) {
+          try {
+            process.kill(pid, 0);
+          } catch (probeError) {
+            stale = probeError.code === "ESRCH";
+          }
+        }
+      } catch {
+        try {
+          stale = Date.now() - statSync2(lock).mtimeMs > 30000;
+        } catch {
+          stale = true;
+        }
+      }
+      if (stale) {
+        rmSync(lock, { recursive: true, force: true });
+        continue;
+      }
+      if (Date.now() >= deadline)
+        throw new Error(`timed out waiting for AnyCode activation lock: ${lock}`);
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
+    }
+  }
+}
+function recoverInterruptedActivation(installRoot, previous) {
+  if (existsSync3(installRoot))
+    return;
+  if (!existsSync3(previous))
+    return;
+  validateExistingInstall(previous);
+  renameSync(previous, installRoot);
+}
+function validateLauncherOwnership(launcher, root, staged, executable, platform) {
+  let existing;
+  try {
+    existing = lstatSync3(launcher);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  if (existing.isSymbolicLink()) {
+    const target = resolve2(dirname2(launcher), readlinkSync2(launcher));
+    const path = relative3(resolve2(root), target).replaceAll("\\", "/");
+    if (path === `bin/${executable}`)
+      return;
+    try {
+      validateExistingInstall(root);
+      if (path === `current/bin/${executable}` && realpathSync(target) === realpathSync(join3(root, "current", "bin", executable)))
+        return;
+    } catch {}
+  } else if (platform === "win32" && existing.isFile()) {
+    const bytes = readFileSync3(launcher);
+    for (const candidate of [join3(staged, "bin", executable), join3(root, "bin", executable)]) {
+      if (existsSync3(candidate) && bytes.equals(readFileSync3(candidate)))
+        return;
+    }
+  }
+  throw new Error(`refusing to replace an unmanaged anycode launcher: ${launcher}`);
+}
+function linkLauncher(source, launcherPath, platform) {
+  mkdirSync2(dirname2(launcherPath), { recursive: true });
+  const next = `${launcherPath}.${process.pid}.next`;
+  rmSync(next, { force: true });
+  if (platform === "win32")
+    copyFileSync(source, next);
+  else
+    symlinkSync(source, next);
+  renameSync(next, launcherPath);
+}
+// runtime/providers/src/installation/release-trust.ts
+import { verify } from "node:crypto";
+import { basename } from "node:path";
+
+// runtime/providers/src/installation/release-key.generated.ts
+var RELEASE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEA/hfqP5bUwAMqzY3QS+j9GIGjbYpyrtcheixQGJt93zo=
+-----END PUBLIC KEY-----
+`;
+
+// runtime/providers/src/installation/release-trust.ts
+function verifyReleaseChecksums(sums, encodedSignature, publicKey = RELEASE_PUBLIC_KEY_PEM) {
+  const encoded = encodedSignature.trim();
+  const signature = Buffer.from(encoded, "base64");
+  if (signature.toString("base64") !== encoded || signature.byteLength !== 64)
+    throw new Error("AnyCode SHA256SUMS 签名格式无效");
+  if (!verify(null, sums, publicKey, signature))
+    throw new Error("AnyCode SHA256SUMS Ed25519 签名验证失败");
+  return parseReleaseChecksums(Buffer.from(sums).toString("utf8"));
+}
+function parseReleaseChecksums(value) {
+  const result = new Map;
+  for (const line of value.split(/\r?\n/u)) {
+    if (!line.trim())
+      continue;
+    const match = /^([a-f0-9]{64})\s+[* ]?([^\s]+)$/u.exec(line.trim());
+    if (!match || basename(match[2]) !== match[2] || result.has(match[2]))
+      throw new Error("已签名 SHA256SUMS 格式无效");
+    result.set(match[2], match[1]);
+  }
+  if (!result.size)
+    throw new Error("已签名 SHA256SUMS 不能为空");
+  return result;
+}
+
+// runtime/providers/src/installation/update.ts
+import { createHash as createHash2, createPublicKey } from "node:crypto";
+var PLATFORM = new Map([
+  ["darwin-arm64", "darwin-arm64"],
+  ["darwin-x64", "darwin-x64"],
+  ["linux-arm64", "linux-arm64"],
+  ["linux-x64", "linux-x64"],
+  ["win32-arm64", "windows-arm64"],
+  ["win32-x64", "windows-x64"]
+]);
+var RELEASE_PUBLIC_KEY_DER_SHA256 = createHash2("sha256").update(createPublicKey(RELEASE_PUBLIC_KEY_PEM).export({ type: "spki", format: "der" })).digest("hex");
+// npm/src/cli.ts
+var HARNESS_IDS = ["opencode-v1", "opencode-v2", "claude", "pi"];
+var HARNESS_ENTRYPOINTS = {
+  "opencode-v1": "bin/harness/opencode-1.x.js",
+  "opencode-v2": "bin/harness/opencode-2.x.js",
+  claude: "bin/harness/claude.js",
+  pi: "bin/harness/pi.js"
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parsePackageMetadata(value) {
+  if (!isRecord2(value) || typeof value["version"] !== "string" || !value["version"].trim()) {
+    throw new Error("package.json must contain a non-empty version");
+  }
+  return { version: value["version"] };
+}
+var metadata = parsePackageMetadata(JSON.parse(await readFile(new URL("../../package.json", import.meta.url), "utf8")));
+var PACKAGE_VERSION = metadata.version;
+var RELEASE_BASE_URL = (process.env["ANYCODE_RELEASE_BASE_URL"] ?? "https://anycode.me").replace(/\/$/u, "");
+var homeDirectory = homedir();
+var INSTALL_ROOT = join4(process.env["ANYCODE_INSTALL_ROOT"] ?? join4(homeDirectory, ".local", "share", "anycode"));
+var BIN_DIR = process.env["ANYCODE_BIN_DIR"] ?? join4(homeDirectory, ".local", "bin");
+var NODE_MINIMUM_MAJOR = 20;
+var DOWNLOAD_TIMEOUT_MS = 60000;
+function usage() {
+  console.log(`AnyCode ${PACKAGE_VERSION}
+
+Usage:
+  curl -fsSL https://anycode.me/install.sh | sh
+  curl -fsSL https://anycode.me/install.sh | ANYCODE_VERSION=<version> sh
+
+After installation:
+  anycode doctor
+  anycode help [topic] [--json]
+  anycode <native-anycode-command> [...args]
+
+Install downloads and verifies the immutable GitHub release. Other commands are
+forwarded to the activated native AnyCode runtime.
+
+Node.js ${NODE_MINIMUM_MAJOR} or newer is required. Git and a Harness (OpenCode,
+Claude Code, or Pi) are separate optional integrations.
+Supported Harness adapters: opencode-v1, opencode-v2, claude, pi.`);
+}
+function normalizedVersion(value) {
+  const version = value.startsWith("v") ? value.slice(1) : value;
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(version)) {
+    throw new Error(`invalid AnyCode version: ${value}`);
+  }
+  return version;
+}
+function option(args, name, fallback) {
+  const index = args.indexOf(name);
+  if (index < 0)
+    return fallback;
+  const value = args[index + 1];
+  if (!value || value.startsWith("--"))
+    throw new Error(`${name} requires a value`);
+  return value;
+}
+function ensureNodeVersion() {
+  const major = Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10);
+  if (!Number.isInteger(major) || major < NODE_MINIMUM_MAJOR) {
+    throw new Error(`AnyCode requires Node.js >= ${NODE_MINIMUM_MAJOR}; detected ${process.versions.node}. Install or upgrade Node.js before continuing.`);
+  }
+}
+async function verifyArtifact(artifact, checksumFile) {
+  const expected = (await readFile(checksumFile, "utf8")).trim().split(/\s+/).at(-1);
+  const actual = createHash3("sha256").update(await readFile(artifact)).digest("hex");
+  const normalized = expected?.replace(/^sha256:/, "");
+  if (!normalized || normalized !== actual) {
+    throw new Error("release artifact sha256 does not match its checksum");
+  }
+}
+async function verifySignedRelease(version, target, artifact, options = {}) {
+  const root = `${(options.baseUrl ?? RELEASE_BASE_URL).replace(/\/$/u, "")}/releases/v${version}`;
+  if (!root.startsWith("https://"))
+    throw new Error("AnyCode release base URL must use HTTPS");
+  const fetcher = options.fetcher ?? fetch;
+  const [manifestResponse, sumsResponse, signatureResponse] = await Promise.all([
+    fetcher(`${root}/latest.json`, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) }),
+    fetcher(`${root}/SHA256SUMS`, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) }),
+    fetcher(`${root}/SHA256SUMS.sig`, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) })
+  ]);
+  if (!manifestResponse.ok || !sumsResponse.ok || !signatureResponse.ok)
+    throw new Error("AnyCode release trust metadata is unavailable");
+  const manifest = await manifestResponse.json();
+  if (manifest.version !== version)
+    throw new Error("AnyCode release manifest version does not match the requested version");
+  const platform = `${target.os}-${target.arch}`;
+  const name = `anycode-${version}-${platform}.tar.gz`;
+  const file = manifest.files?.find((candidate) => candidate.platform === platform && candidate.name === name);
+  if (!file || typeof file.sha256 !== "string")
+    throw new Error("AnyCode release manifest has no unique platform asset");
+  const sums = await sumsResponse.text();
+  const signedHash = verifyReleaseChecksums(Buffer.from(sums), await signatureResponse.text(), options.publicKeyPem ?? RELEASE_PUBLIC_KEY_PEM).get(name);
+  if (signedHash !== file.sha256)
+    throw new Error("AnyCode manifest does not match signed SHA256SUMS");
+  const actual = createHash3("sha256").update(await readFile(artifact)).digest("hex");
+  if (actual !== signedHash)
+    throw new Error("AnyCode release artifact does not match signed SHA256SUMS");
+}
+var RELEASE_TARGETS = {
+  "linux-x64": { os: "linux", arch: "x64", executable: "anycode" },
+  "linux-arm64": { os: "linux", arch: "arm64", executable: "anycode" },
+  "darwin-x64": { os: "darwin", arch: "x64", executable: "anycode" },
+  "darwin-arm64": { os: "darwin", arch: "arm64", executable: "anycode" },
+  "win32-x64": { os: "windows", arch: "x64", executable: "anycode.exe" }
+};
+function releaseTarget() {
+  const target = RELEASE_TARGETS[`${process.platform}-${process.arch}`];
+  if (target === undefined)
+    throw new Error(`AnyCode has no native release for ${process.platform}-${process.arch}`);
+  return target;
+}
+function harnessOption(args) {
+  const value = option(args, "--harness", "");
+  if (!value)
+    return;
+  if (!HARNESS_IDS.includes(value))
+    throw new Error(`unsupported Harness: ${value}; choose ${HARNESS_IDS.join(", ")}`);
+  return value;
+}
+async function install(version, harness, options = {}) {
+  ensureNodeVersion();
+  const target = options.target ?? releaseTarget();
+  const installRoot = options.installRoot ?? INSTALL_ROOT;
+  const binDirectory = options.binDirectory ?? BIN_DIR;
+  const baseUrl = (options.baseUrl ?? RELEASE_BASE_URL).replace(/\/$/u, "");
+  if (!baseUrl.startsWith("https://"))
+    throw new Error("AnyCode release base URL must use HTTPS");
+  const fetcher = options.fetcher ?? fetch;
+  const requestOptions = { redirect: "follow", signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) };
+  await mkdir(dirname3(installRoot), { recursive: true });
+  const temporary = await mkdtemp(join4(dirname3(installRoot), ".anycode-npm-"));
+  const artifact = join4(temporary, `anycode-${version}-${target.os}-${target.arch}.tar.gz`);
+  const checksum = `${artifact}.sha256`;
+  const source = join4(temporary, "source");
+  try {
+    await downloadWith(fetcher, `${baseUrl}/releases/v${version}/anycode-${version}-${target.os}-${target.arch}.tar.gz`, artifact, requestOptions);
+    await downloadWith(fetcher, `${baseUrl}/releases/v${version}/anycode-${version}-${target.os}-${target.arch}.tar.gz.sha256`, checksum, requestOptions);
+    await verifyArtifact(artifact, checksum);
+    await verifySignedRelease(version, target, artifact, options);
+    await mkdir(source, { recursive: true });
+    extractTarGzip(artifact, source);
+    const manifest = verifyInstalledPackage(source);
+    if (manifest.files[`bin/${target.executable}`] === undefined)
+      throw new Error(`release package is missing native executable bin/${target.executable}`);
+    if (harness !== undefined && manifest.files[HARNESS_ENTRYPOINTS[harness]] === undefined) {
+      throw new Error(`release package does not contain the requested Harness adapter: ${harness}`);
+    }
+    activatePackage(source, installRoot, join4(binDirectory, target.executable), {
+      executable: target.executable,
+      ...options.platform === undefined ? {} : { platform: options.platform }
+    });
+    console.log(`AnyCode ${version} installed at ${installRoot}`);
+    if (harness !== undefined)
+      console.log(`Register only ${HARNESS_ENTRYPOINTS[harness]} in the native ${harness} configuration.`);
+    if (!pathContains(binDirectory))
+      console.log(`Add ${binDirectory} to PATH before using the anycode command in a new shell.`);
+  } finally {
+    await rm(temporary, { recursive: true, force: true });
+  }
+}
+async function downloadWith(fetcher, url, destination, requestOptions) {
+  const response = await fetcher(url, requestOptions);
+  if (!response.ok)
+    throw new Error(`download failed: ${response.status} ${response.statusText}`);
+  await writeFile(destination, Buffer.from(await response.arrayBuffer()));
+}
+function pathContains(directory) {
+  const separator = process.platform === "win32" ? ";" : ":";
+  return (process.env["PATH"] ?? "").split(separator).includes(directory);
+}
+function compareVersions(left, right) {
+  const parse = (value) => {
+    const [base, suffix] = value.split("-", 2);
+    return { core: base.split(".").map(Number), suffix: suffix?.split(".") };
+  };
+  const a = parse(left);
+  const b = parse(right);
+  for (let index = 0;index < 3; index += 1) {
+    const difference = (a.core[index] ?? 0) - (b.core[index] ?? 0);
+    if (difference)
+      return Math.sign(difference);
+  }
+  if (!a.suffix && !b.suffix)
+    return 0;
+  if (!a.suffix)
+    return 1;
+  if (!b.suffix)
+    return -1;
+  for (let index = 0;index < Math.max(a.suffix.length, b.suffix.length); index += 1) {
+    const x = a.suffix[index];
+    const y = b.suffix[index];
+    if (x === undefined)
+      return -1;
+    if (y === undefined)
+      return 1;
+    if (x === y)
+      continue;
+    const nx = /^\d+$/u.test(x);
+    const ny = /^\d+$/u.test(y);
+    if (nx && ny)
+      return Number(x) < Number(y) ? -1 : 1;
+    if (nx !== ny)
+      return nx ? -1 : 1;
+    return x.localeCompare(y);
+  }
+  return 0;
+}
+function newerNativeExecutable() {
+  const path = join4(INSTALL_ROOT, "bin", releaseTarget().executable);
+  const probe = spawnSync(path, ["version", "--json"], { encoding: "utf8", timeout: 5000 });
+  if (probe.status !== 0)
+    return;
+  try {
+    const value = JSON.parse(probe.stdout);
+    if (!isRecord2(value) || typeof value["version"] !== "string" || compareVersions(value["version"], PACKAGE_VERSION) <= 0)
+      return;
+    return { path, version: value["version"] };
+  } catch {
+    return;
+  }
+}
+async function main(args) {
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h" || args[0] === "install" && (args.includes("--help") || args.includes("-h"))) {
+    usage();
+    return 0;
+  }
+  if (args.includes("--version") && args.length === 1) {
+    const native = newerNativeExecutable();
+    console.log(native ? `${native.version} (${native.path})` : `${PACKAGE_VERSION} (${fileURLToPath(import.meta.url)})`);
+    return 0;
+  }
+  if (args[0] === "install") {
+    const version = normalizedVersion(option(args, "--version", PACKAGE_VERSION));
+    await install(version, harnessOption(args));
+    return 0;
+  }
+  const executable = newerNativeExecutable()?.path ?? join4(INSTALL_ROOT, "bin", releaseTarget().executable);
+  const result = spawnSync(executable, args, { stdio: "inherit" });
+  if (result.error) {
+    throw new Error(`AnyCode is not installed at ${INSTALL_ROOT}; run: curl -fsSL https://anycode.me/install.sh | sh`);
+  }
+  return result.status ?? 1;
+}
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  main(process.argv.slice(2)).then((code) => {
+    process.exitCode = code;
+  }).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`anycode: ${message}`);
+    process.exitCode = 1;
+  });
+}
+export {
+  install
+};

package/package.json

@@ -1,6 +1,48 @@
 {
   "name": "@langgexyz/anycode",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.6",
+  "description": "AnyCode distribution bootstrap for the native runtime",
+  "type": "module",
+  "bin": {
+    "anycode": "npm/dist/cli.mjs"
+  },
+  "files": [
+    "npm/dist/cli.mjs",
+    "npm/README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/bun": "1.4.0",
+    "@types/node": "26.6.1",
+    "jsonc-parser": "3.3.1",
+    "typescript": "7.0.2"
+  },
+  "scripts": {
+    "build": "bun scripts/generate-release-key.ts --check && bun build npm/src/cli.ts --outfile npm/dist/cli.mjs --target node",
+    "build:binary": "bun scripts/build-binary.ts",
+    "build:binary-package": "bun scripts/build-binary-package.ts",
+    "build:git-gate": "bun build scripts/git-gate.ts --outfile scripts/git-gate.mjs --target node",
+    "check:provider-bundle": "bun scripts/check-provider-bundle.ts",
+    "catalog:generate": "bun scripts/generate-capability-catalog-doc.ts",
+    "catalog:check": "bun scripts/generate-capability-catalog-doc.ts --check",
+    "build:release": "bun scripts/build-release.ts",
+    "test": "bun scripts/run-bounded-test.ts npm/tests/*.test.ts",
+    "test:providers": "bun scripts/run-bounded-test.ts runtime/providers/tests/*.test.ts",
+    "test:opencode": "bun run --cwd runtime/opencode/v1 typecheck && bun run --cwd runtime/opencode/v1 test && bun run --cwd runtime/opencode/v2 typecheck && bun run --cwd runtime/opencode/v2 test",
+    "test:opencode:v1-loader": "bun scripts/run-opencode-v1-registration-e2e.ts",
+    "test:opencode:e2e": "bun scripts/run-opencode-v2-e2e.ts",
+    "architecture:doctor": "bun scripts/architecture-doctor.ts",
+    "typecheck": "bun scripts/typecheck-runtime.ts",
+    "prepublishOnly": "npm run typecheck && npm run build && npm test",
+    "test:runtime": "bun run --cwd runtime/opencode/common test",
+    "test:modules": "bun run --cwd runtime/model-policy test && bun run --cwd runtime/provider-routing test && bun scripts/run-bounded-test.ts runtime/core/tests/*.test.ts runtime/contracts/tests/*.test.ts runtime/archive/tests/*.test.ts runtime/behavior/tests/*.test.ts runtime/credentials/tests/*.test.ts runtime/evidence/tests/*.test.ts runtime/harness-context/tests/*.test.ts runtime/usage/tests/*.test.ts runtime/claude/tests/*.test.ts runtime/pi/tests/*.test.ts scripts/*.test.ts",
+    "verify:native-runtime": "bun scripts/verify-native-runtime.ts",
+    "test:native-runtime:e2e": "bun scripts/run-native-runtime-e2e.ts",
+    "ci:test": "bun run architecture:doctor && bun run typecheck && bun run test:opencode && bun run test:opencode:v1-loader && bun run test:runtime && bun run test:modules && bun run test && bun run test:providers && bun run check:provider-bundle && bun run catalog:check && bash scripts/test-release-workflow.sh && bash scripts/test-release-publish.sh && bash scripts/test-wait-for-ci.sh && bun run test:opencode:e2e && OPENCODE_BINARY=\"$PWD/.cache/opencode-cli/node_modules/.bin/opencode\" bun run test:native-runtime:e2e"
+  }
+}