create-agent-rig 0.9.1 → 0.10.1

package/packages/cli/dist/integrations/verify.js

@@ -0,0 +1,193 @@
+import { createHash } from 'node:crypto';
+import { constants } from 'node:fs';
+import { access, open, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { DECLARATION_REL, MAX_DECLARATION_BYTES, parseDeclaration } from './declaration.js';
+import { readMcpConfig } from './mcp-json.js';
+import { REGISTRY } from './registry.js';
+import { resolveReadableInside } from '../lib/safe-path.js';
+const MCP_REL = '.mcp.json';
+const CODEX_REL = '.codex/config.toml';
+const MAX_WIRING_BYTES = 64 * 1024;
+function sha256(value) {
+    const input = Buffer.isBuffer(value) ? value : JSON.stringify(value);
+    return createHash('sha256').update(input).digest('hex');
+}
+/** Read only regular, in-repository files and cap every allocation before I/O. */
+export async function readBounded(repoDir, rel, max) {
+    const resolved = await resolveReadableInside(repoDir, rel, 'file');
+    if (resolved.status === 'absent')
+        return { status: 'absent' };
+    if (resolved.status !== 'ok')
+        return { status: 'unsafe' };
+    const flags = constants.O_RDONLY |
+        (process.platform === 'win32' ? 0 : constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    let handle;
+    try {
+        handle = await open(resolved.path, flags);
+    }
+    catch {
+        return { status: 'unsafe' };
+    }
+    try {
+        const info = await handle.stat();
+        if (!info.isFile())
+            return { status: 'unsafe' };
+        if (info.size > max)
+            return { status: 'too-large' };
+        const bytes = Buffer.alloc(max + 1);
+        let offset = 0;
+        while (offset < bytes.length) {
+            const { bytesRead } = await handle.read(bytes, offset, bytes.length - offset, null);
+            if (bytesRead === 0)
+                break;
+            offset += bytesRead;
+        }
+        if (offset > max)
+            return { status: 'too-large' };
+        return { status: 'ok', bytes: bytes.subarray(0, offset) };
+    }
+    catch {
+        return { status: 'unsafe' };
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+}
+function decode(bytes) {
+    try {
+        return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        return null;
+    }
+}
+async function defaultLocateLauncher(name, env = process.env) {
+    const variable = env.PATH ?? env.Path;
+    if (variable === undefined)
+        return null;
+    for (const directory of variable.split(path.delimiter)) {
+        if (!path.isAbsolute(directory))
+            continue;
+        const candidate = path.join(directory, process.platform === 'win32' ? `${name}.exe` : name);
+        try {
+            // Follow a machine-installed launcher symlink, but never execute it.
+            if (!(await stat(candidate)).isFile())
+                continue;
+            await access(candidate, process.platform === 'win32' ? constants.F_OK : constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // A PATH member not present on this machine is not a diagnostic failure.
+        }
+    }
+    return null;
+}
+function verification(wiring, launcher) {
+    return {
+        wiring,
+        launcher,
+        runtime: 'unverified',
+        connectivity: 'not-observed',
+        trust: 'not-observed',
+    };
+}
+function mcpServerName(id) {
+    if (id === 'figma-mcp')
+        return 'figma';
+    if (id === 'atlassian-mcp')
+        return 'atlassian';
+    if (id === 'basic-memory')
+        return 'basic-memory';
+    return undefined;
+}
+/**
+ * Pure doctor surface for Rig-owned wiring. It deliberately neither starts a
+ * launcher nor connects to a provider, so launcher presence is only observed
+ * and provider runtime/connectivity/trust remain unverified.
+ */
+export async function verifyIntegrations(options) {
+    const declaration = await readBounded(options.repoDir, DECLARATION_REL, MAX_DECLARATION_BYTES);
+    if (declaration.status === 'absent')
+        return { integrations: [], issues: [{ scope: 'declaration', status: 'missing' }] };
+    if (declaration.status !== 'ok')
+        return { integrations: [], issues: [{ scope: 'declaration', status: 'invalid' }] };
+    const declarationText = decode(declaration.bytes);
+    if (declarationText === null)
+        return { integrations: [], issues: [{ scope: 'declaration', status: 'invalid' }] };
+    const parsed = parseDeclaration(declarationText, REGISTRY);
+    if (parsed.status === 'invalid')
+        return { integrations: [], issues: [{ scope: 'declaration', status: 'invalid' }] };
+    const issues = parsed.rejected.map(({ reason }) => ({
+        scope: 'integration',
+        status: 'rejected',
+        reason,
+    }));
+    const claudeFile = await readBounded(options.repoDir, MCP_REL, MAX_WIRING_BYTES);
+    let claudeServers;
+    if (claudeFile.status === 'ok') {
+        const text = decode(claudeFile.bytes);
+        if (text !== null) {
+            try {
+                claudeServers = readMcpConfig(text).mcpServers;
+            }
+            catch {
+                // The status below reports drift without echoing untrusted JSON.
+            }
+        }
+    }
+    const codexFile = await readBounded(options.repoDir, CODEX_REL, MAX_WIRING_BYTES);
+    const codexHash = codexFile.status === 'ok' ? sha256(codexFile.bytes) : undefined;
+    const locator = options.locateLauncher ?? ((name) => defaultLocateLauncher(name, options.env));
+    const integrations = [];
+    for (const entry of parsed.entries) {
+        const harnesses = {};
+        for (const harness of entry.harnesses ?? []) {
+            if (harness === 'claude-code') {
+                const entryHash = entry.targets?.['claude-code']?.entryHash;
+                const name = mcpServerName(entry.id);
+                let wiring;
+                if (entryHash === undefined)
+                    wiring = 'unowned';
+                else if (claudeFile.status === 'absent')
+                    wiring = 'missing';
+                else if (claudeServers === undefined)
+                    wiring = 'unreadable';
+                else if (name === undefined)
+                    wiring = 'unowned';
+                else if (!(name in claudeServers))
+                    wiring = 'missing';
+                else
+                    wiring = sha256(claudeServers[name]) === entryHash ? 'healthy' : 'drift';
+                let launcher = 'not-applicable';
+                if (entry.id === 'basic-memory' && wiring === 'healthy')
+                    launcher = (await locator('uvx')) === null ? 'missing' : 'observed';
+                harnesses[harness] = verification(wiring, launcher);
+                if (wiring === 'unreadable')
+                    harnesses[harness].reason =
+                        claudeFile.status === 'ok' ? 'invalid-config' : 'unsafe-or-too-large';
+                continue;
+            }
+            const expectedHash = parsed.targets?.codex?.fileHash;
+            const wiring = expectedHash === undefined
+                ? 'unowned'
+                : codexFile.status === 'absent'
+                    ? 'missing'
+                    : codexFile.status !== 'ok'
+                        ? 'unreadable'
+                        : codexHash === expectedHash
+                            ? 'healthy'
+                            : 'drift';
+            const launcher = entry.id === 'basic-memory' && wiring === 'healthy'
+                ? (await locator('uvx')) === null
+                    ? 'missing'
+                    : 'observed'
+                : 'not-applicable';
+            harnesses[harness] = verification(wiring, launcher);
+            if (wiring === 'unreadable')
+                harnesses[harness].reason = 'unsafe-or-too-large';
+        }
+        integrations.push({ id: entry.id, harnesses });
+    }
+    return { integrations, issues };
+}

package/packages/cli/dist/integrations/windows-job.js

@@ -0,0 +1,275 @@
+// Fixed Windows-only supervisor. The payload is constructed by a compiled
+// adapter; repository declarations never reach this script as executable code.
+export const WINDOWS_JOB_SUPERVISOR = String.raw `
+$ErrorActionPreference = 'Stop'
+$source = @'
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+
+public static class RigJob
+{
+    const uint EXTENDED_STARTUPINFO_PRESENT = 0x00080000;
+    const uint JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x00002000;
+    const int JobObjectExtendedLimitInformation = 9;
+    const int JobObjectBasicAccountingInformation = 1;
+    const int JobObjectAssociateCompletionPortInformation = 7;
+    static readonly IntPtr PROC_THREAD_ATTRIBUTE_JOB_LIST = (IntPtr)0x0002000D;
+    const uint INFINITE = 0xffffffff;
+    const uint JOB_OBJECT_MSG_NEW_PROCESS = 6;
+    const uint JOB_OBJECT_MSG_EXIT_PROCESS = 7;
+    const uint JOB_OBJECT_MSG_ABNORMAL_EXIT_PROCESS = 8;
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    struct STARTUPINFO
+    {
+        public int cb;
+        public string lpReserved, lpDesktop, lpTitle;
+        public int dwX, dwY, dwXSize, dwYSize, dwXCountChars, dwYCountChars, dwFillAttribute, dwFlags;
+        public short wShowWindow, cbReserved2;
+        public IntPtr lpReserved2, hStdInput, hStdOutput, hStdError;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct STARTUPINFOEX
+    {
+        public STARTUPINFO StartupInfo;
+        public IntPtr lpAttributeList;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct PROCESS_INFORMATION
+    {
+        public IntPtr hProcess, hThread;
+        public int dwProcessId, dwThreadId;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct JOBOBJECT_BASIC_LIMIT_INFORMATION
+    {
+        public long PerProcessUserTimeLimit, PerJobUserTimeLimit;
+        public uint LimitFlags;
+        public UIntPtr MinimumWorkingSetSize, MaximumWorkingSetSize;
+        public uint ActiveProcessLimit;
+        public IntPtr Affinity;
+        public uint PriorityClass, SchedulingClass;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct IO_COUNTERS
+    {
+        public ulong ReadOperationCount, WriteOperationCount, OtherOperationCount;
+        public ulong ReadTransferCount, WriteTransferCount, OtherTransferCount;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION
+    {
+        public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
+        public IO_COUNTERS IoInfo;
+        public UIntPtr ProcessMemoryLimit, JobMemoryLimit, PeakProcessMemoryUsed, PeakJobMemoryUsed;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct JOBOBJECT_BASIC_ACCOUNTING_INFORMATION
+    {
+        public long TotalUserTime, TotalKernelTime, ThisPeriodTotalUserTime, ThisPeriodTotalKernelTime;
+        public uint TotalPageFaultCount, TotalProcesses, ActiveProcesses, TotalTerminatedProcesses;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct JOBOBJECT_ASSOCIATE_COMPLETION_PORT
+    {
+        public IntPtr CompletionKey;
+        public IntPtr CompletionPort;
+    }
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    static extern IntPtr CreateJobObject(IntPtr attributes, string name);
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern bool SetInformationJobObject(IntPtr job, int infoClass, IntPtr info, int length);
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern bool QueryInformationJobObject(IntPtr job, int infoClass,
+        out JOBOBJECT_BASIC_ACCOUNTING_INFORMATION info, int length, IntPtr returnLength);
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern IntPtr CreateIoCompletionPort(IntPtr fileHandle, IntPtr existingPort,
+        IntPtr completionKey, uint threads);
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern bool GetQueuedCompletionStatus(IntPtr port, out uint bytes,
+        out IntPtr completionKey, out IntPtr overlapped, uint milliseconds);
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern bool InitializeProcThreadAttributeList(IntPtr list, int count, int flags, ref IntPtr size);
+    [DllImport("kernel32.dll")]
+    static extern void DeleteProcThreadAttributeList(IntPtr list);
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern bool UpdateProcThreadAttribute(IntPtr list, uint flags, IntPtr attribute,
+        IntPtr value, IntPtr size, IntPtr previous, IntPtr returnSize);
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    static extern bool CreateProcess(string application, StringBuilder commandLine,
+        IntPtr processAttributes, IntPtr threadAttributes, bool inheritHandles, uint flags,
+        IntPtr environment, string currentDirectory, ref STARTUPINFOEX startupInfo,
+        out PROCESS_INFORMATION processInformation);
+    [DllImport("kernel32.dll")]
+    static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
+    [DllImport("kernel32.dll", SetLastError = true)]
+    static extern bool GetExitCodeProcess(IntPtr process, out uint exitCode);
+    [DllImport("kernel32.dll")]
+    static extern bool CloseHandle(IntPtr handle);
+
+    static void Check(bool value)
+    {
+        if (!value) throw new Win32Exception(Marshal.GetLastWin32Error());
+    }
+
+    public static string Quote(string value)
+    {
+        var result = new StringBuilder("\"");
+        int slashes = 0;
+        foreach (char character in value)
+        {
+            if (character == '\\') { slashes++; continue; }
+            result.Append('\\', character == '"' ? slashes * 2 + 1 : slashes);
+            result.Append(character);
+            slashes = 0;
+        }
+        result.Append('\\', slashes * 2);
+        result.Append('"');
+        return result.ToString();
+    }
+
+    static IntPtr CreateJob(IntPtr port)
+    {
+        IntPtr job = CreateJobObject(IntPtr.Zero, null);
+        if (job == IntPtr.Zero) throw new Win32Exception(Marshal.GetLastWin32Error());
+        var limits = new JOBOBJECT_EXTENDED_LIMIT_INFORMATION();
+        limits.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
+        int size = Marshal.SizeOf(limits);
+        IntPtr buffer = Marshal.AllocHGlobal(size);
+        try
+        {
+            Marshal.StructureToPtr(limits, buffer, false);
+            Check(SetInformationJobObject(job, JobObjectExtendedLimitInformation, buffer, size));
+            var association = new JOBOBJECT_ASSOCIATE_COMPLETION_PORT();
+            association.CompletionKey = (IntPtr)1;
+            association.CompletionPort = port;
+            int associationSize = Marshal.SizeOf(association);
+            IntPtr associationBuffer = Marshal.AllocHGlobal(associationSize);
+            try
+            {
+                Marshal.StructureToPtr(association, associationBuffer, false);
+                Check(SetInformationJobObject(job, JobObjectAssociateCompletionPortInformation,
+                    associationBuffer, associationSize));
+            }
+            finally { Marshal.FreeHGlobal(associationBuffer); }
+            return job;
+        }
+        catch
+        {
+            CloseHandle(job);
+            throw;
+        }
+        finally { Marshal.FreeHGlobal(buffer); }
+    }
+
+    static int DrainEvents(IntPtr port, int members)
+    {
+        uint message;
+        IntPtr key, process;
+        while (GetQueuedCompletionStatus(port, out message, out key, out process, 0))
+        {
+            if (message == JOB_OBJECT_MSG_NEW_PROCESS) members++;
+            if (message == JOB_OBJECT_MSG_EXIT_PROCESS ||
+                message == JOB_OBJECT_MSG_ABNORMAL_EXIT_PROCESS) members--;
+        }
+        return members;
+    }
+
+    // The JOB_LIST attribute is attached to CreateProcess itself, so there is
+    // no created-but-unassigned provider interval for a helper kill to expose.
+    static PROCESS_INFORMATION CreateInJob(IntPtr job, string executable, string command, string cwd)
+    {
+        IntPtr attributeList = IntPtr.Zero;
+        IntPtr jobList = IntPtr.Zero;
+        bool initialized = false;
+        try
+        {
+            IntPtr attributeBytes = IntPtr.Zero;
+            InitializeProcThreadAttributeList(IntPtr.Zero, 1, 0, ref attributeBytes);
+            if (attributeBytes == IntPtr.Zero) throw new Win32Exception(Marshal.GetLastWin32Error());
+            attributeList = Marshal.AllocHGlobal(attributeBytes);
+            Check(InitializeProcThreadAttributeList(attributeList, 1, 0, ref attributeBytes));
+            initialized = true;
+            jobList = Marshal.AllocHGlobal(IntPtr.Size);
+            Marshal.WriteIntPtr(jobList, job);
+            Check(UpdateProcThreadAttribute(attributeList, 0, PROC_THREAD_ATTRIBUTE_JOB_LIST,
+                jobList, (IntPtr)IntPtr.Size, IntPtr.Zero, IntPtr.Zero));
+            var startup = new STARTUPINFOEX();
+            startup.StartupInfo.cb = Marshal.SizeOf(typeof(STARTUPINFOEX));
+            startup.lpAttributeList = attributeList;
+            PROCESS_INFORMATION process;
+            Check(CreateProcess(executable, new StringBuilder(command), IntPtr.Zero, IntPtr.Zero,
+                true, EXTENDED_STARTUPINFO_PRESENT, IntPtr.Zero, cwd, ref startup, out process));
+            return process;
+        }
+        finally
+        {
+            if (initialized) DeleteProcThreadAttributeList(attributeList);
+            if (attributeList != IntPtr.Zero) Marshal.FreeHGlobal(attributeList);
+            if (jobList != IntPtr.Zero) Marshal.FreeHGlobal(jobList);
+        }
+    }
+
+    public static int Run(string executable, string command, string cwd)
+    {
+        IntPtr port = CreateIoCompletionPort((IntPtr)(-1), IntPtr.Zero, IntPtr.Zero, 1);
+        if (port == IntPtr.Zero) throw new Win32Exception(Marshal.GetLastWin32Error());
+        IntPtr job = IntPtr.Zero;
+        int members = 0;
+        try
+        {
+            job = CreateJob(port);
+            PROCESS_INFORMATION process = CreateInJob(job, executable, command, cwd);
+            try
+            {
+                WaitForSingleObject(process.hProcess, INFINITE);
+                members = DrainEvents(port, members);
+                uint exitCode;
+                Check(GetExitCodeProcess(process.hProcess, out exitCode));
+                JOBOBJECT_BASIC_ACCOUNTING_INFORMATION accounting;
+                do
+                {
+                    Check(QueryInformationJobObject(job, JobObjectBasicAccountingInformation,
+                        out accounting, Marshal.SizeOf(typeof(JOBOBJECT_BASIC_ACCOUNTING_INFORMATION)),
+                        IntPtr.Zero));
+                    if (accounting.ActiveProcesses != 0) Thread.Sleep(10);
+                } while (accounting.ActiveProcesses != 0);
+                // Give job notifications already queued by a just-exited root
+                // one bounded scheduling turn before accepting active-zero.
+                Thread.Sleep(20);
+                members = DrainEvents(port, members);
+                return members == 0 ? unchecked((int)exitCode) : 125;
+            }
+            finally
+            {
+                CloseHandle(process.hThread);
+                CloseHandle(process.hProcess);
+            }
+        }
+        finally
+        {
+            if (job != IntPtr.Zero) CloseHandle(job);
+            CloseHandle(port);
+        }
+    }
+}
+'@
+Add-Type -TypeDefinition $source -Language CSharp
+$payload = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($env:RIG_WINDOWS_JOB_PAYLOAD)) | ConvertFrom-Json
+$exe = [string]$payload.executable
+$cwd = [string]$payload.cwd
+$parts = @($payload.args | ForEach-Object { [RigJob]::Quote([string]$_) })
+$command = ([RigJob]::Quote($exe)) + (($parts | ForEach-Object { ' ' + $_ }) -join '')
+exit [RigJob]::Run($exe, $command, $cwd)
+`;

package/packages/cli/dist/lib/elevated-paths.js

@@ -0,0 +1,74 @@
+/**
+ * Mirrors `parseElevatedPaths` in
+ * `templates/agent-os/universal/.claude/scripts/detect-missed-gate.mjs` —
+ * the gate sweep's own parser for the fenced ```elevated-paths block a
+ * rulebook file declares. Kept in step with it by a correspondence test
+ * (`packages/cli/test/elevated-paths-correspondence.test.ts`) that feeds the
+ * same literal fixtures to both and fails the moment they disagree, rather
+ * than by a shared import — the `.mjs` is the gate sweep's own copy, shipped
+ * into every generated rig, and this file is the generator's own, used only
+ * to DECIDE whether `upgrade` can trust an on-disk AGENTS.md as a rulebook
+ * (round 5, design ruling replacing round 4's verdict-only rule). Two
+ * different consumers, one semantics, proven equal rather than assumed so.
+ *
+ * Bounded, one forward pass: a hostile or merely enormous AGENTS.md cannot
+ * make this cost more than a fixed amount of work. The cap is applied BEFORE
+ * the regex ever runs, so the single `matchAll` pass is always over a string
+ * no longer than {@link ELEVATED_PATHS_SCAN_CAP}, never proportional to an
+ * attacker-chosen input size.
+ */
+export const ELEVATED_PATHS_SCAN_CAP = 1_000_000;
+/**
+ * Normalise a path so both sides of a comparison agree — identical to the
+ * `.mjs` sweep's own `normalizePath`, restated here because the correspondence
+ * test proves the two produce the same answer rather than sharing an import.
+ */
+export function normalizeElevatedPath(path) {
+    return String(path ?? '')
+        .replace(/\\/g, '/')
+        .replace(/\/{2,}/g, '/')
+        .replace(/^\.\//, '')
+        .replace(/^\//, '');
+}
+/**
+ * Every declared path across every ```elevated-paths block in `markdown`, or
+ * `null` when there is no such block at all. An empty array (block present,
+ * nothing left after stripping comments and blank lines) is a real, distinct
+ * answer from `null` — round 5's own trigger: a hostile or stale
+ * `elevated-paths` block with only a comment ("Everything is Tier 0") parses
+ * to `[]`, and {@link isReadableRulebook} treats that exactly like no block
+ * at all, never like a real declaration.
+ *
+ * State limit, tested rather than merely claimed: content beyond
+ * {@link ELEVATED_PATHS_SCAN_CAP} characters is never read at all — a block
+ * that starts after the cap, or a path line that straddles it, is invisible
+ * to this function. `elevated-paths-correspondence.test.ts` pins this pair:
+ * a fixture within the cap agrees with the `.mjs` sweep (which has no cap),
+ * and the cap's own behaviour on an over-limit fixture is tested against
+ * this function alone, never against the `.mjs` (which would legitimately
+ * disagree there — the cap is this file's own limit, not a shared one).
+ */
+export function parseElevatedPaths(markdown) {
+    const text = String(markdown ?? '');
+    const bounded = text.length > ELEVATED_PATHS_SCAN_CAP ? text.slice(0, ELEVATED_PATHS_SCAN_CAP) : text;
+    const blocks = [...bounded.matchAll(/```elevated-paths\r?\n([\s\S]*?)```/g)];
+    if (blocks.length === 0)
+        return null;
+    return blocks.flatMap((block) => (block[1] ?? '')
+        .split('\n')
+        // An inline comment after the path is a comment, not part of the path.
+        .map((line) => normalizeElevatedPath(line.replace(/\s+#.*$/, '').trim()))
+        .filter((line) => line.length > 0 && !line.startsWith('#')));
+}
+/**
+ * Round 5's content-based hold-back rule (replacing round 4's verdict-only
+ * rule): whether `content` can serve as the rulebook AGENTS.md is meant to
+ * be — at least one non-empty, non-comment path declared in a fenced
+ * ```elevated-paths block. Absence of the FILE is decided by the caller
+ * (`upgrade.ts`'s `deleted` verdict); this only ever judges bytes that are
+ * actually present.
+ */
+export function isReadableRulebook(content) {
+    const parsed = parseElevatedPaths(content);
+    return parsed !== null && parsed.length > 0;
+}

package/packages/cli/dist/lib/install-set.js

@@ -1,44 +1 @@
-import { readFile } from 'node:fs/promises';
-import { listTreeEntries, mapConcurrent } from './copy-tree.js';
-import { substituteContent, substituteFileName } from './substitute.js';
-import { agentOsStackDir, agentOsUniversalDir } from '../templates.js';
-/**
- * The agent-os layers of a target, in composition order. One definition, read
- * by `create` when it copies them and by `upgrade` when it refreshes them —
- * two lists would drift, and the one nobody looks at would be the wrong one.
- */
-export function agentOsLayerDirs(stacks) {
-    return [
-        { name: 'agent-os/universal', dir: agentOsUniversalDir() },
-        ...stacks.map((stack) => ({ name: `agent-os/stack/${stack}`, dir: agentOsStackDir(stack) })),
-    ];
-}
-/**
- * Exactly the agent-os bytes `create` writes, for a given target and project.
- *
- * The skeleton is deliberately absent: after generation the code is the user's
- * project, not the rig's — `upgrade` refreshes the process layer and nothing
- * else. Layers claim disjoint paths (`composition.ts` refuses otherwise), so
- * this is a plain concatenation.
- *
- * 🔴 Two assumptions, both load-bearing and both true today: the layer is all
- * **text** (this reads every file as UTF-8; a template test pins it for the
- * process half) and none of it is **executable** (`upgrade` writes with a bare
- * `writeFile` and does not carry the mode across the way `copyTree` does —
- * nothing in `templates/agent-os` currently has a mode to carry). Adding the
- * first binary asset or executable script here means teaching both.
- */
-export async function agentOsInstallSet(stacks, ctx) {
-    const files = [];
-    for (const layer of agentOsLayerDirs(stacks)) {
-        const entries = await listTreeEntries(layer.dir, {
-            transformName: (name) => substituteFileName(name, ctx),
-        });
-        files.push(...(await mapConcurrent(entries, 16, async (entry) => ({
-            rel: entry.rel,
-            source: entry.source,
-            content: substituteContent(await readFile(entry.source, 'utf8'), ctx),
-        }))));
-    }
-    return files;
-}
+export {};