@tera-system/pro 0.1.1 → 0.1.3

package/MANIFEST.json

@@ -1,6 +1,6 @@
 {
   "name": "@tera-system/pro",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Build manifest for the Tera System Pro commercial plugin component.",
   "compatibleEnvironments": [
     "opencode"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tera-system/pro",
-  "version": "0.1.1",
-  "description": "Tera System Pro — commercial edition with enforced license gate, server sync, and heartbeat verification",
+  "version": "0.1.3",
+  "description": "Tera System Pro أ¢â‚¬â€‌ commercial edition with enforced license gate, server sync, and heartbeat verification",
   "license": "SEE LICENSE IN LICENSE.md",
   "type": "module",
   "engines": {

package/scripts/install.js

@@ -1,406 +1,419 @@
-#!/usr/bin/env node
-/**
- * @tera/core installer
- * --------------------------------------------------------------
- * NON-DESTRUCTIVE + OWNERSHIP-AWARE installer for the Tera System
- * OpenCode Plugin component.
- *
- * Rules:
- *  - Never deletes anything.
- *  - Never overwrites a file it does not own.
- *  - Tracks ownership via `.opencode/tera-core.manifest.json`.
- *  - Only updates files it owns, always keeping a backup first.
- *  - Idempotent: re-running is safe; identical files are skipped.
- *  - Never touches an existing user `opencode.json`.
- *
- * Target resolution (first match wins):
- *   1. `--target <dir>` argument
- *   2. `TERA_TARGET_DIR` environment variable
- *   3. `INIT_CWD` (set by npm for lifecycle scripts)
- *   4. current working directory
- */
-import { createHash } from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { assessLicenseState, readLicenseState, writeLicenseState } from "./lib/license.mjs";
-import { createIntegrityManifest, saveIntegrityManifest } from "./lib/integrity.mjs";
-import { verifyBundle, applyBundle } from "./lib/bundle.mjs";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const PKG_ROOT = path.resolve(__dirname, "..");
-const MANIFEST_NAME = "tera-core.manifest.json";
-const CONFIG_EXAMPLE = "opencode.tera.example.json";
-
-/* ---------------------------------- helpers ---------------------------------- */
-
-const sha256 = (buf) => createHash("sha256").update(buf).digest("hex");
-
-const toPosix = (p) => p.split(path.sep).join("/");
-
-function resolveTarget() {
-  const args = process.argv.slice(2);
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--help") {
-      console.log("Usage: node scripts/install.js [--target <workspaceRoot>]");
-      process.exit(0);
-    }
-    if (args[i] === "--target" && args[i + 1]) {
-      return path.resolve(args[i + 1]);
-    }
-  }
-  if (process.env.TERA_TARGET_DIR) return path.resolve(process.env.TERA_TARGET_DIR);
-  if (process.env.INIT_CWD) return path.resolve(process.env.INIT_CWD);
-  return path.resolve(process.cwd());
-}
-
-function walkFiles(dir) {
-  const out = [];
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) out.push(...walkFiles(full));
-    else if (entry.isFile()) out.push(full);
-  }
-  return out;
-}
-
-function copyFile(src, dest) {
-  fs.mkdirSync(path.dirname(dest), { recursive: true });
-  fs.copyFileSync(src, dest);
-}
-
-function loadOwnership(target) {
-  const p = path.join(target, ".opencode", MANIFEST_NAME);
-  if (!fs.existsSync(p)) return { files: {} };
-  try {
-    const parsed = JSON.parse(fs.readFileSync(p, "utf8"));
-    return { files: parsed.files && typeof parsed.files === "object" ? parsed.files : {} };
-  } catch {
-    return { files: {} };
-  }
-}
-
-/* ---------------------------------- state ---------------------------------- */
-
-const target = resolveTarget();
-const pkg = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf8"));
-const ownership = loadOwnership(target);
-
-const stats = { installed: 0, updated: 0, identical: 0, skippedGroups: 0, conflicts: [] };
-
-/* ------------------------------- group install ------------------------------- */
-
-/**
- * @param {{name:string, src:string, dest:string}} group
- */
-function installGroup(group) {
-  if (!fs.existsSync(group.src)) return;
-  for (const srcFile of walkFiles(group.src)) {
-    const relSrc = path.relative(group.src, srcFile);
-    const destFile = path.join(group.dest, relSrc);
-    const destRel = toPosix(path.relative(target, destFile));
-    const srcHash = sha256(fs.readFileSync(srcFile));
-
-    if (fs.existsSync(destFile)) {
-      const destHash = sha256(fs.readFileSync(destFile));
-      if (destHash === srcHash) {
-        stats.identical++;
-        continue;
-      }
-      const owned = Object.prototype.hasOwnProperty.call(ownership.files, destRel);
-      if (owned) {
-        const bak = `${destFile}.tera-bak-${Date.now()}`;
-        fs.copyFileSync(destFile, bak);
-        fs.copyFileSync(srcFile, destFile);
-        ownership.files[destRel] = srcHash;
-        stats.updated++;
-        console.log(`  [updated ] ${destRel}  (backup: ${path.basename(bak)})`);
-      } else {
-        stats.conflicts.push(destRel);
-        console.log(`  [CONFLICT] ${destRel} — kept your file (unowned, not overwritten).`);
-      }
-    } else {
-      copyFile(srcFile, destFile);
-      ownership.files[destRel] = srcHash;
-      stats.installed++;
-      console.log(`  [install ] ${destRel}`);
-    }
-  }
-}
-
-/* ---------------------------------- config ---------------------------------- */
-
-function installConfig() {
-  const configSrc = path.join(PKG_ROOT, CONFIG_EXAMPLE);
-  if (!fs.existsSync(configSrc)) return;
-  const configDest = path.join(target, ".opencode", "opencode.json");
-  const configRel = ".opencode/opencode.json";
-
-  if (fs.existsSync(configDest)) {
-    const a = sha256(fs.readFileSync(configDest));
-    const b = sha256(fs.readFileSync(configSrc));
-    if (a === b) {
-      stats.identical++;
-      console.log(`  [same    ] ${configRel} — already identical.`);
-    } else {
-      stats.conflicts.push(configRel);
-      console.log(`  [CONFLICT] ${configRel} — kept yours. Reference copy provided below.`);
-    }
-  } else {
-    copyFile(configSrc, configDest);
-    ownership.files[configRel] = sha256(fs.readFileSync(configDest));
-    stats.installed++;
-    console.log(`  [install ] ${configRel}`);
-  }
-
-  // Additive reference copy — always written, never destructive.
-  const exampleDest = path.join(target, ".opencode", CONFIG_EXAMPLE);
-  copyFile(configSrc, exampleDest);
-  console.log(`  [reference] .opencode/${CONFIG_EXAMPLE}`);
-}
-
-/* ------------------------------ project-control ------------------------------ */
-
-function installProjectControl() {
-  const pcSrc = path.join(PKG_ROOT, "core", "project-control");
-  if (!fs.existsSync(pcSrc)) return;
-  const pcDest = path.join(target, "project-control");
-  if (fs.existsSync(pcDest)) {
-    stats.skippedGroups++;
-    console.log("  [SKIP    ] project-control/ — exists (user-owned state). Skeleton not installed.");
-    return;
-  }
-  for (const f of walkFiles(pcSrc)) {
-    const relF = toPosix(path.relative(pcSrc, f));
-    const d = path.join(pcDest, relF);
-    copyFile(f, d);
-    ownership.files[`project-control/${relF}`] = sha256(fs.readFileSync(f));
-    stats.installed++;
-    console.log(`  [install ] project-control/${relF}`);
-  }
-}
-
-/* ----------------------------------- run ----------------------------------- */
-
-console.log(`\n@tera/core v${pkg.version} — install`);
-console.log(`  target workspace : ${target}\n`);
-
-installGroup({ name: "agents", src: path.join(PKG_ROOT, "agents"), dest: path.join(target, ".opencode", "agents") });
-installGroup({ name: "commands", src: path.join(PKG_ROOT, "commands"), dest: path.join(target, ".opencode", "commands") });
-installGroup({ name: "tera-system", src: path.join(PKG_ROOT, "core", "tera-system"), dest: path.join(target, "tera-system") });
-installGroup({ name: "tools", src: path.join(PKG_ROOT, "tools"), dest: path.join(target, "tools") });
-installGroup({ name: "scripts", src: path.join(PKG_ROOT, "scripts"), dest: path.join(target, "scripts") });
-installConfig();
-installProjectControl();
-
-/* -------------------------------- persist log -------------------------------- */
-
-const manifest = {
-  name: pkg.name,
-  version: pkg.version,
-  installedAt: new Date().toISOString(),
-  target,
-  files: ownership.files,
-  conflicts: stats.conflicts,
-  summary: {
-    installed: stats.installed,
-    updated: stats.updated,
-    identical: stats.identical,
-    skippedGroups: stats.skippedGroups,
-    conflicts: stats.conflicts.length,
-  },
-};
-
-const manifestPath = path.join(target, ".opencode", MANIFEST_NAME);
-fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
-fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-
-/* ------------------- license state (non-blocking, never breaks install) ------------------- */
-
-/**
- * License verification with API-first strategy + offline fallback.
- *
- * Flow:
- *   1. Try online API verification (if API URL is configured)
- *   2. On API failure → fallback to offline Ed25519 verification
- *   3. Never blocks install — always continues
- *
- * Environment variables:
- *   TERA_LICENSE_API  — API base URL (e.g. https://teranoo.com/api/license)
- *   TERA_LICENSE_KEY  — Manual license key override
- */
-const LICENSE_API_URL = process.env.TERA_LICENSE_API || "https://teranoo.com/api/license";
-const LICENSE_TIMEOUT_MS = 5000; // 5 seconds max for API call
-
-/**
- * Verify license via remote API (online).
- * Returns: { ok: boolean, state: string, reason: string, expiresAt?: string, source: "api" }
- */
-async function verifyViaAPI(licenseKey) {
-  if (!licenseKey) return { ok: false, state: "Unlicensed", reason: "no-key", source: "api" };
-
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), LICENSE_TIMEOUT_MS);
-
-    const res = await fetch(`${LICENSE_API_URL}/verify`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ licenseKey }),
-      signal: controller.signal,
-    });
-    clearTimeout(timeout);
-
-    if (!res.ok) {
-      return { ok: false, state: "Invalid", reason: `api-http-${res.status}`, source: "api" };
-    }
-
-    const data = await res.json();
-    return {
-      ok: data.valid === true,
-      state: data.state || "Invalid",
-      reason: data.reason || "api-response",
-      expiresAt: data.expiresAt || null,
-      source: "api",
-    };
-  } catch (err) {
-    // Network error, timeout, abort — fall through to offline
-    return { ok: false, state: "Unknown", reason: `api-error: ${err.message}`, source: "api-fallback" };
-  }
-}
-
-/**
- * Verify license offline (Ed25519 signature check).
- * Returns: { ok: boolean, state: string, reason: string, expiresAt?: string, source: "offline" }
- */
-function verifyOffline(licenseKey) {
-  const state = assessLicenseState(licenseKey);
-  return {
-    ok: state.state === "Active" || state.state === "Grace",
-    state: state.state,
-    reason: state.reason,
-    expiresAt: state.expiresAt || null,
-    graceUntil: state.graceUntil || null,
-    source: "offline",
-  };
-}
-
-/**
- * Combined verification: API-first, offline fallback.
- * Always returns a result — never throws.
- */
-async function verifyLicense(licenseKey) {
-  // Step 1: Try API (unless explicitly disabled)
-  if (process.env.TERA_OFFLINE_ONLY === "1") {
-    return verifyOffline(licenseKey);
-  }
-
-  const apiResult = await verifyViaAPI(licenseKey);
-
-  // If API succeeded and gave a definitive answer, use it
-  if (apiResult.source === "api" && apiResult.ok !== undefined) {
-    return apiResult;
-  }
-
-  // Step 2: Fallback to offline
-  const offlineResult = verifyOffline(licenseKey);
-
-  // If offline confirms API's failure, use offline (more trusted)
-  if (!apiResult.ok && !offlineResult.ok) {
-    return offlineResult;
-  }
-
-  // If API failed but offline says active, trust offline (API might be down)
-  if (!apiResult.ok && offlineResult.ok) {
-    return { ...offlineResult, reason: `offline-verified (api-unavailable: ${apiResult.reason})` };
-  }
-
-  // Default: trust API
-  return apiResult;
-}
-
-/* ------------------- server sync → integrity → license ------------------- */
-const SYNC_URL = process.env.TERA_SYNC_URL || "https://teranoo.com/api/tera-system/bundle";
-
-/**
- * Attempt server sync (best-effort, never breaks install).
- * Downloads the signed bundle, verifies signature + hashes, and applies.
- * If unreachable/rejected → bundled content remains (thick mode).
- */
-async function tryServerSync() {
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 8000);
-    const res = await fetch(SYNC_URL, { signal: controller.signal });
-    clearTimeout(timeout);
-    if (!res.ok) {
-      console.log(`  [sync    ] server HTTP ${res.status} — using bundled content`);
-      return false;
-    }
-    const bundle = await res.json();
-    const v = verifyBundle(bundle);
-    if (!v.ok) {
-      console.log(`  [sync    ] bundle rejected (${v.reason}) — using bundled content`);
-      return false;
-    }
-    const r = applyBundle(bundle, target);
-    console.log(`  [sync    ] server bundle applied — ${r.applied} files (signed & verified)`);
-    return true;
-  } catch {
-    console.log(`  [sync    ] server unreachable — using bundled content`);
-    return false;
-  }
-}
-
-// Run: sync → integrity manifest → license check (async wrapper, non-blocking)
-(async () => {
-  try {
-    // Step 1: best-effort server sync (self-healing / fresh content)
-    await tryServerSync();
-
-    // Step 2: integrity manifest (after sync, covers server files too)
-    try {
-      const integrityManifest = createIntegrityManifest(target);
-      saveIntegrityManifest(target, integrityManifest);
-      console.log(`  [integrity] manifest created (${integrityManifest.fileCount} files tracked)`);
-    } catch (err) {
-      console.log(`  [integrity] skipped (${err.message}) — install continues`);
-    }
-
-    // Step 3: license verification (API-first, offline fallback)
-    const stateFile = path.join(target, ".tera", "license.state.json");
-    let licenseKey = (readLicenseState(stateFile) || {}).licenseKey;
-    if (!licenseKey) licenseKey = process.env.TERA_LICENSE_KEY || undefined;
-
-    const result = await verifyLicense(licenseKey);
-
-    writeLicenseState(stateFile, {
-      state: result.state,
-      reason: result.reason,
-      licenseKey: licenseKey || null,
-      expiresAt: result.expiresAt || null,
-      graceUntil: result.graceUntil || null,
-      source: result.source,
-      checkedAt: new Date().toISOString(),
-    });
-
-    const sourceTag = result.source === "api" ? "☁️" : result.source === "offline" ? "🔒" : "🔄";
-    console.log(`  [license ] ${sourceTag} state=${result.state} (${result.reason})`);
-  } catch (err) {
-    console.log(`  [license ] skipped (${err.message}) — install continues`);
-  }
-
-  // final summary (printed after sync/integrity/license complete)
-  console.log("\n  summary:");
-  console.log(`    installed : ${stats.installed}`);
-  console.log(`    updated   : ${stats.updated}`);
-  console.log(`    identical : ${stats.identical}`);
-  console.log(`    conflicts : ${stats.conflicts.length} (your files kept untouched)`);
-  console.log(`    skipped   : ${stats.skippedGroups} group(s) — user-owned state`);
-  console.log(`  ownership log : ${path.join(".opencode", MANIFEST_NAME)}\n`);
-
-  if (stats.conflicts.length > 0) {
-    console.log("  ⚠ conflicts — your files were kept. Review them before relying on Tera content.");
-    process.exitCode = 0;
-  }
-})();
+#!/usr/bin/env node
+/**
+ * @tera/core installer
+ * --------------------------------------------------------------
+ * NON-DESTRUCTIVE + OWNERSHIP-AWARE installer for the Tera System
+ * OpenCode Plugin component.
+ *
+ * Rules:
+ *  - Never deletes anything.
+ *  - Never overwrites a file it does not own.
+ *  - Tracks ownership via `.opencode/tera-core.manifest.json`.
+ *  - Only updates files it owns, always keeping a backup first.
+ *  - Idempotent: re-running is safe; identical files are skipped.
+ *  - Never touches an existing user `opencode.json`.
+ *
+ * Target resolution (first match wins):
+ *   1. `--target <dir>` argument
+ *   2. `TERA_TARGET_DIR` environment variable
+ *   3. `INIT_CWD` (set by npm for lifecycle scripts)
+ *   4. current working directory
+ */
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { assessLicenseState, readLicenseState, writeLicenseState } from "./lib/license.mjs";
+import { createIntegrityManifest, saveIntegrityManifest } from "./lib/integrity.mjs";
+import { verifyBundle, applyBundle } from "./lib/bundle.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = path.resolve(__dirname, "..");
+const MANIFEST_NAME = "tera-core.manifest.json";
+const CONFIG_EXAMPLE = "opencode.tera.example.json";
+
+/* ---------------------------------- helpers ---------------------------------- */
+
+const sha256 = (buf) => createHash("sha256").update(buf).digest("hex");
+
+const toPosix = (p) => p.split(path.sep).join("/");
+
+function resolveTarget() {
+  const args = process.argv.slice(2);
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--help") {
+      console.log("Usage: node scripts/install.js [--target <workspaceRoot>]");
+      process.exit(0);
+    }
+    if (args[i] === "--target" && args[i + 1]) {
+      return path.resolve(args[i + 1]);
+    }
+  }
+  if (process.env.TERA_TARGET_DIR) return path.resolve(process.env.TERA_TARGET_DIR);
+  if (process.env.INIT_CWD) return path.resolve(process.env.INIT_CWD);
+  return path.resolve(process.cwd());
+}
+
+function walkFiles(dir) {
+  const out = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...walkFiles(full));
+    else if (entry.isFile()) out.push(full);
+  }
+  return out;
+}
+
+function copyFile(src, dest) {
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+function loadOwnership(target) {
+  const p = path.join(target, ".opencode", MANIFEST_NAME);
+  if (!fs.existsSync(p)) return { files: {} };
+  try {
+    const parsed = JSON.parse(fs.readFileSync(p, "utf8"));
+    return { files: parsed.files && typeof parsed.files === "object" ? parsed.files : {} };
+  } catch {
+    return { files: {} };
+  }
+}
+
+/* ---------------------------------- state ---------------------------------- */
+
+const target = resolveTarget();
+const pkg = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf8"));
+const ownership = loadOwnership(target);
+
+const stats = { installed: 0, updated: 0, identical: 0, adopted: 0, skippedGroups: 0, conflicts: [] };
+
+/* ------------------------------- group install ------------------------------- */
+
+/**
+ * @param {{name:string, src:string, dest:string}} group
+ */
+function installGroup(group) {
+  if (!fs.existsSync(group.src)) return;
+  for (const srcFile of walkFiles(group.src)) {
+    const relSrc = path.relative(group.src, srcFile);
+    const destFile = path.join(group.dest, relSrc);
+    const destRel = toPosix(path.relative(target, destFile));
+    const srcHash = sha256(fs.readFileSync(srcFile));
+
+    if (fs.existsSync(destFile)) {
+      const destHash = sha256(fs.readFileSync(destFile));
+      if (destHash === srcHash) {
+        // Identical content — adopt ownership if not already owned.
+        // (byte-identical file = package content, so it is safe to claim it.)
+        if (!Object.prototype.hasOwnProperty.call(ownership.files, destRel)) {
+          ownership.files[destRel] = srcHash;
+          stats.adopted++;
+          console.log(`  [adopt   ] ${destRel} — identical, now owned by package`);
+        } else {
+          stats.identical++;
+        }
+        continue;
+      }
+      const owned = Object.prototype.hasOwnProperty.call(ownership.files, destRel);
+      if (owned) {
+        const bak = `${destFile}.tera-bak-${Date.now()}`;
+        fs.copyFileSync(destFile, bak);
+        fs.copyFileSync(srcFile, destFile);
+        ownership.files[destRel] = srcHash;
+        stats.updated++;
+        console.log(`  [updated ] ${destRel}  (backup: ${path.basename(bak)})`);
+      } else {
+        stats.conflicts.push(destRel);
+        console.log(`  [CONFLICT] ${destRel} — kept your file (unowned, not overwritten).`);
+      }
+    } else {
+      copyFile(srcFile, destFile);
+      ownership.files[destRel] = srcHash;
+      stats.installed++;
+      console.log(`  [install ] ${destRel}`);
+    }
+  }
+}
+
+/* ---------------------------------- config ---------------------------------- */
+
+function installConfig() {
+  const configSrc = path.join(PKG_ROOT, CONFIG_EXAMPLE);
+  if (!fs.existsSync(configSrc)) return;
+  const configDest = path.join(target, ".opencode", "opencode.json");
+  const configRel = ".opencode/opencode.json";
+
+  if (fs.existsSync(configDest)) {
+    const a = sha256(fs.readFileSync(configDest));
+    const b = sha256(fs.readFileSync(configSrc));
+    if (a === b) {
+      stats.identical++;
+      console.log(`  [same    ] ${configRel} — already identical.`);
+    } else {
+      stats.conflicts.push(configRel);
+      console.log(`  [CONFLICT] ${configRel} — kept yours. Reference copy provided below.`);
+    }
+  } else {
+    copyFile(configSrc, configDest);
+    ownership.files[configRel] = sha256(fs.readFileSync(configDest));
+    stats.installed++;
+    console.log(`  [install ] ${configRel}`);
+  }
+
+  // Additive reference copy — always written, never destructive.
+  const exampleDest = path.join(target, ".opencode", CONFIG_EXAMPLE);
+  copyFile(configSrc, exampleDest);
+  console.log(`  [reference] .opencode/${CONFIG_EXAMPLE}`);
+}
+
+/* ------------------------------ project-control ------------------------------ */
+
+function installProjectControl() {
+  const pcSrc = path.join(PKG_ROOT, "core", "project-control");
+  if (!fs.existsSync(pcSrc)) return;
+  const pcDest = path.join(target, "project-control");
+  if (fs.existsSync(pcDest)) {
+    stats.skippedGroups++;
+    console.log("  [SKIP    ] project-control/ — exists (user-owned state). Skeleton not installed.");
+    return;
+  }
+  for (const f of walkFiles(pcSrc)) {
+    const relF = toPosix(path.relative(pcSrc, f));
+    const d = path.join(pcDest, relF);
+    copyFile(f, d);
+    ownership.files[`project-control/${relF}`] = sha256(fs.readFileSync(f));
+    stats.installed++;
+    console.log(`  [install ] project-control/${relF}`);
+  }
+}
+
+/* ----------------------------------- run ----------------------------------- */
+
+console.log(`\n@tera/core v${pkg.version} — install`);
+console.log(`  target workspace : ${target}\n`);
+
+installGroup({ name: "agents", src: path.join(PKG_ROOT, "agents"), dest: path.join(target, ".opencode", "agents") });
+installGroup({ name: "commands", src: path.join(PKG_ROOT, "commands"), dest: path.join(target, ".opencode", "commands") });
+installGroup({ name: "tera-system", src: path.join(PKG_ROOT, "core", "tera-system"), dest: path.join(target, "tera-system") });
+installGroup({ name: "tools", src: path.join(PKG_ROOT, "tools"), dest: path.join(target, "tools") });
+installGroup({ name: "scripts", src: path.join(PKG_ROOT, "scripts"), dest: path.join(target, "scripts") });
+installConfig();
+installProjectControl();
+
+/* -------------------------------- persist log -------------------------------- */
+
+const manifest = {
+  name: pkg.name,
+  version: pkg.version,
+  installedAt: new Date().toISOString(),
+  target,
+  files: ownership.files,
+  conflicts: stats.conflicts,
+  summary: {
+    installed: stats.installed,
+    updated: stats.updated,
+    identical: stats.identical,
+    adopted: stats.adopted,
+    skippedGroups: stats.skippedGroups,
+    conflicts: stats.conflicts.length,
+  },
+};
+
+const manifestPath = path.join(target, ".opencode", MANIFEST_NAME);
+fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+/* ------------------- license state (non-blocking, never breaks install) ------------------- */
+
+/**
+ * License verification with API-first strategy + offline fallback.
+ *
+ * Flow:
+ *   1. Try online API verification (if API URL is configured)
+ *   2. On API failure → fallback to offline Ed25519 verification
+ *   3. Never blocks install — always continues
+ *
+ * Environment variables:
+ *   TERA_LICENSE_API  — API base URL (e.g. https://teranoo.com/api/license)
+ *   TERA_LICENSE_KEY  — Manual license key override
+ */
+const LICENSE_API_URL = process.env.TERA_LICENSE_API || "https://teranoo.com/api/license";
+const LICENSE_TIMEOUT_MS = 5000; // 5 seconds max for API call
+
+/**
+ * Verify license via remote API (online).
+ * Returns: { ok: boolean, state: string, reason: string, expiresAt?: string, source: "api" }
+ */
+async function verifyViaAPI(licenseKey) {
+  if (!licenseKey) return { ok: false, state: "Unlicensed", reason: "no-key", source: "api" };
+
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), LICENSE_TIMEOUT_MS);
+
+    const res = await fetch(`${LICENSE_API_URL}/verify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ licenseKey }),
+      signal: controller.signal,
+    });
+    clearTimeout(timeout);
+
+    if (!res.ok) {
+      // Server responded with an error status (e.g. 404 while the endpoint is
+      // not implemented yet, or 5xx). This is NOT a definitive license verdict —
+      // treat it as "API unavailable" so the offline Ed25519 fallback runs.
+      return { ok: false, state: "Unknown", reason: `api-http-${res.status}`, source: "api-fallback" };
+    }
+
+    const data = await res.json();
+    return {
+      ok: data.valid === true,
+      state: data.state || "Invalid",
+      reason: data.reason || "api-response",
+      expiresAt: data.expiresAt || null,
+      source: "api",
+    };
+  } catch (err) {
+    // Network error, timeout, abort — fall through to offline
+    return { ok: false, state: "Unknown", reason: `api-error: ${err.message}`, source: "api-fallback" };
+  }
+}
+
+/**
+ * Verify license offline (Ed25519 signature check).
+ * Returns: { ok: boolean, state: string, reason: string, expiresAt?: string, source: "offline" }
+ */
+function verifyOffline(licenseKey) {
+  const state = assessLicenseState(licenseKey);
+  return {
+    ok: state.state === "Active" || state.state === "Grace",
+    state: state.state,
+    reason: state.reason,
+    expiresAt: state.expiresAt || null,
+    graceUntil: state.graceUntil || null,
+    source: "offline",
+  };
+}
+
+/**
+ * Combined verification: API-first, offline fallback.
+ * Always returns a result — never throws.
+ */
+async function verifyLicense(licenseKey) {
+  // Step 1: Try API (unless explicitly disabled)
+  if (process.env.TERA_OFFLINE_ONLY === "1") {
+    return verifyOffline(licenseKey);
+  }
+
+  const apiResult = await verifyViaAPI(licenseKey);
+
+  // If API succeeded and gave a definitive answer, use it
+  if (apiResult.source === "api" && apiResult.ok !== undefined) {
+    return apiResult;
+  }
+
+  // Step 2: Fallback to offline
+  const offlineResult = verifyOffline(licenseKey);
+
+  // If offline confirms API's failure, use offline (more trusted)
+  if (!apiResult.ok && !offlineResult.ok) {
+    return offlineResult;
+  }
+
+  // If API failed but offline says active, trust offline (API might be down)
+  if (!apiResult.ok && offlineResult.ok) {
+    return { ...offlineResult, reason: `offline-verified (api-unavailable: ${apiResult.reason})` };
+  }
+
+  // Default: trust API
+  return apiResult;
+}
+
+/* ------------------- server sync → integrity → license ------------------- */
+const SYNC_URL = process.env.TERA_SYNC_URL || "https://teranoo.com/api/tera-system/bundle";
+
+/**
+ * Attempt server sync (best-effort, never breaks install).
+ * Downloads the signed bundle, verifies signature + hashes, and applies.
+ * If unreachable/rejected → bundled content remains (thick mode).
+ */
+async function tryServerSync() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 8000);
+    const res = await fetch(SYNC_URL, { signal: controller.signal });
+    clearTimeout(timeout);
+    if (!res.ok) {
+      console.log(`  [sync    ] server HTTP ${res.status} — using bundled content`);
+      return false;
+    }
+    const bundle = await res.json();
+    const v = verifyBundle(bundle);
+    if (!v.ok) {
+      console.log(`  [sync    ] bundle rejected (${v.reason}) — using bundled content`);
+      return false;
+    }
+    const r = applyBundle(bundle, target);
+    console.log(`  [sync    ] server bundle applied — ${r.applied} files (signed & verified)`);
+    return true;
+  } catch {
+    console.log(`  [sync    ] server unreachable — using bundled content`);
+    return false;
+  }
+}
+
+// Run: sync → integrity manifest → license check (async wrapper, non-blocking)
+(async () => {
+  try {
+    // Step 1: best-effort server sync (self-healing / fresh content)
+    await tryServerSync();
+
+    // Step 2: integrity manifest (after sync, covers server files too)
+    try {
+      const integrityManifest = createIntegrityManifest(target);
+      saveIntegrityManifest(target, integrityManifest);
+      console.log(`  [integrity] manifest created (${integrityManifest.fileCount} files tracked)`);
+    } catch (err) {
+      console.log(`  [integrity] skipped (${err.message}) — install continues`);
+    }
+
+    // Step 3: license verification (API-first, offline fallback)
+    const stateFile = path.join(target, ".tera", "license.state.json");
+    let licenseKey = (readLicenseState(stateFile) || {}).licenseKey;
+    if (!licenseKey) licenseKey = process.env.TERA_LICENSE_KEY || undefined;
+
+    const result = await verifyLicense(licenseKey);
+
+    writeLicenseState(stateFile, {
+      state: result.state,
+      reason: result.reason,
+      licenseKey: licenseKey || null,
+      expiresAt: result.expiresAt || null,
+      graceUntil: result.graceUntil || null,
+      source: result.source,
+      checkedAt: new Date().toISOString(),
+    });
+
+    const sourceTag = result.source === "api" ? "☁️" : result.source === "offline" ? "🔒" : "🔄";
+    console.log(`  [license ] ${sourceTag} state=${result.state} (${result.reason})`);
+  } catch (err) {
+    console.log(`  [license ] skipped (${err.message}) — install continues`);
+  }
+
+  // final summary (printed after sync/integrity/license complete)
+  console.log("\n  summary:");
+  console.log(`    installed : ${stats.installed}`);
+  console.log(`    updated   : ${stats.updated}`);
+  console.log(`    identical : ${stats.identical}`);
+  console.log(`    adopted   : ${stats.adopted} (pre-existing identical files now owned)`);
+  console.log(`    conflicts : ${stats.conflicts.length} (your files kept untouched)`);
+  console.log(`    skipped   : ${stats.skippedGroups} group(s) — user-owned state`);
+  console.log(`  ownership log : ${path.join(".opencode", MANIFEST_NAME)}\n`);
+
+  if (stats.conflicts.length > 0) {
+    console.log("  ⚠ conflicts — your files were kept. Review them before relying on Tera content.");
+    process.exitCode = 0;
+  }
+})();