capix-code 1.3.0

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "capix-code",
+  "version": "1.3.0",
+  "description": "Capix Code \u2014 decentralized AI coding agent with GPU marketplace",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "capix-code": "./bin/capix-code.cjs"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "dist/customer/config/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "compile": "tsc --noEmit",
+    "lint": "eslint src/",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "manifest:validate": "node scripts/validate-manifest.mjs manifest/release-manifest.json",
+    "manifest:build": "node scripts/build-manifest.mjs",
+    "resolve-version": "node scripts/resolve-version.mjs",
+    "prepack": "node scripts/prepare-npm-meta.mjs",
+    "pack:npm-platform": "node scripts/prepare-npm-platform.mjs",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "devDependencies": {
+    "@ai-sdk/provider": "3.0.8",
+    "@eslint/js": "^9.0.0",
+    "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "^2.1.0",
+    "@capix/runtime-provider": "file:packages/runtime-provider",
+    "@opencode-ai/plugin": "1.17.18",
+    "@opencode-ai/sdk": "1.17.18",
+    "bun": "^1.3.14",
+    "eslint": "^9.0.0",
+    "husky": "^9.0.0",
+    "lint-staged": "^15.0.0",
+    "opencode-ai": "1.17.18",
+    "prettier": "^3.0.0",
+    "typescript": "^5.7.0",
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^2.1.0"
+  },
+  "lint-staged": {
+    "*.{ts,js}": [
+      "prettier --write",
+      "eslint --fix"
+    ],
+    "*.{json,md,yml}": [
+      "prettier --write"
+    ]
+  },
+  "optionalDependencies": {
+    "@capix-code/darwin-arm64": "1.2.7",
+    "@capix-code/darwin-x64": "1.2.7",
+    "@capix-code/linux-arm64": "1.2.7",
+    "@capix-code/linux-x64": "1.2.7",
+    "@capix-code/windows-x64": "1.2.7"
+  },
+  "keywords": [
+    "ai",
+    "coding",
+    "agent",
+    "gpu",
+    "llm",
+    "inference",
+    "capix",
+    "solana"
+  ]
+}

package/scripts/assert-artifact.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="${1:?artifact directory required}"
+SUFFIX=""
+test -f "$ROOT/bin/capix-code.exe" && SUFFIX=".exe"
+required=(
+  "bin/capix-code$SUFFIX"
+  "engine/capix-engine$SUFFIX"
+  runtime/src/plugin.ts
+  runtime/src/native-bridge.ts
+  runtime/src/broker.ts
+  runtime/src/sandbox.ts
+  runtime/src/capix-provider.ts
+  runtime/src/ai-sdk-provider.ts
+  runtime/packages/runtime-provider/package.json
+  runtime/node_modules/@capix/runtime-provider/package.json
+  config/capix-defaults.json
+  config/defaults.json
+)
+for path in "${required[@]}"; do
+  test -e "$ROOT/$path" || { echo "✗ artifact missing $path"; exit 1; }
+done
+test -x "$ROOT/engine/capix-engine$SUFFIX" || { echo "✗ bundled engine is not executable"; exit 1; }
+test -x "$ROOT/bin/capix-code$SUFFIX" || { echo "✗ native launcher is not executable"; exit 1; }
+grep -q '"name": "@capix/runtime-provider"' "$ROOT/runtime/packages/runtime-provider/package.json"
+grep -q '"model": "{env:CAPIX_MODEL:capix/auto}"' "$ROOT/config/defaults.json"
+grep -q 'SuperGemma' "$ROOT/config/defaults.json"
+grep -q '/oauth/authorize' "$ROOT/runtime/src/broker.ts"
+grep -q '/oauth/token' "$ROOT/runtime/src/broker.ts"
+echo "✓ artifact contains pinned engine, plugin, broker, sandbox and runtime provider"

package/scripts/assert-customer-brand.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="${1:?artifact directory required}"
+FORBIDDEN='opencode|vast|hetzner|void|vscode'
+
+if find "$ROOT" -path "$ROOT/runtime/node_modules" -prune -o -type f -print | sed "s|$ROOT/||" | grep -Eiq "$FORBIDDEN"; then
+  echo "✗ customer artifact contains a forbidden filename"
+  exit 1
+fi
+
+for command in "--help" "--version" "doctor"; do
+  output="$($ROOT/bin/capix-code $command 2>&1)"
+  if printf '%s' "$output" | grep -Eiq "$FORBIDDEN"; then
+    echo "✗ forbidden customer-visible brand in: capix-code $command"
+    exit 1
+  fi
+done
+
+# The embedded engine is not invoked directly by customers, but every help
+# surface it can render through the launcher must still be Capix-only.
+for args in "--help" "run --help"; do
+  output="$($ROOT/engine/capix-engine $args 2>&1)"
+  if printf '%s' "$output" | grep -Eiq "$FORBIDDEN"; then
+    echo "✗ forbidden predecessor brand in embedded engine output: $args"
+    exit 1
+  fi
+done
+
+# Native account commands must never fall through to the bundled engine's
+# command parser. An unsigned CI artifact has no user keychain credential, so
+# the expected result is a clean Capix-only sign-in instruction.
+set +e
+status_output="$($ROOT/bin/capix-code status 2>&1)"
+status_code=$?
+set -e
+if [ "$status_code" -eq 0 ]; then
+  # A developer machine may already have a valid native keychain session.
+  printf '%s' "$status_output" | grep -Fq '"accountId"' || {
+    echo "✗ authenticated status did not return canonical Capix account data"; exit 1;
+  }
+else
+  printf '%s' "$status_output" | grep -Fq 'capix-code login' || {
+    echo "✗ status did not return the native Capix authentication instruction"; exit 1;
+  }
+fi
+if printf '%s' "$status_output" | grep -Eiq "$FORBIDDEN"; then
+  echo "✗ status leaked a forbidden inherited brand"; exit 1
+fi
+
+if grep -ERiq "$FORBIDDEN" "$ROOT/config"; then
+  echo "✗ forbidden customer-visible brand in configuration"
+  exit 1
+fi
+echo "✓ customer-visible artifact surfaces use Capix branding only"

package/scripts/assert-upstream-brand.sh

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT="${1:?prepared engine source required}"
+# Internal import/package symbols intentionally retain their upstream ABI.
+# This expression targets customer-readable identity and command prose only.
+FORBIDDEN='OpenCode|OC \||run opencode|close opencode|Starting opencode|opencode -s|opencode (models|auth|does|version|server|with|to|upgrade|mcp|session)|Thank you[^\n]*opencode'
+SURFACES=(
+  packages/tui/src/logo.ts
+  packages/tui/src/app.tsx
+  packages/tui/src/util/presentation.ts
+  packages/capix-code/src/cli/ui.ts
+  packages/capix-code/src/index.ts
+  packages/capix-code/src/cli/error.ts
+  packages/capix-code/src/cli/cmd/run.ts
+  packages/capix-code/src/cli/cmd/run/splash.ts
+  packages/capix-code/src/cli/cmd/run/footer.permission.tsx
+  packages/capix-code/src/cli/cmd/run/footer.prompt.tsx
+  packages/capix-code/src/cli/cmd/run/permission.shared.ts
+  packages/capix-code/src/provider/error.ts
+  packages/capix-code/src/cli/cmd/attach.ts
+  packages/capix-code/src/cli/cmd/upgrade.ts
+  packages/capix-code/src/cli/cmd/uninstall.ts
+  packages/capix-code/src/cli/cmd/serve.ts
+  packages/capix-code/src/cli/cmd/web.ts
+  packages/capix-code/src/cli/cmd/pr.ts
+  packages/capix-code/src/cli/cmd/tui.ts
+  packages/capix-code/src/cli/network.ts
+)
+for file in "${SURFACES[@]}"; do
+  test -f "$ROOT/$file" || { echo "✗ missing customer presentation source: $file"; exit 1; }
+  if grep -Eq "$FORBIDDEN" "$ROOT/$file"; then
+    echo "✗ predecessor branding remains in customer presentation source: $file"
+    grep -En "$FORBIDDEN" "$ROOT/$file" | head -n 10
+    exit 1
+  fi
+done
+grep -Fq 'CAPIX CODE' "$ROOT/packages/capix-code/src/cli/ui.ts" || {
+  echo "✗ Capix Code startup wordmark is missing"
+  exit 1
+}
+grep -Fq 'export const identity' "$ROOT/packages/tui/src/logo.ts" &&
+  grep -Fq 'CAPIX CODE' "$ROOT/packages/tui/src/logo.ts" || {
+  echo "✗ Capix Code TUI identity is missing"
+  exit 1
+}
+echo "✓ prepared engine customer presentation sources are Capix-only"

package/scripts/bootstrap.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+# bootstrap.sh — clone upstream source and prepare capix-code.
+set -euo pipefail
+
+DIR="$(cd "$(dirname "$0")/.." && pwd)"
+CAPIX_CODE_DIR="${CAPIX_CODE_DIR:-$DIR/upstream}"
+
+# TODO: Update this SHA when upgrading upstream
+CAPIX_CODE_REF="${CAPIX_CODE_REF:-9976269ab1accfc9f9dc98a4a688c516934de422}"
+
+if [ -d "$CAPIX_CODE_DIR/.git" ]; then
+  echo "✓ $CAPIX_CODE_DIR already cloned."
+else
+  echo "▸ Cloning upstream source into $CAPIX_CODE_DIR (SHA: $CAPIX_CODE_REF)…"
+  git clone https://github.com/anomalyco/opencode.git "$CAPIX_CODE_DIR"
+  git -C "$CAPIX_CODE_DIR" checkout "$CAPIX_CODE_REF"
+fi
+
+ACTUAL_REF="$(git -C "$CAPIX_CODE_DIR" rev-parse HEAD)"
+if [ "$ACTUAL_REF" != "$CAPIX_CODE_REF" ]; then
+  echo "✗ Source checkout is at $ACTUAL_REF; expected pinned ref $CAPIX_CODE_REF"
+  echo "  Use a new CAPIX_CODE_DIR or restore the pinned checkout before continuing."
+  exit 1
+fi
+
+# A prepared checkout is intentionally changed by scripts/rebrand.sh. Treat the
+# expected renamed package as an idempotent success, while still rejecting an
+# unrelated dirty checkout before the first rebrand.
+if [ -d "$CAPIX_CODE_DIR/packages/capix-code" ]; then
+  echo "✓ Pinned Capix Code source already prepared: $ACTUAL_REF"
+  exit 0
+fi
+
+git -C "$CAPIX_CODE_DIR" diff --quiet || {
+  echo "✗ Source tree has unstaged changes before Capix preparation"
+  exit 1
+}
+echo "✓ Pinned source ready: $ACTUAL_REF"

package/scripts/build-manifest.mjs

@@ -0,0 +1,219 @@
+/**
+ * Build (materialize) manifest/release-manifest.json from real per-platform
+ * release entries produced by write-release-entry.mjs.
+ *
+ * A publishable manifest is assembled ONLY from real artifact metadata — it
+ * never copies through TEMPLATE placeholders. If a required platform entry is
+ * missing or carries invalid metadata, the build fails closed.
+ *
+ * Usage:
+ *   node scripts/build-manifest.mjs \
+ *     --entries release-artifacts \
+ *     --base-url https://github.com/CapIX-Protocol/Capix-Code/releases/download \
+ *     --stable-version v1.2.4 \
+ *     --source-sha <40-hex> \
+ *     --launcher-version 1.2.4 --opencode-version 1.17.18 \
+ *     --plugin-version 1.2.4 --provider-version 1.2.4 \
+ *     [--out manifest/release-manifest.json] [--require-all]
+ *
+ * The stable version is the single source of truth consumed by the installer's
+ * `latest` resolver and by validate-manifest.
+ */
+import { readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const REQUIRED_PLATFORMS = ['darwin-arm64', 'darwin-x64', 'linux-arm64', 'linux-x64', 'win32-x64'];
+const SEMVER_TAG = /^v\d+\.\d+\.\d+$/;
+const SHA1 = /^[0-9a-f]{40}$/;
+const SHA256 = /^[0-9a-f]{64}$/;
+const SEMVER = /^\d+\.\d+\.\d+$/;
+
+function parseArgs(argv) {
+  const args = {
+    entries: 'release-artifacts',
+    out: 'manifest/release-manifest.json',
+    requireAll: false,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    switch (a) {
+      case '--entries':
+        args.entries = argv[++i];
+        break;
+      case '--base-url':
+        args.baseUrl = argv[++i];
+        break;
+      case '--stable-version':
+        args.stableVersion = argv[++i];
+        break;
+      case '--source-sha':
+        args.sourceSha = argv[++i];
+        break;
+      case '--launcher-version':
+        args.launcherVersion = argv[++i];
+        break;
+      case '--opencode-version':
+        args.opencodeVersion = argv[++i];
+        break;
+      case '--plugin-version':
+        args.pluginVersion = argv[++i];
+        break;
+      case '--provider-version':
+        args.providerVersion = argv[++i];
+        break;
+      case '--out':
+        args.out = argv[++i];
+        break;
+      case '--require-all':
+        args.requireAll = true;
+        break;
+      default:
+        throw new Error(`unknown argument: ${a}`);
+    }
+  }
+  return args;
+}
+
+function requireArg(args, name) {
+  const v = args[name];
+  if (!v)
+    throw new Error(
+      `${name} is required (pass --${name.replace(/([A-Z])/g, '-$1').toLowerCase()})`
+    );
+  return v;
+}
+
+/** Read every capix-code-*-{platform}-{arch}.release.json in the entries dir. */
+export function readReleaseEntries(entriesDir) {
+  const files = readdirSync(entriesDir).filter((f) => /\.release\.json$/i.test(f));
+  const entries = new Map();
+  for (const f of files) {
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync(join(entriesDir, f), 'utf8'));
+    } catch (err) {
+      throw new Error(`cannot parse ${f}: ${err.message}`);
+    }
+    if (parsed.product !== 'capix-code') throw new Error(`${f}: product is not capix-code`);
+    const platform = parsed.platform;
+    if (!platform || !REQUIRED_PLATFORMS.includes(platform)) {
+      throw new Error(`${f}: unrecognized platform "${platform}"`);
+    }
+    if (entries.has(platform))
+      throw new Error(`duplicate release entry for platform ${platform} (${f})`);
+    entries.set(platform, parsed);
+  }
+  return entries;
+}
+
+/**
+ * Build the manifest object from a map of platform -> release entry.
+ * Pure function — testable without touching the filesystem.
+ */
+export function buildManifestFromEntries(entries, opts) {
+  const {
+    baseUrl,
+    stableVersion,
+    sourceSha,
+    launcherVersion,
+    opencodeVersion,
+    pluginVersion,
+    providerVersion,
+  } = opts;
+  const errors = [];
+  if (!SEMVER_TAG.test(stableVersion ?? ''))
+    errors.push('--stable-version must be vMAJOR.MINOR.PATCH');
+  if (!SHA1.test(sourceSha ?? ''))
+    errors.push('--source-sha must be a 40-character lowercase hex commit SHA');
+  for (const [name, v] of [
+    ['launcher', launcherVersion],
+    ['opencode', opencodeVersion],
+    ['plugin', pluginVersion],
+    ['provider', providerVersion],
+  ]) {
+    if (!SEMVER.test(v ?? '')) errors.push(`--${name}-version must be MAJOR.MINOR.PATCH`);
+  }
+  if (!baseUrl || !/^https:\/\//.test(baseUrl)) errors.push('--base-url must be an https URL');
+
+  const present = [...entries.keys()];
+  if (opts.requireAll) {
+    for (const p of REQUIRED_PLATFORMS)
+      if (!entries.has(p)) errors.push(`missing required platform entry: ${p}`);
+  }
+  if (errors.length) throw new Error(errors.join('; '));
+
+  const platforms = {};
+  for (const p of REQUIRED_PLATFORMS) {
+    const e = entries.get(p);
+    if (!e) continue; // when not --require-all, only publish what exists
+    if (!SHA256.test(e.sha256 ?? ''))
+      throw new Error(`${p}: release entry sha256 is not a valid 64-hex digest`);
+    if (typeof e.sizeBytes !== 'number' || e.sizeBytes <= 0)
+      throw new Error(`${p}: release entry sizeBytes must be positive`);
+    const tag = stableVersion;
+    platforms[p] = {
+      url: `${baseUrl}/${tag}/${e.artifact}`,
+      sha256: e.sha256,
+      // Unsigned artifacts ship a null signatureUrl; strict signing is a
+      // separate, later gate. Never TEMPLATE.
+      signatureUrl: e.signed ? `${baseUrl}/${tag}/${e.artifact}.sig` : null,
+      sizeBytes: e.sizeBytes,
+    };
+  }
+
+  const createdAt = process.env.SOURCE_DATE_EPOCH
+    ? new Date(Number(process.env.SOURCE_DATE_EPOCH) * 1000).toISOString()
+    : new Date().toISOString();
+
+  return {
+    id: `rel_capix_code_${stableVersion.slice(1).replace(/\./g, '_')}`,
+    schemaVersion: 1,
+    stableVersion,
+    createdAt,
+    createdBy: 'release-engineering',
+    immutable: true,
+    launcher: { sourceSha, version: launcherVersion },
+    opencode: { sourceSha, version: opencodeVersion },
+    plugin: { sourceSha, version: pluginVersion },
+    provider: { sourceSha, version: providerVersion },
+    acpVersion: '1',
+    ipcVersion: '1',
+    apiRange: { min: 'v1', max: 'v1' },
+    platforms,
+    sbomRef: `${baseUrl}/${stableVersion}/sbom.spdx.json`,
+    provenanceRef: `${baseUrl}/${stableVersion}/provenance.json`,
+    signatureRef: null,
+    thirdPartyNoticesRef: `${baseUrl}/${stableVersion}/NOTICE`,
+    rollbackConstraints: ['retain-n-1'],
+    publishedPlatforms: present,
+  };
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const entries = readReleaseEntries(args.entries);
+  const manifest = buildManifestFromEntries(entries, {
+    baseUrl: requireArg(args, 'baseUrl'),
+    stableVersion: requireArg(args, 'stableVersion'),
+    sourceSha: requireArg(args, 'sourceSha'),
+    launcherVersion: requireArg(args, 'launcherVersion'),
+    opencodeVersion: requireArg(args, 'opencodeVersion'),
+    pluginVersion: requireArg(args, 'pluginVersion'),
+    providerVersion: requireArg(args, 'providerVersion'),
+    requireAll: args.requireAll,
+  });
+  writeFileSync(args.out, `${JSON.stringify(manifest, null, 2)}\n`);
+  console.log(
+    `✓ wrote ${args.out} (stable=${manifest.stableVersion}, platforms=${Object.keys(manifest.platforms).join(',')})`
+  );
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  try {
+    main();
+  } catch (err) {
+    console.error(`✗ ${err.message}`);
+    process.exit(1);
+  }
+}

package/scripts/build.sh

@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+# build.sh — produce packaged capix-code binaries.
+set -euo pipefail
+
+DIR="$(cd "$(dirname "$0")/.." && pwd)"
+CAPIX_CODE_DIR="${CAPIX_CODE_DIR:-$DIR/upstream}"
+BUN="${BUN_BIN:-$(command -v bun || true)}"
+if [ -z "$BUN" ] && [ -x "$DIR/node_modules/.bin/bun" ]; then BUN="$DIR/node_modules/.bin/bun"; fi
+[ -n "$BUN" ] || { echo "✗ Bun 1.3.14 is required"; exit 1; }
+[ "$($BUN --version)" = "1.3.14" ] || { echo "✗ Expected Bun 1.3.14"; exit 1; }
+
+if [ ! -d "$CAPIX_CODE_DIR" ]; then
+  echo "✗ No $CAPIX_CODE_DIR. Run ./scripts/bootstrap.sh first."
+  exit 1
+fi
+
+cd "$CAPIX_CODE_DIR"
+
+echo "▸ Building capix-code standalone binary…"
+"$BUN" install
+
+# The embedded engine otherwise falls back to a timestamped 0.0.0 development
+# identifier. Stamp it with the immutable Capix Code package version so the TUI,
+# API metadata and diagnostics all report the customer release.
+CAPIX_RELEASE_VERSION="${CAPIX_CODE_VERSION:-$(node -p 'require(process.argv[1]).version' "$DIR/package.json")}"
+export OPENCODE_VERSION="$CAPIX_RELEASE_VERSION"
+
+# Write default config if the init script exists.
+if [ -f "packages/capix-code/scripts/init-capix-config.ts" ]; then
+  "$BUN" run packages/capix-code/scripts/init-capix-config.ts 2>/dev/null || true
+fi
+
+# Build using the upstream build script.
+if [ -f "packages/capix-code/script/build.ts" ]; then
+  "$BUN" run --cwd packages/capix-code script/build.ts --single
+fi
+
+# Find the output — handle both renamed and original patterns.
+EXE_SUFFIX=""
+case "$(uname -s)" in MINGW*|MSYS*|CYGWIN*) EXE_SUFFIX=".exe";; esac
+OUTPUT=$(find packages/capix-code/dist -name "capix-code$EXE_SUFFIX" -type f 2>/dev/null | head -1)
+if [ -z "$OUTPUT" ]; then
+  OUTPUT=$(find packages/capix-code/dist -name "opencode$EXE_SUFFIX" -type f 2>/dev/null | head -1)
+  if [ -n "$OUTPUT" ]; then
+    NEW_OUTPUT="$(dirname "$OUTPUT")/capix-code$EXE_SUFFIX"
+    mv "$OUTPUT" "$NEW_OUTPUT"
+    OUTPUT="$NEW_OUTPUT"
+  fi
+fi
+
+if [ -n "$OUTPUT" ]; then
+  ARTIFACT="$DIR/dist/customer"
+  rm -rf "$ARTIFACT"
+  mkdir -p "$ARTIFACT/bin" "$ARTIFACT/engine" "$ARTIFACT/runtime/packages" "$ARTIFACT/config"
+  cp "$OUTPUT" "$ARTIFACT/engine/capix-engine$EXE_SUFFIX"
+  cp -R "$DIR/src" "$ARTIFACT/runtime/src"
+  cp -R "$DIR/packages/runtime-provider" "$ARTIFACT/runtime/packages/runtime-provider"
+  cp "$DIR/config/runtime-package.json" "$ARTIFACT/runtime/package.json"
+  cp "$DIR/config/capix-defaults.json" "$DIR/config/defaults.json" "$ARTIFACT/config/"
+  cp -R "$DIR/commands" "$ARTIFACT/commands"
+  chmod 0755 "$ARTIFACT/engine/capix-engine$EXE_SUFFIX"
+  # Install from the dedicated runtime manifest. The outer npm package has
+  # platform selectors which do not belong inside the embedded runtime.
+  (cd "$ARTIFACT/runtime" && npm install --omit=dev --ignore-scripts)
+  (cd "$DIR/launcher" && cargo build --locked --release)
+  cp "$DIR/launcher/target/release/capix-code$EXE_SUFFIX" "$ARTIFACT/bin/capix-code$EXE_SUFFIX"
+  chmod 0755 "$ARTIFACT/bin/capix-code$EXE_SUFFIX"
+  "$DIR/scripts/assert-artifact.sh" "$ARTIFACT"
+  "$DIR/scripts/assert-customer-brand.sh" "$ARTIFACT"
+  echo "✓ Customer artifact staged: $ARTIFACT"
+else
+  echo "✗ No binary found in dist/ — build may have failed."
+  exit 1
+fi

package/scripts/checksum.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -euo pipefail
+DIST_DIR="${1:-dist}"
+for f in "$DIST_DIR"/*.tar.gz "$DIST_DIR"/*.zip; do
+  [ -f "$f" ] || continue
+  shasum -a 256 "$f" > "$f.sha256"
+  echo "  $(basename $f): $(cat "$f.sha256" | awk '{print $1}')"
+done

package/scripts/dev-install.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+# Local development installation of Capix Code
+# This is NOT a production installer — for development only
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+SOURCE_DIR="$(dirname "$SCRIPT_DIR")"
+
+echo "=== Capix Code Development Install ==="
+echo "Path: $SOURCE_DIR"
+echo ""
+
+# Install dependencies
+cd "$SOURCE_DIR"
+if [ ! -d "node_modules" ]; then
+  echo "Installing dependencies..."
+  npm install
+fi
+
+# Type check
+echo "Running type check..."
+npx tsc --noEmit
+
+# Run tests
+echo "Running tests..."
+npx vitest run
+
+echo ""
+echo "✅ Development environment ready."
+echo "Run: npx tsx src/plugin.ts  # to start the Capix Code agent"

package/scripts/dev.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+#
+# dev.sh — launch capix-code in dev mode.
+#
+# Requires the repository-pinned Bun 1.3.14 runtime.
+set -euo pipefail
+
+DIR="$(cd "$(dirname "$0")/.." && pwd)"
+CAPIX_CODE_DIR="${CAPIX_CODE_DIR:-$DIR/upstream}"
+BUN="${BUN_BIN:-$(command -v bun || true)}"
+if [ -z "$BUN" ] && [ -x "$DIR/node_modules/.bin/bun" ]; then BUN="$DIR/node_modules/.bin/bun"; fi
+[ -n "$BUN" ] || { echo "✗ Bun 1.3.14 is required; install the pinned runtime first"; exit 1; }
+[ "$($BUN --version)" = "1.3.14" ] || { echo "✗ Expected Bun 1.3.14"; exit 1; }
+
+if [ ! -d "$CAPIX_CODE_DIR" ]; then
+  echo "✗ No $CAPIX_CODE_DIR. Run ./scripts/bootstrap.sh first."
+  exit 1
+fi
+
+cd "$CAPIX_CODE_DIR"
+
+echo "▸ Installing dependencies (Bun)…"
+"$BUN" install
+
+echo "▸ Writing default Capix config (if missing)…"
+"$BUN" run packages/capix-code/scripts/init-capix-config.ts 2>/dev/null || true
+
+echo "▸ Launching capix-code (dev mode)…"
+echo ""
+echo "  Set your Capix env vars before starting:"
+echo "    export CAPIX_BASE_URL=https://capix.network/api/v1"
+echo "    export CAPIX_API_KEY=cpk_...   (or your deployed cpxllm_... key)"
+echo "    export CAPIX_MODEL=capix/auto   (optional — defaults to auto)"
+echo ""
+"$BUN" run --cwd packages/capix-code --conditions=browser src/index.ts "$@"