@yunhozz/arc 0.0.0-stage → 0.1.0

package/lib/safe-fs/index.mjs

@@ -0,0 +1,67 @@
+import fs from 'node:fs';
+import { loadNative } from './native.mjs';
+const state = new WeakMap();
+const finalizer = new FinalizationRegistry(fd => { try { fs.closeSync(fd); } catch {} });
+function value(handle) {
+  const v = state.get(handle);
+  if (!v || v.fd === null) throw new Error('Filesystem handle is closed');
+  return v;
+}
+function register(handle, fd, native) {
+  state.set(handle, { fd, native }); finalizer.register(handle, fd, handle);
+}
+class Handle {
+  stat() { return fs.fstatSync(value(this).fd, { bigint: true }); }
+  chmod(mode) { fs.fchmodSync(value(this).fd, mode); }
+  setTimes(times, legacyMtime) {
+    const v = value(this);
+    if (times !== null && typeof times === 'object' && !(times instanceof Date)) {
+      if (typeof times.atimeNs !== 'bigint' || typeof times.mtimeNs !== 'bigint') throw new TypeError('Timestamp metadata requires BigInt nanoseconds');
+      v.native.setTimes(v.fd, times.atimeNs, times.mtimeNs);
+    } else fs.futimesSync(v.fd, times, legacyMtime);
+  }
+  sync() { fs.fsyncSync(value(this).fd); }
+  close() { const v = value(this); fs.closeSync(v.fd); v.fd = null; finalizer.unregister(this); }
+}
+export class FileHandle extends Handle {
+  readAll() { return this.read(); }
+  writeAll(buffer) { return this.write(buffer); }
+  read() {
+    const descriptor = value(this).fd;
+    const parts = []; let position = 0;
+    for (;;) {
+      const chunk = Buffer.alloc(65536);
+      const count = fs.readSync(descriptor, chunk, 0, chunk.length, position);
+      if (!count) return Buffer.concat(parts);
+      parts.push(chunk.subarray(0, count)); position += count;
+    }
+  }
+  write(data, position = 0) {
+    const fd = value(this).fd; const bytes = Buffer.isBuffer(data) ? data : Buffer.from(data); let offset = 0;
+    while (offset < bytes.length) { const count = fs.writeSync(fd, bytes, offset, bytes.length - offset, position + offset); if (!count) throw new Error('Short file write'); offset += count; }
+    return offset;
+  }
+}
+export class DirectoryHandle extends Handle {
+  openDir(name) { const v = value(this); const h = new DirectoryHandle(); register(h, v.native.openAt(v.fd, name, 1, 0, 0, 0, 0), v.native); return h; }
+  openFile(name, { read = true, create = false, exclusive = false, createExclusive = false, mode = 0o600 } = {}) {
+    if (!Number.isInteger(mode) || mode < 0 || mode > 0o7777) throw new TypeError('Invalid file mode');
+    const v = value(this), h = new FileHandle();
+    register(h, v.native.openAt(v.fd, name, 0, Number(create || createExclusive), Number(exclusive || createExclusive), mode, Number(!read || create || createExclusive)), v.native);
+    return h;
+  }
+  readDir() { const v = value(this); return v.native.readDir(v.fd).sort(); }
+  lstat(name) { const v = value(this); return v.native.lstat(v.fd, name); }
+  symlink(target, name) { const v = value(this); v.native.symlink(v.fd, name, target); }
+  readlink(name) { const v = value(this); return v.native.readlink(v.fd, name); }
+  mkdir(name, mode = 0o700) { if (!Number.isInteger(mode) || mode < 0 || mode > 0o7777) throw new TypeError('Invalid directory mode'); const v = value(this); v.native.mkdir(v.fd, name, mode); }
+  unlink(name) { const v = value(this); v.native.unlink(v.fd, name); }
+  rmdir(name) { const v = value(this); v.native.rmdir(v.fd, name); }
+  renameNoReplaceTo(name, destination, newName) { const v = value(this), target = value(destination); if (!(destination instanceof DirectoryHandle)) throw new TypeError('Destination must be a directory handle'); v.native.renameExclusive(v.fd, name, target.fd, newName); }
+  renameTo(name, destination, newName) { const v = value(this), target = value(destination); if (!(destination instanceof DirectoryHandle)) throw new TypeError('Destination must be a directory handle'); v.native.rename(v.fd, name, target.fd, newName); }
+}
+let defaultNative;
+export function openRoot(path, { native } = {}) {
+  const binding = native ?? (defaultNative ??= loadNative());
+  const handle = new DirectoryHandle(); register(handle, binding.openRoot(path), binding); return handle;
+}

package/lib/safe-fs/native.mjs

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+const require = createRequire(import.meta.url);
+const packageRoot = fileURLToPath(new URL('../../', import.meta.url));
+export function hostRuntime() {
+  return { platform: process.platform, arch: process.arch, node: process.versions.node, release: os.release(),
+    glibc: process.report?.getReport().header.glibcVersionRuntime };
+}
+function runtimeError(message) { return Object.assign(new Error(message), { code: 'ARC_UNSUPPORTED_RUNTIME' }); }
+export function supportedTuple(runtime = hostRuntime()) {
+  const major = Number(runtime.node?.split('.')[0]);
+  if (!Number.isInteger(major) || major < 22) throw runtimeError('Node.js 22 or later is required');
+  if (!['darwin', 'linux'].includes(runtime.platform) || !['arm64', 'x64'].includes(runtime.arch)) throw runtimeError('Unsupported operating system or CPU');
+  if (runtime.platform === 'darwin' && !(Number(runtime.release?.split('.')[0]) >= 22)) throw runtimeError('macOS 13 or later is required');
+  if (runtime.platform === 'linux') {
+    const [major, minor] = (runtime.glibc ?? '').split('.').map(Number);
+    if (!(major > 2 || major === 2 && minor >= 28)) throw runtimeError('glibc 2.28 or later is required');
+  }
+  return `${runtime.platform}-${runtime.arch}${runtime.platform === 'linux' ? '-gnu' : ''}`;
+}
+function verifyHeader(bytes, tuple) {
+  const [platform, arch] = tuple.split('-');
+  if (platform === 'darwin') {
+    if (bytes.length < 32 || bytes.readUInt32LE(0) !== 0xfeedfacf || bytes.readUInt32LE(4) !== (arch === 'arm64' ? 0x100000c : 0x1000007)) throw new Error('Invalid native Mach-O binary');
+  } else if (bytes.length < 64 || bytes.subarray(0, 4).toString('hex') !== '7f454c46' || bytes[4] !== 2 || bytes[5] !== 1 || bytes.readUInt16LE(18) !== (arch === 'arm64' ? 183 : 62)) throw new Error('Invalid native ELF binary');
+}
+export function loadNative({ root = packageRoot, runtime = hostRuntime(), artifactDirectory = 'prebuilds' } = {}) {
+  const tuple = supportedTuple(runtime);
+  try {
+  const artifactRoot = path.join(root, artifactDirectory);
+  let records;
+  try { records = JSON.parse(fs.readFileSync(path.join(artifactRoot, 'index.json'), 'utf8')).artifacts; }
+  catch (error) { throw new Error('Native artifact index unavailable: ' + error.message); }
+  const record = records?.[tuple];
+  if (!record || record.napi !== 8 || !/^[a-f0-9]{64}$/.test(record.sha256 ?? '')) throw new Error('Invalid native artifact record');
+  const binaryPath = path.join(artifactRoot, tuple, 'arc_safe_fs.node');
+  const descriptor = fs.openSync(binaryPath, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+  let bytes;
+  try {
+    if (!fs.fstatSync(descriptor).isFile()) throw new Error('Native artifact is not a regular file');
+    bytes = fs.readFileSync(descriptor);
+  } finally { fs.closeSync(descriptor); }
+  if (crypto.createHash('sha256').update(bytes).digest('hex') !== record.sha256) throw new Error('Native artifact hash mismatch');
+  verifyHeader(bytes, tuple);
+  // The package is trusted executable code. Concurrent replacement of package
+  // code between verification and loading is outside the target-directory race
+  // protection boundary. Bootstrap performs no filesystem writes.
+  return require(binaryPath);
+  } catch (cause) { throw Object.assign(new Error(cause.message, { cause }), { code: 'ARC_NATIVE_UNAVAILABLE' }); }
+}

package/native/binding.c

@@ -0,0 +1,157 @@
+#define _GNU_SOURCE
+#include <node_api.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#ifdef __linux__
+#include <sys/syscall.h>
+#include <linux/fs.h>
+#endif
+
+static napi_value fail(napi_env e, const char *what) {
+  char msg[256]; snprintf(msg,sizeof(msg),"%s: %s",what,strerror(errno));
+  const char *code="ERR_SAFE_FS";
+  switch(errno) {
+#define ERRNO_CASE(x) case x: code=#x; break;
+    ERRNO_CASE(ENOENT) ERRNO_CASE(EEXIST) ERRNO_CASE(EACCES) ERRNO_CASE(EPERM)
+    ERRNO_CASE(ELOOP) ERRNO_CASE(ENOTDIR) ERRNO_CASE(EISDIR) ERRNO_CASE(EINVAL)
+    ERRNO_CASE(EBADF) ERRNO_CASE(ENOSPC) ERRNO_CASE(EXDEV) ERRNO_CASE(ENOTEMPTY) ERRNO_CASE(EIO)
+  }
+  napi_throw_error(e,code,msg); return NULL;
+}
+static int integer(napi_env e,napi_value v) { int32_t n=-1; napi_get_value_int32(e,v,&n); return n; }
+static char *string(napi_env e,napi_value v) {
+  size_t n=0; if(napi_get_value_string_utf8(e,v,NULL,0,&n)!=napi_ok) { napi_throw_type_error(e,NULL,"Expected string"); return NULL; }
+  char *s=malloc(n+1); if(!s) { errno=ENOMEM; fail(e,"allocate"); return NULL; }
+  napi_get_value_string_utf8(e,v,s,n+1,&n);
+  if(strlen(s)!=n) { free(s); napi_throw_error(e,NULL,"NUL is forbidden"); return NULL; } return s;
+}
+static char *component(napi_env e,napi_value v) {
+  char *s=string(e,v); if(!s)return NULL;
+  if(!*s||!strcmp(s,".")||!strcmp(s,"..")||strchr(s,'/')) { free(s); napi_throw_error(e,NULL,"Expected one safe path component"); return NULL; } return s;
+}
+static napi_value number(napi_env e,int n) { napi_value v; napi_create_int32(e,n,&v); return v; }
+static napi_value open_root(napi_env e,napi_callback_info info) {
+  napi_value a[1]; size_t n=1; napi_get_cb_info(e,info,&n,a,NULL,NULL);
+  char *p=string(e,a[0]); if(!p)return NULL;
+  if(p[0]!='/') { free(p); napi_throw_error(e,NULL,"Root must be absolute"); return NULL; }
+  int fd=open("/",O_RDONLY|O_DIRECTORY|O_CLOEXEC); if(fd<0) { free(p); return fail(e,"open root"); }
+  char *save=NULL; char *part=strtok_r(p,"/",&save);
+  while(part) {
+    if(!strcmp(part,".")||!strcmp(part,"..")) { close(fd); free(p); napi_throw_error(e,NULL,"Unsafe root component"); return NULL; }
+    int next=openat(fd,part,O_RDONLY|O_DIRECTORY|O_NOFOLLOW|O_CLOEXEC); int saved=errno; close(fd);
+    if(next<0) { free(p); errno=saved; return fail(e,"open root component"); } fd=next; part=strtok_r(NULL,"/",&save);
+  }
+  free(p); return number(e,fd);
+}
+static napi_value open_at(napi_env e,napi_callback_info info) {
+  napi_value a[7]; size_t n=7; napi_get_cb_info(e,info,&n,a,NULL,NULL);
+  if(n<7) { napi_throw_type_error(e,NULL,"Invalid native open arguments"); return NULL; }
+  int parent=integer(e,a[0]); char *name=component(e,a[1]); if(!name)return NULL;
+  int directory=integer(e,a[2]), create=integer(e,a[3]), exclusive=integer(e,a[4]);
+  int flags=O_CLOEXEC|O_NOFOLLOW|O_NONBLOCK|(directory ? O_RDONLY|O_DIRECTORY : (integer(e,a[6]) ? O_RDWR : O_RDONLY));
+  if(create) flags |= O_CREAT;
+  if(exclusive) flags |= O_EXCL;
+  int fd=openat(parent,name,flags,(mode_t)integer(e,a[5])); int saved=errno; free(name);
+  if(fd<0) { errno=saved; return fail(e,"open component"); }
+  struct stat st; if(fstat(fd,&st)<0 || (directory ? !S_ISDIR(st.st_mode) : !S_ISREG(st.st_mode))) { close(fd); errno=EINVAL; return fail(e,"Unexpected file type"); }
+  return number(e,fd);
+}
+static napi_value mutate(napi_env e,napi_callback_info info) {
+  napi_value a[5]; size_t n=5; void *data; napi_get_cb_info(e,info,&n,a,NULL,&data);
+  int fd=integer(e,a[0]); char *name=component(e,a[1]); if(!name)return NULL;
+  intptr_t op=(intptr_t)data; int rc=-1;
+  if(op==0) rc=mkdirat(fd,name,(mode_t)integer(e,a[2]));
+  else if(op==1||op==2)rc=unlinkat(fd,name,op==2?AT_REMOVEDIR:0);
+  else { char *dest=component(e,a[3]); if(!dest) { free(name); return NULL; } rc=renameat(fd,name,integer(e,a[2]),dest); free(dest); }
+  int saved=errno; free(name); if(rc<0) { errno=saved; return fail(e,"relative mutation"); } return number(e,0);
+}
+static napi_value rename_exclusive(napi_env e,napi_callback_info info) {
+  napi_value a[4]; size_t n=4; napi_get_cb_info(e,info,&n,a,NULL,NULL);
+  if(n!=4) { napi_throw_type_error(e,NULL,"Expected source and destination handles and names"); return NULL; }
+  char *source=component(e,a[1]); if(!source)return NULL;
+  char *destination=component(e,a[3]); if(!destination) { free(source); return NULL; }
+  int rc;
+#ifdef __APPLE__
+  rc=renameatx_np(integer(e,a[0]),source,integer(e,a[2]),destination,RENAME_EXCL);
+#elif defined(__linux__) && defined(SYS_renameat2)
+  rc=(int)syscall(SYS_renameat2,integer(e,a[0]),source,integer(e,a[2]),destination,RENAME_NOREPLACE);
+#else
+  errno=ENOTSUP; rc=-1;
+#endif
+  int saved=errno; free(source); free(destination);
+  if(rc<0) { errno=saved; return fail(e,"atomic no-replace rename"); }
+  return number(e,0);
+}
+static napi_value set_times(napi_env e,napi_callback_info info) {
+  napi_value a[3]; size_t n=3; napi_get_cb_info(e,info,&n,a,NULL,NULL);
+  if(n<3) { napi_throw_type_error(e,NULL,"Expected descriptor and nanosecond times"); return NULL; }
+  struct timespec times[2];
+  for(int i=0;i<2;i++) {
+    int64_t ns; bool lossless;
+    if(napi_get_value_bigint_int64(e,a[i+1],&ns,&lossless)!=napi_ok || !lossless) {
+      napi_throw_type_error(e,NULL,"Timestamp must be a signed 64-bit BigInt in nanoseconds"); return NULL;
+    }
+    times[i].tv_sec=ns/1000000000; times[i].tv_nsec=ns%1000000000;
+    if(times[i].tv_nsec<0) { times[i].tv_sec--; times[i].tv_nsec+=1000000000; }
+  }
+  if(futimens(integer(e,a[0]),times)<0)return fail(e,"set descriptor timestamps");
+  return number(e,0);
+}
+static napi_value symlink_at(napi_env e,napi_callback_info info) {
+  napi_value a[3]; size_t n=3; napi_get_cb_info(e,info,&n,a,NULL,NULL);
+  char *name=component(e,a[1]); if(!name)return NULL;
+  char *target=string(e,a[2]); if(!target) { free(name); return NULL; }
+  int rc=symlinkat(target,integer(e,a[0]),name); int saved=errno; free(name); free(target);
+  if(rc<0) { errno=saved; return fail(e,"create symlink"); } return number(e,0);
+}
+static napi_value read_link(napi_env e,napi_callback_info info) {
+  napi_value a[2],v; size_t n=2; napi_get_cb_info(e,info,&n,a,NULL,NULL); char *s=component(e,a[1]); if(!s)return NULL;
+  char buf[65536]; ssize_t len=readlinkat(integer(e,a[0]),s,buf,sizeof(buf)); int saved=errno; free(s);
+  if(len<0) { errno=saved; return fail(e,"readlink"); } if(len==sizeof(buf)) { errno=ENAMETOOLONG; return fail(e,"readlink"); }
+  napi_create_string_utf8(e,buf,len,&v); return v;
+}
+static napi_value list(napi_env e,napi_callback_info info) {
+  napi_value a[1],result; size_t n=1; napi_get_cb_info(e,info,&n,a,NULL,NULL);
+  int fd=openat(integer(e,a[0]),".",O_RDONLY|O_DIRECTORY|O_CLOEXEC); if(fd<0)return fail(e,"read directory");
+  DIR *d=fdopendir(fd); if(!d) { close(fd); return fail(e,"read directory"); }
+  napi_create_array(e,&result); unsigned i=0; struct dirent *entry; int saved=0;
+  for(;;) {
+    /* N-API conversion may change errno. Only readdir's EOF/error owns it. */
+    errno=0; entry=readdir(d); if(!entry) { saved=errno; break; }
+    if(!strcmp(entry->d_name,".")||!strcmp(entry->d_name,".."))continue;
+    napi_value v; napi_create_string_utf8(e,entry->d_name,NAPI_AUTO_LENGTH,&v); napi_set_element(e,result,i++,v);
+  }
+  closedir(d); if(saved) { errno=saved; return fail(e,"read directory"); } return result;
+}
+static napi_value stat_at(napi_env e,napi_callback_info info) {
+  napi_value a[2],o; size_t n=2; napi_get_cb_info(e,info,&n,a,NULL,NULL); char *s=component(e,a[1]); if(!s)return NULL;
+  struct stat st; int rc=fstatat(integer(e,a[0]),s,&st,AT_SYMLINK_NOFOLLOW); int saved=errno; free(s); if(rc<0) { errno=saved; return fail(e,"lstat"); }
+  napi_create_object(e,&o);
+#define FIELD(k,value) { napi_value v; napi_create_bigint_int64(e,(int64_t)(value),&v); napi_set_named_property(e,o,k,v); }
+  FIELD("dev",st.st_dev); FIELD("ino",st.st_ino); FIELD("mode",st.st_mode); FIELD("size",st.st_size);
+  FIELD("nlink",st.st_nlink); FIELD("uid",st.st_uid); FIELD("gid",st.st_gid);
+#ifdef __APPLE__
+  int64_t atime=(int64_t)st.st_atimespec.tv_sec*1000000000+st.st_atimespec.tv_nsec;
+  int64_t mtime=(int64_t)st.st_mtimespec.tv_sec*1000000000+st.st_mtimespec.tv_nsec;
+  int64_t ctime=(int64_t)st.st_ctimespec.tv_sec*1000000000+st.st_ctimespec.tv_nsec;
+  FIELD("birthtimeNs",(int64_t)st.st_birthtimespec.tv_sec*1000000000+st.st_birthtimespec.tv_nsec);
+#else
+  int64_t atime=(int64_t)st.st_atim.tv_sec*1000000000+st.st_atim.tv_nsec;
+  int64_t mtime=(int64_t)st.st_mtim.tv_sec*1000000000+st.st_mtim.tv_nsec;
+  int64_t ctime=(int64_t)st.st_ctim.tv_sec*1000000000+st.st_ctim.tv_nsec;
+#endif
+  FIELD("atimeNs",atime); FIELD("mtimeNs",mtime); FIELD("ctimeNs",ctime);
+  FIELD("atimeMs",atime/1000000); FIELD("mtimeMs",mtime/1000000); FIELD("ctimeMs",ctime/1000000);
+  return o;
+}
+static napi_value init(napi_env e,napi_value exports) {
+  struct { const char *name; napi_callback cb; intptr_t data; } f[]={ {"openRoot",open_root,0},{"openAt",open_at,0},{"mkdir",mutate,0},{"unlink",mutate,1},{"rmdir",mutate,2},{"rename",mutate,3},{"renameExclusive",rename_exclusive,0},{"setTimes",set_times,0},{"symlink",symlink_at,0},{"readlink",read_link,0},{"readDir",list,0},{"lstat",stat_at,0} };
+  for(unsigned i=0;i<sizeof(f)/sizeof(f[0]);i++) { napi_value v; napi_create_function(e,f[i].name,NAPI_AUTO_LENGTH,f[i].cb,(void*)f[i].data,&v); napi_set_named_property(e,exports,f[i].name,v); } return exports;
+}
+NAPI_MODULE(NODE_GYP_MODULE_NAME,init)

package/native/binding.gyp

@@ -0,0 +1 @@
+{"targets":[{"target_name":"arc_safe_fs","sources":["binding.c"],"defines":["NAPI_VERSION=8"],"xcode_settings":{"MACOSX_DEPLOYMENT_TARGET":"13.0"}}]}

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "@yunhozz/arc",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "test": "node --test tests/node/*.test.mjs",
+    "build:native": "node scripts/build-native.mjs",
+    "check:manifest": "node scripts/update-manifest.mjs --check",
+    "update:role-policy": "node scripts/update-role-policy.mjs",
+    "check:role-policy": "node scripts/update-role-policy.mjs --check"
+  },
+  "devDependencies": {
+    "node-gyp": "11.5.0",
+    "smol-toml": "1.9.1"
+  },
+  "bin": {
+    "arc": "bin/arc.mjs"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "scripts/",
+    "vendor/",
+    "prebuilds/",
+    "native/binding.c",
+    "native/binding.gyp",
+    "codex/skill/",
+    "codex/agents/",
+    "claude/skill/",
+    "claude/agents/",
+    "MANIFEST.sha256",
+    "install.command"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yunhozz/arc.git"
+  }
+}

package/prebuilds/index.json

@@ -0,0 +1,64 @@
+{
+  "artifacts": {
+    "darwin-arm64": {
+      "sha256": "208c65cfde244d39ce45c3cf1b0acb128f04d21199b6b3fb5466e62db5b64af9",
+      "sourceCommit": "f4386726e133922676aeb2f8d9d73b2b87afbf96",
+      "nativeInputDigest": "831a685a17634789f84f9f16077e2f0ce28f79e99714d54b7bc122b40b5139cf",
+      "napi": 8,
+      "nodeHeaders": "22.23.2",
+      "nodeHeadersDigest": "6f8b5e0047e9d15a28da9aead4236cebf5171031359b2f6a1d9fdf05f8f04bf3",
+      "sourceDirty": false,
+      "buildImage": null,
+      "libc": null,
+      "compiler": "Apple clang version 17.0.0 (clang-1700.0.13.5)\nTarget: arm64-apple-darwin24.6.0\nThread model: posix\nInstalledDir: /Applications/Xcode_16.4.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin",
+      "sysroot": "/Applications/Xcode_16.4.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk",
+      "deploymentTarget": "13.0",
+      "tuple": "darwin-arm64"
+    },
+    "darwin-x64": {
+      "sha256": "572887ac794d10a8b921d8168ea2328e31f05b45987611ff02c83114dba901af",
+      "sourceCommit": "f4386726e133922676aeb2f8d9d73b2b87afbf96",
+      "nativeInputDigest": "831a685a17634789f84f9f16077e2f0ce28f79e99714d54b7bc122b40b5139cf",
+      "napi": 8,
+      "nodeHeaders": "22.23.2",
+      "nodeHeadersDigest": "6f8b5e0047e9d15a28da9aead4236cebf5171031359b2f6a1d9fdf05f8f04bf3",
+      "sourceDirty": false,
+      "buildImage": null,
+      "libc": null,
+      "compiler": "Apple clang version 17.0.0 (clang-1700.0.13.5)\nTarget: x86_64-apple-darwin24.6.0\nThread model: posix\nInstalledDir: /Applications/Xcode_16.4.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin",
+      "sysroot": "/Applications/Xcode_16.4.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk",
+      "deploymentTarget": "13.0",
+      "tuple": "darwin-x64"
+    },
+    "linux-arm64-gnu": {
+      "sha256": "b98bb4ac757ebd6e8f8fc1eb7a6a4389e3a8199984baf6bb1c327a6f952c2c0d",
+      "sourceCommit": "f4386726e133922676aeb2f8d9d73b2b87afbf96",
+      "nativeInputDigest": "831a685a17634789f84f9f16077e2f0ce28f79e99714d54b7bc122b40b5139cf",
+      "napi": 8,
+      "nodeHeaders": "22.23.3",
+      "nodeHeadersDigest": "b1c10d710bb872f0d5d9f53756bb0c6cebe4b6441722268a7a2d0889e1df59ce",
+      "sourceDirty": false,
+      "buildImage": "quay.io/pypa/manylinux_2_28_aarch64@sha256:abd1230aa9e4058a74b89d27cd14ba18c0db036d7bfe6e6f219a29ea63c24eb6",
+      "libc": "glibc 2.28",
+      "compiler": "cc (GCC) 14.2.1 20250110 (Red Hat 14.2.1-11)\nCopyright (C) 2024 Free Software Foundation, Inc.\nThis is free software; see the source for copying conditions.  There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.",
+      "sysroot": "/",
+      "deploymentTarget": "glibc-2.28",
+      "tuple": "linux-arm64-gnu"
+    },
+    "linux-x64-gnu": {
+      "sha256": "9f8c2c1e328ee287355bc36afc3173c00ed062611fbd1262e4d30fca83e979dc",
+      "sourceCommit": "f4386726e133922676aeb2f8d9d73b2b87afbf96",
+      "nativeInputDigest": "831a685a17634789f84f9f16077e2f0ce28f79e99714d54b7bc122b40b5139cf",
+      "napi": 8,
+      "nodeHeaders": "22.23.3",
+      "nodeHeadersDigest": "b1c10d710bb872f0d5d9f53756bb0c6cebe4b6441722268a7a2d0889e1df59ce",
+      "sourceDirty": false,
+      "buildImage": "quay.io/pypa/manylinux_2_28_x86_64@sha256:4131ddd7acb9c6c966af02fe7e71edc51e078c2d41f475966697676430bfa2ae",
+      "libc": "glibc 2.28",
+      "compiler": "cc (GCC) 14.2.1 20250110 (Red Hat 14.2.1-11)\nCopyright (C) 2024 Free Software Foundation, Inc.\nThis is free software; see the source for copying conditions.  There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.",
+      "sysroot": "/",
+      "deploymentTarget": "glibc-2.28",
+      "tuple": "linux-x64-gnu"
+    }
+  }
+}

package/scripts/build-native.mjs

@@ -0,0 +1,36 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { supportedTuple } from '../lib/safe-fs/native.mjs';
+const root = fileURLToPath(new URL('../', import.meta.url));
+function argument(name, fallback) { const i = process.argv.indexOf(name); return i < 0 ? fallback : process.argv[i + 1]; }
+const tuple = argument('--tuple', supportedTuple());
+if (tuple !== supportedTuple()) throw new Error('Native builds must run on the selected target tuple');
+const output = path.resolve(argument('--output', `build/native/${tuple}`));
+const headerCache = path.join(root, 'build/node-headers');
+const build = spawnSync(process.execPath, [path.join(root, 'node_modules/node-gyp/bin/node-gyp.js'), 'rebuild', '--devdir', headerCache, '--directory', path.join(root, 'native')], { stdio: 'inherit', env: { ...process.env, MACOSX_DEPLOYMENT_TARGET: '13.0' } });
+if (build.status !== 0) process.exit(build.status ?? 1);
+const binary = fs.readFileSync(path.join(root, 'native/build/Release/arc_safe_fs.node'));
+const digest = crypto.createHash('sha256');
+for (const name of ['native/binding.c', 'native/binding.gyp', 'scripts/build-native.mjs', 'package-lock.json']) digest.update(name).update('\0').update(fs.readFileSync(path.join(root, name))).update('\0');
+const command = (cmd, args) => { const r = spawnSync(cmd, args, { cwd: root, encoding: 'utf8' }); if (r.status !== 0) throw new Error(`Cannot identify build input: ${cmd}`); return r.stdout.trim(); };
+const headerDigest = crypto.createHash('sha256');
+function hashTree(directory, relative = '') {
+  for (const name of fs.readdirSync(path.join(directory, relative)).sort()) {
+    const child = path.join(relative, name); const filename = path.join(directory, child);
+    if (fs.lstatSync(filename).isDirectory()) hashTree(directory, child);
+    else headerDigest.update(child).update('\0').update(fs.readFileSync(filename)).update('\0');
+  }
+}
+hashTree(path.join(headerCache, process.versions.node, 'include/node'));
+const libc = process.platform === 'linux' ? command('getconf', ['GNU_LIBC_VERSION']) : null;
+if (libc && libc !== 'glibc 2.28') throw new Error('Release Linux native builds require the glibc 2.28 build image');
+const record = { sha256: crypto.createHash('sha256').update(binary).digest('hex'), sourceCommit: command('git', ['rev-parse', 'HEAD']), nativeInputDigest: digest.digest('hex'), napi: 8, nodeHeaders: process.versions.node, nodeHeadersDigest: headerDigest.digest('hex'), sourceDirty: Boolean(command('git', ['status', '--porcelain', '--untracked-files=no'])), buildImage: process.env.ARC_BUILD_IMAGE ?? null, libc, compiler: command('cc', ['--version']), sysroot: process.platform === 'darwin' ? command('xcrun', ['--show-sdk-path']) : command('cc', ['-print-sysroot']) || '/', deploymentTarget: process.platform === 'darwin' ? '13.0' : 'glibc-2.28', tuple };
+fs.mkdirSync(output, { recursive: true }); fs.writeFileSync(path.join(output, 'arc_safe_fs.node'), binary);
+fs.writeFileSync(path.join(output, 'provenance.json'), JSON.stringify(record, null, 2) + '\n');
+const base = path.dirname(output); const indexFile = path.join(base, 'index.json');
+const index = fs.existsSync(indexFile) ? JSON.parse(fs.readFileSync(indexFile)) : { artifacts: {} };
+index.artifacts[tuple] = record; fs.writeFileSync(indexFile, JSON.stringify(index, null, 2) + '\n');
+console.log(`Built ${tuple}: ${record.sha256}`);

package/scripts/check-installer-parity.mjs

@@ -0,0 +1,59 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import {spawnSync} from 'node:child_process';
+import {fileURLToPath} from 'node:url';
+const arg=(name,fallback)=>{const i=process.argv.indexOf(name);return i<0?fallback:process.argv[i+1];};
+const root=path.resolve(arg('--root',fileURLToPath(new URL('../',import.meta.url))));
+const complete=process.argv.includes('--complete');
+// Frozen before the legacy files were removed: test bodies, assertion expressions,
+// and helper assertion sites. Coverage mappings may change; this inventory may not.
+const inventorySha='b21f21cb1786d8400914f6f1837e8c3dddc51e4629fbdc4e091567a99f3825de';
+try{
+ const ledger=JSON.parse(fs.readFileSync(path.join(root,'tests/installer-parity.json'),'utf8'));
+ const inventory={tests:ledger.legacyInventory,helpers:ledger.legacyHelpers?.map(({id,assertions})=>({id,assertions}))};
+ if(crypto.createHash('sha256').update(JSON.stringify(inventory)).digest('hex')!==inventorySha)throw Error('Original assertion inventory changed');
+ if(inventory.tests.length!==236||inventory.tests.reduce((n,t)=>n+t.assertions.length,0)!==739||inventory.helpers.reduce((n,t)=>n+t.assertions.length,0)!==14)throw Error('Original assertion inventory count changed');
+ const entryIds=ledger.entries.map(e=>e.legacy);if(new Set(entryIds).size!==entryIds.length)throw Error('Duplicate legacy assertion ID');if(entryIds.length!==236)throw Error('Original inventory ID count changed');
+ let retiredIds=0,retiredAssertions=0;
+ const original=new Map(inventory.tests.map(t=>[t.id,t])),seen=new Set(),destinations=new Map();
+ const addDestination=(destination,owner)=>{
+  if(!/^tests\/(?:node\/[^/]+\.test\.mjs|test_[a-z_]+\.py)$/.test(destination?.file)||typeof destination.test!=='string'||!destination.test.trim())throw Error(`Invalid destination: ${owner}`);
+  if(!fs.existsSync(path.join(root,destination.file)))throw Error(`Missing mapped test file: ${destination.file} (${owner})`);
+  destinations.set(JSON.stringify(destination),destination);
+ };
+ for(const entry of ledger.entries){
+  if(seen.has(entry.legacy))throw Error(`Duplicate legacy assertion: ${entry.legacy}`);seen.add(entry.legacy);
+  const before=original.get(entry.legacy);if(!before)throw Error(`Unknown original inventory ID: ${entry.legacy}`);
+  if(entry.status==='retired'){
+   if(entry.legacy!=='tests/test_install.py::PolicyWordBudgetTests::test_policy_text_stays_within_word_budget'||entry.approvedPlan!=='docs/superpowers/plans/2026-10-17-arc-harness-refactor-plan.md'||!fs.existsSync(path.join(root,entry.approvedPlan))||typeof entry.retirementReason!=='string'||!entry.retirementReason.trim()||!Array.isArray(entry.destinations)||entry.destinations.length||Object.hasOwn(entry,'destination'))throw Error(`Invalid retired legacy assertion: ${entry.legacy}`);
+   if(JSON.stringify(entry.assertionLines)!==JSON.stringify(before.assertions.map(a=>a.line)))throw Error(`Changed retired assertion coverage: ${entry.legacy}`);
+   retiredIds++;retiredAssertions+=before.assertions.length;continue;
+  }
+  if(entry.status!=='verified')throw Error(`Unverified legacy assertion: ${entry.legacy}`);
+  const coverage=entry.assertionLines;if(!coverage||coverage.length!==before.assertions.length||!entry.destinations?.length)throw Error(`Incomplete assertion coverage: ${entry.legacy}`);
+  for(const assertion of before.assertions)if(!coverage.includes(assertion.line))throw Error(`Missing assertion destination: ${entry.legacy}:${assertion.line}`);
+  for(const destination of entry.destinations)addDestination(destination,entry.legacy);
+ }
+ for(const id of original.keys())if(!seen.has(id))throw Error(`Missing original inventory ID: ${id}`);
+ for(const helper of ledger.legacyHelpers){
+  if(!helper.destinations?.length)throw Error(`Missing helper assertion coverage: ${helper.id}`);
+  for(const destination of helper.destinations)addDestination(destination,helper.id);
+ }
+ // While the originals exist, detect a source inventory change as well.
+ const sourceIds=new Set();for(const filename of ['tests/test_install.py','tests/test_target_install.py']){const file=path.join(root,filename);if(!fs.existsSync(file))continue;let group;for(const line of fs.readFileSync(file,'utf8').split('\n')){const cls=/^class (\w+)/.exec(line);if(cls)group=cls[1];const method=/^    def (test_\w+)\(/.exec(line);if(method)sourceIds.add(`${filename}::${group}::${method[1]}`);}}for(const id of sourceIds)if(!original.has(id))throw Error(`Uninventoried legacy test: ${id}`);
+ if(complete){
+  const all=[...destinations.values()],nodeFiles=[...new Set(all.filter(d=>d.file.endsWith('.mjs')).map(d=>d.file))];
+  const escape=text=>text.replace(/[.*+?^${}()|[\]\\]/g,'\\$&');
+  for(const file of nodeFiles){
+   const selected=all.filter(d=>d.file===file),pattern='^(?:'+selected.map(d=>escape(d.test)).join('|')+')$';
+   const result=spawnSync(process.execPath,['--test','--test-reporter=tap','--test-name-pattern',pattern,file],{cwd:root,encoding:'utf8',maxBuffer:16*1024*1024});
+   if(result.status!==0)throw Error(`Mapped Node tests failed: ${file}\n${result.stdout}\n${result.stderr}`);
+   const passed=new Set([...result.stdout.matchAll(/^ok \d+ - (.+)$/gm)].map(m=>m[1]));
+   for(const d of selected)if(!passed.has(d.test))throw Error(`Mapped Node destination did not execute: ${file}: ${d.test}`);
+  }
+  const pythonFiles=[...new Set(all.filter(d=>d.file.endsWith('.py')).map(d=>d.file))];
+  for(const file of pythonFiles){const result=spawnSync('python3',['-B','-m','unittest','discover','-v','-s','tests','-p',path.basename(file)],{cwd:root,encoding:'utf8',env:{...process.env,PYTHONDONTWRITEBYTECODE:'1'}});if(result.status!==0)throw Error(`Preserved Python suite failed: ${file}\n${result.stderr}`);for(const d of all.filter(d=>d.file===file))if(!result.stderr.includes(`.${d.class}.${d.test}) ... ok`))throw Error(`Preserved destination did not execute: ${file}: ${d.class}.${d.test}`);}
+ }
+ console.log(`Parity verified: 236 original test IDs (${236-retiredIds} verified + ${retiredIds} retired), 739 test assertions (${739-retiredAssertions} verified + ${retiredAssertions} retired), 14 helper assertions${complete?'; all active mappings ran; every mapped Node and preserved Python test passed':''}`);
+}catch(error){console.error(error.message);process.exitCode=1;}

package/scripts/update-manifest.mjs

@@ -0,0 +1,28 @@
+import {isDynamicReferencePath} from '../lib/installer/superpowers.mjs';
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+const i = process.argv.indexOf('--root');
+const root = i < 0 ? fileURLToPath(new URL('../', import.meta.url)) : path.resolve(process.argv[i + 1]);
+const mutable = new Set(['codex/skill/models.toml', 'claude/skill/models.toml']);
+const excluded = new Set(['.DS_Store', '__pycache__', 'build']);
+const files = new Set();
+function visit(relative) {
+  if(isDynamicReferencePath(relative)) return;
+  const filename = path.join(root, relative);
+  if (!fs.existsSync(filename)) return;
+  const stat = fs.lstatSync(filename);
+  if (stat.isSymbolicLink()) throw new Error(`Protected payload contains symlink: ${relative}`);
+  if (stat.isDirectory()) {
+    for (const name of fs.readdirSync(filename).sort()) if (!excluded.has(name)) visit(`${relative}/${name}`);
+  } else if (stat.isFile() && !mutable.has(relative)) files.add(relative);
+  else if (!stat.isFile()) throw new Error(`Protected payload is not regular: ${relative}`);
+}
+for (const entry of ['README.md', 'install.command', 'package.json', 'bin', 'lib', 'native/binding.c', 'native/binding.gyp', 'scripts', 'vendor', 'prebuilds', 'codex/skill', 'codex/agents', 'claude/skill', 'claude/agents']) visit(entry);
+const content = [...files].sort().map(name => `${crypto.createHash('sha256').update(fs.readFileSync(path.join(root, name))).digest('hex')}  ${name}\n`).join('');
+const manifest = path.join(root, 'MANIFEST.sha256');
+if (process.argv.includes('--check')) {
+  if (!fs.existsSync(manifest) || fs.readFileSync(manifest, 'utf8') !== content) { console.error('Protected payload manifest is stale'); process.exitCode = 1; }
+  else console.log(`Protected payload manifest verified (${files.size} files)`);
+} else { fs.writeFileSync(manifest, content); console.log(`Updated manifest (${files.size} files)`); }

package/scripts/update-role-policy.mjs

@@ -0,0 +1,15 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {POLICY_TARGETS, buildPolicyOutputs} from '../lib/policy/render.mjs';
+try {
+  const args=process.argv.slice(2); let root=fileURLToPath(new URL('../',import.meta.url)),check=false;
+  while(args.length) {const arg=args.shift();if(arg==='--check'&&!check)check=true;else if(arg==='--root'&&args[0]&&!args[0].startsWith('--'))root=path.resolve(args.shift());else throw Error(`Unknown or incomplete option: ${arg}`);}
+  const policy=JSON.parse(fs.readFileSync(path.join(root,'lib/policy/role-policy.json'),'utf8'));
+  const inputs=new Map(POLICY_TARGETS.map(({path:name})=>[name,fs.readFileSync(path.join(root,name))]));
+  // All policy, UTF-8 and marker validation completes before the first write.
+  const outputs=buildPolicyOutputs(inputs,policy);
+  const changed=[...outputs].filter(([name,bytes])=>!bytes.equals(inputs.get(name)));
+  if(check) {if(changed.length){console.error(`Role policy outputs are stale: ${changed.map(([name])=>name).join(', ')}`);process.exitCode=1;}else console.log(`Role policy verified (${outputs.size} targets)`);}
+  else {for(const [name,bytes] of changed)fs.writeFileSync(path.join(root,name),bytes);console.log(`Updated role policy (${changed.length} targets)`);}
+} catch(error) {console.error(error.message);process.exitCode=1;}

package/scripts/update-superpowers.mjs

@@ -0,0 +1,4 @@
+import {fileURLToPath} from 'node:url';
+import {refreshPackageReferences} from '../lib/installer/package-references.mjs';
+const result=await refreshPackageReferences({packageRoot:fileURLToPath(new URL('../',import.meta.url))});
+console.log(`Updated superpowers references (${result.provenance.revision})`);

package/scripts/vendor-toml.mjs

@@ -0,0 +1,40 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+const i = process.argv.indexOf('--root');
+const root = i < 0 ? fileURLToPath(new URL('../', import.meta.url)) : path.resolve(process.argv[i + 1]);
+try {
+  const manifest = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+  const source = path.join(root, 'node_modules/smol-toml');
+  const sourceManifest = JSON.parse(fs.readFileSync(path.join(source, 'package.json'), 'utf8'));
+  if (!/^\d+\.\d+\.\d+$/.test(manifest.devDependencies?.['smol-toml'] ?? '') || sourceManifest.version !== manifest.devDependencies['smol-toml']) throw new Error('Vendor source must match the exact smol-toml dev dependency');
+  const expected = new Map();
+  const sourceFiles = {};
+  // This reproducible formatting adjustment changes no executable tokens in the
+  // pinned source. Preserve line endings and every non-JS file byte-for-byte.
+  const normalization = { javascript: 'strip-trailing-horizontal-whitespace-v1', pattern: '[ \\t]+(?=\\r?$)', flags: 'gm', preserveLineEndings: true };
+  for (const name of fs.readdirSync(path.join(source, 'dist')).sort()) if (name.endsWith('.js')) {
+    const original = fs.readFileSync(path.join(source, 'dist', name));
+    sourceFiles[`dist/${name}`] = crypto.createHash('sha256').update(original).digest('hex');
+    const text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(original);
+    expected.set(`dist/${name}`, Buffer.from(text.replace(/[ \t]+(?=\r?$)/gm, '')));
+  }
+  expected.set('LICENSE', fs.readFileSync(path.join(source, 'LICENSE')));
+  expected.set('package.json', Buffer.from(JSON.stringify({ name: 'smol-toml', version: sourceManifest.version, type: 'module', license: 'BSD-3-Clause' }, null, 2) + '\n'));
+  const hashes = Object.fromEntries([...expected].map(([name, data]) => [name, crypto.createHash('sha256').update(data).digest('hex')]));
+  const lockPath = path.join(root, 'package-lock.json');
+  const lock = fs.existsSync(lockPath) ? JSON.parse(fs.readFileSync(lockPath)) : undefined;
+  expected.set('provenance.json', Buffer.from(JSON.stringify({ name: 'smol-toml', version: sourceManifest.version, normalization, sourceFiles, integrity: lock?.packages?.['node_modules/smol-toml']?.integrity ?? null, files: hashes }, null, 2) + '\n'));
+  const destination = path.join(root, 'vendor/toml');
+  if (process.argv.includes('--check')) {
+    const actual = [];
+    function list(dir, relative = '') { if (!fs.existsSync(dir)) return; for (const entry of fs.readdirSync(dir, { withFileTypes: true })) { const name = relative + entry.name; if (entry.isDirectory()) list(path.join(dir, entry.name), `${name}/`); else actual.push(name); } }
+    list(destination);
+    if (actual.length !== expected.size || actual.some(name => !expected.has(name)) || [...expected].some(([name, bytes]) => !fs.existsSync(path.join(destination, name)) || !fs.readFileSync(path.join(destination, name)).equals(bytes))) throw new Error('Vendored TOML runtime differs from the exact pinned source');
+    console.log(`Vendored smol-toml ${sourceManifest.version} verified (${expected.size} files)`);
+  } else {
+    for (const [name, bytes] of expected) { const file = path.join(destination, name); fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, bytes); }
+    console.log(`Vendored smol-toml ${sourceManifest.version} (${expected.size} files)`);
+  }
+} catch (error) { console.error(error.message); process.exitCode = 1; }

package/vendor/toml/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) Squirrel Chat et al., All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.