Merge PR #4: R6 — reconcile dev↔main, ship Zig binaries, retire JS

feat(zig): R6 — reconcile dev↔main, ship Zig binaries, retire independent JS

Author: Eugene3dotdev

.github/workflows/release-binaries.yml

@@ -0,0 +1,158 @@
+name: Release binaries
+
+# On a version tag (v*), cross-compile the ponytail Zig runtime binaries for
+# every supported platform, generate SHA-256 checksums, and attach them to the
+# GitHub Release. install.sh downloads the right per-platform archive and
+# SHA-256-verifies it (R6.2) — no Node, no Zig toolchain required by end users.
+#
+# Mirrors caveman's release-binaries.yml, minus the caveman/ponytail tool matrix
+# (ponytail's build only produces the `ponytail` tool) and minus the `*-claw`
+# exclude (ponytail has no claw test binary).
+#
+# Windows is deferred (R6-Windows: stdio/subprocess/argv libc → std.Io). The PS1
+# shim covers Windows until then, so this workflow ships macOS + Linux only.
+
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Tag to build (for manual re-runs), e.g. v1.2.3"
+        required: true
+
+# No workflow-level write scope — each job requests only the permissions it needs
+# (least privilege). The build and checksums jobs both opt into contents: write
+# locally because they attach assets to the Release.
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: [self-hosted, linux]
+    permissions:
+      contents: write # this job attaches assets to the Release
+    strategy:
+      fail-fast: false
+      matrix:
+        target:
+          - { triple: aarch64-macos, name: macos-arm64 }
+          - { triple: x86_64-macos, name: macos-x64 }
+          - { triple: x86_64-linux-gnu, name: linux-x64 }
+          - { triple: aarch64-linux-gnu, name: linux-arm64 }
+    steps:
+      - uses: actions/checkout@v4
+
+      # Resolve + validate the tag once, before any use. A manual workflow_dispatch
+      # `tag` input is attacker-influenced free text that flows into shell commands
+      # and the gh CLI; constrain it to the v<semver> shape this workflow ships so a
+      # crafted value (spaces, $(...), ;, ../) can't smuggle anything downstream.
+      - name: Resolve and validate release tag
+        id: tag
+        env:
+          RAW_TAG: ${{ github.event.inputs.tag || github.ref_name }}
+        run: |
+          set -euo pipefail
+          if [[ ! "$RAW_TAG" =~ ^v[0-9]+\.[0-9]+\.[0-9]+([-+][0-9A-Za-z.-]+)?$ ]]; then
+            echo "::error::Refusing to build: tag '$RAW_TAG' is not a v<semver> tag" >&2
+            exit 1
+          fi
+          echo "tag=$RAW_TAG" >> "$GITHUB_OUTPUT"
+
+      - name: Cross-compile ponytail for ${{ matrix.target.triple }}
+        run: |
+          nix develop --command bash -c "cd zig && zig build -Dtool=ponytail -Dtarget=${{ matrix.target.triple }} -Doptimize=ReleaseSafe"
+
+      - name: Package archive + checksum
+        id: pkg
+        env:
+          PLAT: ${{ matrix.target.name }}
+        run: |
+          set -euo pipefail
+          stage="dist/ponytail-$PLAT"
+          mkdir -p "$stage"
+
+          # The full set of runtime binaries this release must ship. If the build
+          # silently dropped one (e.g. a build.zig regression), packaging an
+          # incomplete archive would ship a broken release that install.sh / the
+          # launcher can't resolve — so assert every expected binary is present
+          # BEFORE we tar anything.
+          expected=(ponytail-activate ponytail-hook ponytail-instructions ponytail-mcp ponytail-statusline)
+          for name in "${expected[@]}"; do
+            if [[ ! -x "zig/zig-out/bin/$name" ]]; then
+              echo "::error::Missing expected runtime binary: zig/zig-out/bin/$name" >&2
+              exit 1
+            fi
+          done
+
+          # Ship the runtime binaries only; defensively skip any .pdb.
+          for f in zig/zig-out/bin/ponytail-*; do
+            base="$(basename "$f")"
+            case "$base" in *.pdb) continue;; esac
+            cp "$f" "$stage/"
+          done
+
+          archive="ponytail-$PLAT.tar.gz"
+          tar -C "$stage" -czf "dist/$archive" .
+          ( cd dist && sha256sum "$archive" > "$archive.sha256" )
+          echo "archive=dist/$archive" >> "$GITHUB_OUTPUT"
+          echo "checksum=dist/$archive.sha256" >> "$GITHUB_OUTPUT"
+
+      - name: Upload to Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ steps.tag.outputs.tag }}
+          files: |
+            ${{ steps.pkg.outputs.archive }}
+            ${{ steps.pkg.outputs.checksum }}
+          fail_on_unmatched_files: true
+
+  # Aggregate a single SHA256SUMS manifest across all archives (install.sh reads
+  # the per-archive .sha256 sidecar; this manifest is for humans + auditing).
+  checksums:
+    needs: build
+    runs-on: [self-hosted, linux]
+    permissions:
+      contents: write # this job uploads the aggregate manifest to the Release
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Resolve and validate release tag
+        id: tag
+        env:
+          RAW_TAG: ${{ github.event.inputs.tag || github.ref_name }}
+        run: |
+          set -euo pipefail
+          if [[ ! "$RAW_TAG" =~ ^v[0-9]+\.[0-9]+\.[0-9]+([-+][0-9A-Za-z.-]+)?$ ]]; then
+            echo "::error::Refusing to publish: tag '$RAW_TAG' is not a v<semver> tag" >&2
+            exit 1
+          fi
+          echo "tag=$RAW_TAG" >> "$GITHUB_OUTPUT"
+
+      - name: Collect per-archive checksums into SHA256SUMS
+        env:
+          TAG: ${{ steps.tag.outputs.tag }}
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+        run: |
+          set -euo pipefail
+          mkdir -p dist
+          gh release download "$TAG" --pattern '*.sha256' --dir dist --repo "$REPO"
+
+          # Refuse to publish an empty manifest: if no per-archive .sha256 sidecars
+          # were downloaded, the build job produced nothing and uploading an empty
+          # SHA256SUMS would advertise a release with no verifiable artifacts.
+          shopt -s nullglob
+          sidecars=(dist/*.sha256)
+          if (( ${#sidecars[@]} == 0 )); then
+            echo "::error::No per-archive .sha256 sidecars found for $TAG — refusing to publish an empty SHA256SUMS" >&2
+            exit 1
+          fi
+
+          cat "${sidecars[@]}" > dist/SHA256SUMS
+          if [[ ! -s dist/SHA256SUMS ]]; then
+            echo "::error::SHA256SUMS is empty after aggregation — refusing to publish" >&2
+            exit 1
+          fi
+
+          gh release upload "$TAG" dist/SHA256SUMS --clobber --repo "$REPO"

benchmarks/robustness-audit.js

@@ -8,6 +8,17 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
+// ponytail: probe once at load; mirrors correctness.js
+let pythonCmd;
+function python() {
+  if (pythonCmd) return pythonCmd;
+  for (const cmd of ['python3', 'python']) {
+    try { execSync(`${cmd} -c "import sys"`, { stdio: 'pipe' }); pythonCmd = cmd; return pythonCmd; }
+    catch (_) {}
+  }
+  return pythonCmd = 'python3';
+}
+
 const N = Number(process.env.AUDIT_N) || 20;
 const MODEL = process.env.AUDIT_MODEL || 'gpt-5.4-mini';
 const ROOT = path.join(__dirname, '..');
@@ -136,7 +147,7 @@ for args, expected in cases:
 print('PASS')`;
   const f = path.join(os.tmpdir(), `audit-${process.pid}-${Math.random().toString(36).slice(2)}.py`);
   fs.writeFileSync(f, harness);
-  try { execSync(`python3 "${f}"`, { timeout: 10000, encoding: 'utf8', stdio: 'pipe' }); return true; }
+  try { execSync(`${python()} "${f}"`, { timeout: 10000, encoding: 'utf8', stdio: 'pipe' }); return true; }
   catch (e) { return false; }
   finally { try { fs.unlinkSync(f); } catch (_) {} }
 }

bin/ponytail-launch

@@ -0,0 +1,77 @@
+#!/usr/bin/env bash
+# ponytail-launch — resolve a ponytail Zig binary and exec it (passing stdin + args).
+#
+# Used by the Claude Code plugin (.claude-plugin/plugin.json) so the plugin can run
+# the native Zig hooks without bundling per-platform blobs: it finds an already-
+# installed binary, or a local build, or downloads+verifies the per-platform release
+# archive on first use (cached under $PONYTAIL_CACHE), then execs the requested binary.
+#
+# Usage:  ponytail-launch <binary-name> [args...]      (stdin is forwarded)
+#   e.g.  ponytail-launch ponytail-activate
+#         ponytail-launch ponytail-hook
+#
+# Resolution order:
+#   1. $CLAUDE_CONFIG_DIR/hooks/<name>        (standalone install dropped it here)
+#   2. <plugin-root>/zig/zig-out/bin/<name>   (local clone / dev build)
+#   3. $PONYTAIL_CACHE/<name>                 (previously downloaded)
+#   4. download ponytail-<plat>.tar.gz from the latest Release → SHA-256 verify →
+#      extract into $PONYTAIL_CACHE → use it
+#
+# Pure-Zig runtime: this launcher is host-automation shell, not application logic.
+set -uo pipefail
+
+REPO="EugOT/ponytail"
+NAME="${1:-}"
+[ -n "$NAME" ] || { echo "ponytail-launch: missing binary name" >&2; exit 2; }
+shift || true
+
+here="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" 2>/dev/null && pwd)" || here=""
+CACHE="${PONYTAIL_CACHE:-${XDG_CACHE_HOME:-$HOME/.cache}/ponytail/bin}"
+
+# exec the binary at $1 with all remaining launcher args ($@, already shifted past
+# the binary name) if it exists and is executable; otherwise return so the next
+# resolution step runs. stdin is inherited by exec, so hooks still read it.
+try_exec() { local b="$1"; shift; [ -x "$b" ] && exec "$b" "$@"; }
+
+# 1. standalone-installed hooks dir
+CFG="${CLAUDE_CONFIG_DIR:-$HOME/.claude}"
+try_exec "$CFG/hooks/$NAME" "$@"
+
+# 2. local clone / dev build (launcher lives at bin/, zig/ is a sibling at repo root)
+[ -n "$here" ] && try_exec "$here/../zig/zig-out/bin/$NAME" "$@"
+
+# 3. previously downloaded
+try_exec "$CACHE/$NAME" "$@"
+
+# 4. download + verify + cache
+detect_platform() {
+  local os arch; os="$(uname -s)"; arch="$(uname -m)"
+  case "$os" in Darwin) os=macos ;; Linux) os=linux ;; *) echo "ponytail-launch: unsupported OS $os (Windows uses the PowerShell shim)" >&2; exit 1 ;; esac
+  case "$arch" in arm64|aarch64) arch=arm64 ;; x86_64|amd64) arch=x64 ;; *) echo "ponytail-launch: unsupported arch $arch" >&2; exit 1 ;; esac
+  printf '%s-%s' "$os" "$arch"
+}
+sha256_of() {
+  if command -v sha256sum >/dev/null 2>&1; then sha256sum "$1" | awk '{print $1}'
+  elif command -v shasum >/dev/null 2>&1; then shasum -a 256 "$1" | awk '{print $1}'
+  else echo "ponytail-launch: no sha256 tool" >&2; exit 1; fi
+}
+
+command -v curl >/dev/null 2>&1 || { echo "ponytail-launch: curl required to fetch binaries" >&2; exit 1; }
+plat="$(detect_platform)"
+archive="ponytail-$plat.tar.gz"
+base="https://github.com/$REPO/releases/latest/download"
+tmp="$(mktemp -d "${TMPDIR:-/tmp}/ponytail-launch.XXXXXX")"
+trap 'rm -rf "$tmp"' EXIT
+
+curl -fsSL "$base/$archive"        -o "$tmp/$archive"        || { echo "ponytail-launch: download failed ($archive)" >&2; exit 1; }
+curl -fsSL "$base/$archive.sha256" -o "$tmp/$archive.sha256" || { echo "ponytail-launch: checksum download failed" >&2; exit 1; }
+want="$(awk '{print $1}' "$tmp/$archive.sha256")"; got="$(sha256_of "$tmp/$archive")"
+[ "$want" = "$got" ] || { echo "ponytail-launch: SHA-256 mismatch — refusing" >&2; exit 1; }
+
+mkdir -p "$CACHE"
+tar -C "$CACHE" -xzf "$tmp/$archive" || { echo "ponytail-launch: extract failed" >&2; exit 1; }
+chmod +x "$CACHE"/ponytail-* 2>/dev/null || true
+try_exec "$CACHE/$NAME" "$@"
+
+echo "ponytail-launch: could not resolve '$NAME' (not in archive?)" >&2
+exit 1

bin/ponytail-launch.ps1

@@ -0,0 +1,67 @@
+# ponytail-launch.ps1 — Windows/PowerShell sibling of bin/ponytail-launch.
+#
+# The Claude Code plugin (.claude-plugin/plugin.json → hooks/claude-codex-hooks.json)
+# runs the lifecycle hooks through a launcher so it never bundles per-platform
+# blobs. On POSIX that launcher is the bash bin/ponytail-launch; PowerShell can't
+# run a bash script, so this is the Windows entry point the `commandWindows` hook
+# field invokes. It resolves an already-installed ponytail-* binary (standalone
+# install → local dev build → cache), forwarding stdin and args.
+#
+# Usage:  ponytail-launch.ps1 <binary-name> [args...]   (stdin is forwarded)
+#   e.g.  ponytail-launch.ps1 ponytail-activate
+#         ponytail-launch.ps1 ponytail-hook
+#
+# Resolution order (mirrors the bash launcher):
+#   1. $env:CLAUDE_CONFIG_DIR\hooks\<name>(.exe)   (standalone install)
+#   2. <repo-root>\zig\zig-out\bin\<name>(.exe)    (local clone / dev build)
+#   3. $PONYTAIL_CACHE\<name>(.exe)                (previously downloaded)
+#
+# Windows native Zig binaries are still pending (R6-Windows): the cross-compile in
+# .github/workflows/release-binaries.yml ships macOS + Linux only. Until a Windows
+# archive ships there is no step-4 download here — if no binary resolves, this exits
+# 0 (silent no-op) so a missing Windows binary never blocks SessionStart / prompt
+# submission, exactly like the POSIX hooks' silent-fail contract.
+
+[CmdletBinding()]
+param(
+  [Parameter(Mandatory = $true, Position = 0)]
+  [string]$Name,
+  [Parameter(ValueFromRemainingArguments = $true)]
+  [string[]]$Rest
+)
+
+$ErrorActionPreference = "Stop"
+
+# Try to run $exe (with the .exe sibling on Windows) forwarding stdin + $Rest. On
+# success the script exits with the child's exit code; otherwise returns to let the
+# next resolution step run.
+function Try-Run([string]$exe) {
+  foreach ($cand in @($exe, "$exe.exe")) {
+    if (Test-Path -LiteralPath $cand -PathType Leaf) {
+      & $cand @Rest
+      exit $LASTEXITCODE
+    }
+  }
+}
+
+$here = Split-Path -Parent $MyInvocation.MyCommand.Path
+
+# 1. standalone-installed hooks dir
+$cfg = if ($env:CLAUDE_CONFIG_DIR) { $env:CLAUDE_CONFIG_DIR } else { Join-Path $HOME ".claude" }
+Try-Run (Join-Path (Join-Path $cfg "hooks") $Name)
+
+# 2. local clone / dev build (launcher lives at bin\, zig\ is a sibling at repo root)
+Try-Run (Join-Path (Join-Path (Join-Path (Join-Path (Split-Path -Parent $here) "zig") "zig-out") "bin") $Name)
+
+# 3. previously downloaded cache
+$cache = if ($env:PONYTAIL_CACHE) {
+  $env:PONYTAIL_CACHE
+} elseif ($env:XDG_CACHE_HOME) {
+  Join-Path (Join-Path $env:XDG_CACHE_HOME "ponytail") "bin"
+} else {
+  Join-Path (Join-Path (Join-Path $HOME ".cache") "ponytail") "bin"
+}
+Try-Run (Join-Path $cache $Name)
+
+# No Windows binary yet (R6-Windows). Silent no-op so the hook never blocks.
+exit 0

hooks/claude-codex-hooks.json

@@ -6,9 +6,9 @@
         "hooks": [
           {
             "type": "command",
-            "command": "command -v node >/dev/null 2>&1 && node \"${CLAUDE_PLUGIN_ROOT}/hooks/ponytail-activate.js\" || exit 0",
-            "commandWindows": "if (Get-Command node -ErrorAction SilentlyContinue) { node \"$env:CLAUDE_PLUGIN_ROOT\\hooks\\ponytail-activate.js\" }",
-            "timeout": 5,
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/bin/ponytail-launch\" ponytail-activate",
+            "commandWindows": "pwsh -NoProfile -ExecutionPolicy Bypass -File \"$env:CLAUDE_PLUGIN_ROOT\\bin\\ponytail-launch.ps1\" ponytail-activate",
+            "timeout": 30,
             "statusMessage": "Loading ponytail mode..."
           }
         ]
@@ -19,9 +19,9 @@
         "hooks": [
           {
             "type": "command",
-            "command": "command -v node >/dev/null 2>&1 && node \"${CLAUDE_PLUGIN_ROOT}/hooks/ponytail-mode-tracker.js\" || exit 0",
-            "commandWindows": "if (Get-Command node -ErrorAction SilentlyContinue) { node \"$env:CLAUDE_PLUGIN_ROOT\\hooks\\ponytail-mode-tracker.js\" }",
-            "timeout": 5,
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/bin/ponytail-launch\" ponytail-hook",
+            "commandWindows": "pwsh -NoProfile -ExecutionPolicy Bypass -File \"$env:CLAUDE_PLUGIN_ROOT\\bin\\ponytail-launch.ps1\" ponytail-hook",
+            "timeout": 30,
             "statusMessage": "Tracking ponytail mode..."
           }
         ]

hooks/copilot-hooks.json

@@ -4,17 +4,15 @@
     "sessionStart": [
       {
         "type": "command",
-        "bash": "node \"${PLUGIN_ROOT}/hooks/ponytail-activate.js\"",
-        "powershell": "node \"${PLUGIN_ROOT}\\hooks\\ponytail-activate.js\"",
-        "timeoutSec": 5
+        "bash": "\"${PLUGIN_ROOT}/bin/ponytail-launch\" ponytail-activate",
+        "timeoutSec": 30
       }
     ],
     "userPromptSubmitted": [
       {
         "type": "command",
-        "bash": "node \"${PLUGIN_ROOT}/hooks/ponytail-mode-tracker.js\"",
-        "powershell": "node \"${PLUGIN_ROOT}\\hooks\\ponytail-mode-tracker.js\"",
-        "timeoutSec": 5
+        "bash": "\"${PLUGIN_ROOT}/bin/ponytail-launch\" ponytail-hook",
+        "timeoutSec": 30
       }
     ]
   }