@axiomantic/garden 0.1.2 → 0.1.4

package/README.md

@@ -67,24 +67,51 @@ Garden is organized into a clean, batteries-included catalog of self-explanatory
 | **[`plan-implementation`](skills/plan-implementation/SKILL.md)** | **Master Scheduling** | Authors `implementation_plan.md` defining task assignment matrices, `rhizo` distributed fencing locks, `vine` strand workflows, dynamic markdown checkboxes, harness To-Do integration, and emergent design addenda. |
 | **[`orchestrate-swarm`](skills/orchestrate-swarm/SKILL.md)** | **Main-Chat Governor** | Governs execution from the primary chat session: dispatches tasks over Redis, tracks heartbeats, ratifies emergent design addenda, verifies Two-Key gate passes, and triggers `vine weave`. |
 
+## Standalone Yet Designed for the Axiomantic Triad
+
+Garden is completely standalone and can direct multi-agent dialectics, persona selection, and tmux worker swarms on any codebase.
+
+However, Garden is designed from the ground up to pair seamlessly with **Rhizo** and **Vine**:
+- [**Rhizo**](https://github.com/axiomantic/rhizo) (Transport & Concurrency): Inter-agent messaging bus, monotonic fencing locks, and task queues over Redis.
+- [**Vine**](https://github.com/axiomantic/vine) (Workspaces & Verification): Sub-second APFS Copy-on-Write strands, polyglot build-cache normalization, and the Two-Key integration gate (`git merge-tree` mechanical + compiler/test suite semantic checks).
+- **Garden** (Swarm Ceremonies): Tmux worker fleet provisioning, 3-stage empirical dialectical pump (research, architecture, audit), and master ceremonial implementation planning.
+
 ---
 
 ## Installation
 
-### 1. For AI Coding Assistants (Interactive Skill Setup)
-Install the Garden skills into your coding assistants (Claude Code, Antigravity, Cursor, etc.):
+### 1. For AI Coding Assistants (Recommended)
+
+Install the skills globally (`-g`) across all your coding assistants (Claude Code, Antigravity, Cursor, Codex, OpenCode, etc.):
+
 ```bash
-npx skills add axiomantic/garden
+# Recommended: Install the complete multi-agent triad globally
+npx skills add -g axiomantic/rhizo
+npx skills add -g axiomantic/vine
+npx skills add -g axiomantic/garden
+```
+
+*(Each skill automatically self-bootstraps its native CLI binary if it is not already installed on your system).*
+
+To install only Garden (includes the 6 Garden skills):
+```bash
+npx skills add -g axiomantic/garden
 ```
-*(Launches the interactive selector to choose which skills and which agents to equip. Self-bootstraps Rhizo & Vine automatically).*
 
 ### 2. Standalone CLI Installation
-Install the compiled CLI tool directly onto your `$PATH`:
+
+Install the compiled CLI tools directly onto your `$PATH`:
+
 ```bash
+# Install all three tools:
+npm install -g @axiomantic/rhizo @axiomantic/vine @axiomantic/garden
+
+# Or install Garden alone:
 npm install -g @axiomantic/garden
 ```
 
 ### 3. Repository Coordination Guide
+
 Install the Garden multi-agent swarm coordination protocol directly into any project's `AGENTS.md`:
 ```bash
 garden guide install

package/SKILL.md

@@ -8,6 +8,18 @@ description: "Master entrypoint and end-to-end ceremony director for multi-agent
 > **The Sovereign Orchestration Layer for Autonomous AI Swarms**  
 > *Where `rhizo` is the transport nervous system and `vine` is the workspace integrator, `garden` is the institutional intellect, deliberation crucible, and master ceremony conductor.*
 
+## 0. Prerequisite & Automatic Bootstrapping
+
+All swarm ceremonies require the native `garden` CLI. If `command -v garden` fails, immediately install it:
+```bash
+npm install -g @axiomantic/garden
+```
+Or install the full coordination triad:
+```bash
+npm install -g @axiomantic/rhizo @axiomantic/vine @axiomantic/garden
+```
+Once installed, `garden` is available on `$PATH` and provisions architecture-appropriate binaries automatically.
+
 ---
 
 ## 1. Architectural Architecture & Layering

package/bin/run.js

@@ -1,31 +1,139 @@
 #!/usr/bin/env node
 const fs = require('fs');
 const path = require('path');
-const { spawnSync } = require('child_process');
+const os = require('os');
+const { spawnSync, execSync } = require('child_process');
 
-function findBinary() {
+const PKG_NAME = 'garden';
+const REPO = `axiomantic/${PKG_NAME}`;
+const VERSION = require('../package.json').version;
+
+function isCompatibleBinary(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return false;
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile() || stat.size < 64) return false;
+
+    const fd = fs.openSync(filePath, 'r');
+    const buf = Buffer.alloc(64);
+    fs.readSync(fd, buf, 0, 64, 0);
+    fs.closeSync(fd);
+
+    const platform = process.platform;
+    const arch = process.arch;
+
+    if (platform === 'darwin') {
+      const isMachO64 = (buf[0] === 0xcf && buf[1] === 0xfa && buf[2] === 0xed && buf[3] === 0xfe);
+      const isFatMachO = (buf[0] === 0xca && buf[1] === 0xfe && buf[2] === 0xba && buf[3] === 0xbe);
+      if (isFatMachO) return true;
+      if (!isMachO64) return false;
+      const cpuType = buf.readInt32LE(4);
+      if (arch === 'arm64' && cpuType === 0x0100000c) return true;
+      if (arch === 'x64' && cpuType === 0x01000007) return true;
+      return false;
+    }
+
+    if (platform === 'linux') {
+      const isELF = buf[0] === 0x7f && buf[1] === 0x45 && buf[2] === 0x4c && buf[3] === 0x46;
+      if (!isELF) return false;
+      const is64Bit = buf[4] === 2;
+      if (!is64Bit) return false;
+      const machine = buf.readUInt16LE(18);
+      if (arch === 'x64' && machine === 62) return true; // EM_X86_64
+      if (arch === 'arm64' && machine === 183) return true; // EM_AARCH64
+      return false;
+    }
+
+    if (platform === 'win32') {
+      return buf[0] === 0x4d && buf[1] === 0x5a;
+    }
+
+    return false;
+  } catch (_) {
+    return false;
+  }
+}
+
+function resolveBinary() {
   const ext = process.platform === 'win32' ? '.exe' : '';
-  const arch = process.arch;
-  const platform = process.platform;
+  const arch = process.arch === 'arm64' ? 'arm64' : 'amd64';
+  const platform = process.platform === 'darwin' ? 'darwin' : (process.platform === 'linux' ? 'linux' : 'windows');
 
-  for (const name of ['garden']) {
-    const directBin = path.join(__dirname, `${name}${ext}`);
-    if (fs.existsSync(directBin)) return directBin;
+  // 1. Check local/bundled locations (Fat-Package and local builds)
+  const candidates = [
+    path.join(__dirname, 'binaries', `${PKG_NAME}-${process.platform}-${process.arch}${ext}`),
+    path.join(__dirname, 'binaries', `${PKG_NAME}-${process.platform}-${process.arch === 'x64' ? 'amd64' : process.arch}${ext}`),
+    path.join(__dirname, `${PKG_NAME}-${process.platform}-${process.arch}${ext}`),
+    path.join(__dirname, `${PKG_NAME}${ext}`),
+    path.join(__dirname, '..', 'vendor', 'bin', `${PKG_NAME}${ext}`),
+  ];
 
-    const platformBin = path.join(__dirname, `${name}-${platform}-${arch}${ext}`);
-    if (fs.existsSync(platformBin)) return platformBin;
+  for (const cand of candidates) {
+    if (isCompatibleBinary(cand)) {
+      try { fs.chmodSync(cand, 0o755); } catch (_) {}
+      return cand;
+    }
+  }
+
+  // 2. Check user cache directory (~/.cache/<pkg>/bin/<pkg>)
+  const cacheBase = process.env.XDG_CACHE_HOME || (
+    process.platform === 'win32'
+      ? (process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'))
+      : path.join(os.homedir(), '.cache')
+  );
+  const cacheBinDir = path.join(cacheBase, PKG_NAME, 'bin');
+  const cachedBin = path.join(cacheBinDir, `${PKG_NAME}${ext}`);
+
+  if (isCompatibleBinary(cachedBin)) {
+    return cachedBin;
+  }
+
+  // 3. Auto-download from GitHub releases
+  const assetExt = process.platform === 'win32' ? '.zip' : '.tar.gz';
+  const assetName = `${PKG_NAME}-${platform}-${arch}${assetExt}`;
+  const downloadUrl = `https://github.com/${REPO}/releases/download/v${VERSION}/${assetName}`;
+
+  try {
+    fs.mkdirSync(cacheBinDir, { recursive: true });
+    process.stderr.write(`[@axiomantic/${PKG_NAME}] Downloading native binary for ${platform}-${arch} from GitHub Releases...\n`);
+
+    if (process.platform === 'win32') {
+      const zipPath = path.join(cacheBinDir, assetName);
+      execSync(`powershell -Command "Invoke-WebRequest -Uri '${downloadUrl}' -OutFile '${zipPath}'; Expand-Archive -Path '${zipPath}' -DestinationPath '${cacheBinDir}' -Force; Remove-Item '${zipPath}'"`, { stdio: 'inherit' });
+    } else {
+      execSync(`curl -fsSL "${downloadUrl}" | tar -xzf - -C "${cacheBinDir}"`, { stdio: 'inherit' });
+    }
+
+    if (isCompatibleBinary(cachedBin)) {
+      try { fs.chmodSync(cachedBin, 0o755); } catch (_) {}
+      return cachedBin;
+    }
+  } catch (err) {
+    process.stderr.write(`[@axiomantic/${PKG_NAME}] Automatic download failed: ${err.message}\n`);
+  }
 
-    const vendorBin = path.join(__dirname, '..', 'vendor', 'bin', `${name}${ext}`);
-    if (fs.existsSync(vendorBin)) return vendorBin;
+  // 4. Fallback: compile from local source if nim is available
+  const srcFile = path.join(__dirname, '..', 'src', `${PKG_NAME}.nim`);
+  if (fs.existsSync(srcFile)) {
+    try {
+      execSync('which nim', { stdio: 'ignore' });
+      process.stderr.write(`[@axiomantic/${PKG_NAME}] Building from source via Nim compiler...\n`);
+      fs.mkdirSync(cacheBinDir, { recursive: true });
+      execSync(`nim c -d:release --opt:speed -o:"${cachedBin}" "${srcFile}"`, { stdio: 'inherit' });
+      if (isCompatibleBinary(cachedBin)) {
+        try { fs.chmodSync(cachedBin, 0o755); } catch (_) {}
+        return cachedBin;
+      }
+    } catch (_) {}
   }
 
   return null;
 }
 
-const binPath = findBinary();
+const binPath = resolveBinary();
 if (!binPath) {
-  console.error(`Error: @axiomantic/garden native binary not found for ${process.platform}-${process.arch}.`);
-  console.error(`Please visit https://github.com/axiomantic/garden/releases to download.`);
+  console.error(`\nError: @axiomantic/${PKG_NAME} native binary not found or incompatible with ${process.platform}-${process.arch}.`);
+  console.error(`Please visit https://github.com/${REPO}/releases to download, or install Nim (https://nim-lang.org) to compile from source.`);
   process.exit(1);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiomantic/garden",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Multi-Agent Swarm Orchestration, Empirical Dialectics & Ceremonies on top of Rhizo & Vine",
   "main": "bin/run.js",
   "bin": {
@@ -8,7 +8,8 @@
   },
   "skills": "./skills",
   "files": [
-    "bin/",
+    "bin/run.js",
+    "bin/binaries/",
     "scripts/",
     "skills/",
     "SKILL.md",

package/skills/garden/SKILL.md

@@ -8,6 +8,18 @@ description: "Master entrypoint and end-to-end ceremony director for multi-agent
 > **The Sovereign Orchestration Layer for Autonomous AI Swarms**  
 > *Where `rhizo` is the transport nervous system and `vine` is the workspace integrator, `garden` is the institutional intellect, deliberation crucible, and master ceremony conductor.*
 
+## 0. Prerequisite & Automatic Bootstrapping
+
+All swarm ceremonies require the native `garden` CLI. If `command -v garden` fails, immediately install it:
+```bash
+npm install -g @axiomantic/garden
+```
+Or install the full coordination triad:
+```bash
+npm install -g @axiomantic/rhizo @axiomantic/vine @axiomantic/garden
+```
+Once installed, `garden` is available on `$PATH` and provisions architecture-appropriate binaries automatically.
+
 ---
 
 ## 1. Architectural Architecture & Layering