create-agent-rig 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Serhii
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,87 @@
+# create-agent-rig
+
+Scaffold a project that ships with an **agent operating system** — rules,
+gates, and hooks that hold the architecture mechanically, not by prose.
+
+```sh
+npx create-agent-rig my-app
+```
+
+## What you get
+
+**A system of boundaries, each held by tooling.** An agent (or a human using
+one) cannot talk its way past them:
+
+- **`guard-core-purity`** — refuses any edit that puts I/O, clock, randomness,
+  or environment access into the pure domain core;
+- **`guard-web-boundary`** — refuses `db`/service imports from the frontend;
+  the web talks to the backend over HTTP only;
+- **`block-no-verify`** — refuses bypassing pre-commit checks (and knows the
+  difference between using the flag and merely mentioning it in a message).
+
+Around the hooks, the operating system: **autonomy tiers** (what an agent does
+alone / after review / never), **stop rules** (three strikes, flaky ≠ retry,
+session staleness), **subagent gates** (`test-writer`, `code-reviewer`,
+`security-scanner`, `cdk-diff-reviewer`), **skills** (`pr-ship` pre-merge
+gate; `post-deploy-verify` with its binary HEALTHY/REGRESSION verdict), and a
+one-page `CLAUDE.md` map a fresh session orients by.
+
+The skeleton around it is real and runnable — pure core shared by server _and_
+browser (one schema validates on both sides of the wire), a mandatory usecase
+layer, a queue with DLQ discipline, tests at every layer.
+
+## Targets
+
+| Target           | One line                                                                                                                                  |
+| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
+| `aws-serverless` | DynamoDB single-table, SQS + DLQ + alarm, three Lambdas behind an HTTP API, static web via S3 + CloudFront, CDK with least-privilege IAM  |
+| `node-service`   | `node:http` server that also serves the web bundle, JSON-file store behind the same model boundary, spool-directory queue, worker process |
+
+Coherent alternatives, not a parameterized abstraction. Flexibility is
+**subtraction**: the generated project is yours — delete what you don't need.
+
+## What it deliberately does not do
+
+No authentication. No design system or UI kit. No state manager. No i18n,
+analytics, or error tracking. No third cloud. No component-testing apparatus.
+
+Each of these is application surface, not an architecture proof — and every
+addition is permanent maintenance in every target. The frontend is plain on
+purpose: scaffolding gets replaced without friction; a finished-looking UI
+gets fought. If you need one of these, add it — the project is yours.
+
+## The 2-minute demo
+
+```sh
+./demo.sh   # from a clone of this repo
+```
+
+generate → the generated project's own gates pass → **an attempted core-purity
+violation is refused live by the hook** → the service runs, a smoke request
+travels every layer, the worker drains the queue, the DLQ stays empty:
+
+```
+== 3/4 an agent tries to put I/O and clock access into the pure core… ==
+BLOCKED — packages/core is a pure module and this change breaks its purity:
+  - imports "node:fs/promises" — the core may import only its own modules and: zod
+  - reads the clock — take a timestamp as an argument
+Move the impure part behind the usecase layer or into an adapter.
+…and the guard-core-purity hook REFUSED the edit at the tool layer (exit 2). ✔
+```
+
+## Requirements
+
+- Node ≥ 20 (pnpm recommended for the generated workspace)
+
+## How it stays honest
+
+Every template is a real project tested in place on every push; every e2e run
+generates a project cold and runs the generated project's own full checks
+(install → lint → typecheck → test → build → synth); a grep-test keeps the
+universal rules free of any provider mention; the hook-blocking behavior
+itself is under test; and a weekly lockfile-free run catches upstream breakage
+early. This repo dogfoods its own rulebook — `CLAUDE.md` and `.claude/` are
+composed from the templates, and drift fails the suite.
+
+Development: `pnpm test` (full), `pnpm test:unit` (fast loop),
+`pnpm template:check` (templates in place). The plan of record is `PLAN.md`.

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "create-agent-rig",
+  "version": "0.1.0",
+  "description": "Scaffold a new project with an agent operating system (rules, gates, hooks) and a runnable code skeleton",
+  "keywords": [
+    "create",
+    "scaffold",
+    "generator",
+    "starter",
+    "template",
+    "agent",
+    "claude-code",
+    "agent-os",
+    "aws-serverless",
+    "node-service"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "create-agent-rig": "packages/cli/dist/index.js"
+  },
+  "files": [
+    "packages/cli/dist",
+    "templates",
+    "scripts/prepare.mjs"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "packageManager": "pnpm@11.16.0",
+  "scripts": {
+    "prepare": "node scripts/prepare.mjs",
+    "build": "tsc -p packages/cli/tsconfig.build.json",
+    "lint": "eslint . && prettier --check .",
+    "format": "prettier --write .",
+    "typecheck": "tsc -p packages/cli/tsconfig.json && tsc -p tsconfig.json",
+    "test": "pnpm build && vitest run",
+    "test:unit": "vitest run --project unit --project template",
+    "test:e2e": "pnpm build && vitest run --project e2e",
+    "template:install": "pnpm --dir templates/skeleton/aws-serverless install",
+    "template:check": "pnpm --dir templates/skeleton/aws-serverless run check"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^26.1.1",
+    "eslint": "^10.7.0",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^17.7.0",
+    "prettier": "^3.9.6",
+    "typescript": "~6.0.3",
+    "typescript-eslint": "^8.65.0",
+    "vitest": "^4.1.10"
+  }
+}

package/packages/cli/dist/commands/create.js

@@ -0,0 +1,109 @@
+import { execFile } from 'node:child_process';
+import { mkdir, readdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { copyTree, listTree } from '../lib/copy-tree.js';
+import { ALLOWED_OVERWRITES, detectCollisions } from '../lib/composition.js';
+import { substituteContent, substituteFileName } from '../lib/substitute.js';
+import { DEFAULT_TARGET, TARGETS, TARGET_NAMES } from '../lib/targets.js';
+import { agentOsStackDir, agentOsUniversalDir, skeletonDir } from '../templates.js';
+/** A user-facing failure: message is printed as-is, no stack trace. */
+export class CreateError extends Error {
+}
+/** Valid npm package name (unscoped part) — also used as the npm scope. */
+const NAME_PATTERN = /^[a-z0-9][a-z0-9._-]*$/;
+export async function createProject(dirArg, options) {
+    const projectDir = path.resolve(options.cwd, dirArg);
+    const projectName = path.basename(projectDir);
+    if (!NAME_PATTERN.test(projectName)) {
+        throw new CreateError(`Invalid project name "${projectName}": use lowercase letters, digits, ".", "_" and "-" ` +
+            '(it becomes the npm package name and scope).');
+    }
+    await ensureEmptyOrAbsent(projectDir);
+    const targetName = options.target ?? DEFAULT_TARGET;
+    const target = TARGETS[targetName];
+    if (!target) {
+        throw new CreateError(`Unknown target "${targetName}". Known targets: ${TARGET_NAMES.join(', ')}.`);
+    }
+    const ctx = {
+        projectName,
+        projectScope: projectName,
+        region: target.defaultRegion ?? '',
+    };
+    const transforms = {
+        transformContent: (content) => substituteContent(content, ctx),
+        transformName: (name) => substituteFileName(name, ctx),
+    };
+    // Layer 2 (the skeleton) + layer 1 (agent-os: universal + stack overlays).
+    const layers = [
+        { name: `skeleton/${target.skeletonDir}`, dir: skeletonDir(target.skeletonDir) },
+        { name: 'agent-os/universal', dir: agentOsUniversalDir() },
+        ...target.stacks.map((stack) => ({
+            name: `agent-os/stack/${stack}`,
+            dir: agentOsStackDir(stack),
+        })),
+    ];
+    // Composition safety: layers must claim disjoint paths. Checked before any
+    // copy — a collision is a template bug and must never be resolved by order.
+    const claimed = [];
+    for (const layer of layers) {
+        claimed.push({ name: layer.name, files: await listTree(layer.dir, transforms) });
+    }
+    const collisions = detectCollisions(claimed, ALLOWED_OVERWRITES);
+    if (collisions.length > 0) {
+        const detail = collisions
+            .map((c) => `  ${c.path} — claimed by ${c.layers.join(' and ')}`)
+            .join('\n');
+        throw new CreateError(`Template layers collide (fix the templates, not the order):\n${detail}`);
+    }
+    await mkdir(projectDir, { recursive: true });
+    for (const layer of layers) {
+        await copyTree(layer.dir, projectDir, transforms);
+    }
+    if (options.git !== false) {
+        await initGitBaseline(projectDir);
+    }
+    return { projectDir, projectName };
+}
+const run = promisify(execFile);
+async function initGitBaseline(projectDir) {
+    try {
+        await run('git', ['init', '--quiet'], { cwd: projectDir });
+        await run('git', ['add', '-A'], { cwd: projectDir });
+        // Explicit identity: the baseline must commit even where git has no
+        // global user configured (fresh machines, CI). --no-verify here shields
+        // the baseline from the USER'S global hooks only — the generated
+        // project's own gates do not exist yet, so nothing is being bypassed.
+        await run('git', [
+            '-c',
+            'user.name=create-agent-rig',
+            '-c',
+            'user.email=create-agent-rig@localhost',
+            'commit',
+            '--quiet',
+            '--no-verify',
+            '-m',
+            'Pristine template (create-agent-rig)',
+        ], { cwd: projectDir });
+    }
+    catch {
+        // git missing or unusable — generation never fails on this.
+    }
+}
+async function ensureEmptyOrAbsent(dir) {
+    let stats;
+    try {
+        stats = await stat(dir);
+    }
+    catch {
+        return; // does not exist — fine
+    }
+    if (!stats.isDirectory()) {
+        throw new CreateError(`Target "${dir}" exists and is not a directory.`);
+    }
+    const entries = await readdir(dir);
+    if (entries.length > 0) {
+        throw new CreateError(`Target directory "${dir}" is not empty (${entries.length} entries). ` +
+            'Choose a new directory — the generator never overwrites existing files.');
+    }
+}

package/packages/cli/dist/index.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseArgs } from 'node:util';
+import { CreateError, createProject } from './commands/create.js';
+import { makePalette } from './lib/colors.js';
+import { promptTarget } from './lib/prompts.js';
+import { collectGovernance, renderSummary } from './lib/summary.js';
+import { DEFAULT_TARGET, TARGET_NAMES } from './lib/targets.js';
+const USAGE = `Usage: create-agent-rig <dir> [options]
+
+Scaffolds a new project into <dir>: agent operating system (.claude/, CLAUDE.md)
+plus a runnable code skeleton. Refuses to write into a non-empty directory.
+
+Options
+  --target <name>   ${TARGET_NAMES.join(' | ')}
+                    (interactive selection when omitted on a terminal;
+                    required when not a terminal — default: ${DEFAULT_TARGET})
+  --no-git          skip git init + the pristine-template baseline commit
+  --no-color        plain output (NO_COLOR is respected too)
+  --version         print the version
+  -h, --help        this text`;
+async function packageVersion() {
+    // dist/index.js lives three levels under the package root — same walk as
+    // the templates resolver, valid in the repo and in the published package.
+    const pkgPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'package.json');
+    const pkg = JSON.parse(await readFile(pkgPath, 'utf8'));
+    return pkg.version;
+}
+async function main() {
+    let positionals;
+    let values;
+    try {
+        ({ positionals, values } = parseArgs({
+            args: process.argv.slice(2),
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                target: { type: 'string' },
+                version: { type: 'boolean' },
+                'no-git': { type: 'boolean' },
+                'no-color': { type: 'boolean' },
+            },
+            allowPositionals: true,
+        }));
+    }
+    catch (error) {
+        process.stderr.write(`${error.message}\n\n${USAGE}\n`);
+        return 1;
+    }
+    if (values.version) {
+        process.stdout.write(`${await packageVersion()}\n`);
+        return 0;
+    }
+    if (values.help) {
+        process.stdout.write(`${USAGE}\n`);
+        return 0;
+    }
+    const dirArg = positionals[0];
+    if (!dirArg || positionals.length > 1) {
+        process.stderr.write(`${USAGE}\n`);
+        return 1;
+    }
+    // Non-TTY correctness (polish brief §5): never prompt into a pipe — a
+    // prompt would hang CI. Non-interactive runs must state the target.
+    const isInteractive = Boolean(process.stdin.isTTY && process.stderr.isTTY);
+    let target = values.target;
+    if (!target) {
+        if (!isInteractive) {
+            process.stderr.write(`Missing --target in a non-interactive run. ` +
+                `Pass --target <${TARGET_NAMES.join('|')}>.\n`);
+            return 1;
+        }
+        target = await promptTarget(TARGET_NAMES, DEFAULT_TARGET, {
+            input: process.stdin,
+            output: process.stderr,
+            isInteractive,
+        });
+    }
+    const { projectDir, projectName } = await createProject(dirArg, {
+        cwd: process.cwd(),
+        target,
+        git: values['no-git'] !== true,
+    });
+    const palette = makePalette(Boolean(process.stdout.isTTY) && !process.env.NO_COLOR && values['no-color'] !== true);
+    const summary = await collectGovernance(projectDir);
+    process.stdout.write('\n' + renderSummary(projectName, target, dirArg, summary, palette));
+    return 0;
+}
+main()
+    .then((code) => {
+    process.exitCode = code;
+})
+    .catch((error) => {
+    if (error instanceof CreateError) {
+        process.stderr.write(`${error.message}\n`);
+    }
+    else {
+        console.error(error); // unexpected: the trace is the diagnostic
+    }
+    process.exitCode = 1;
+});

package/packages/cli/dist/lib/colors.js

@@ -0,0 +1,14 @@
+const wrap = (open, close) => (text) => `[${open}m${text}[${close}m`;
+const COLORED = {
+    accent: wrap('36', '39'), // cyan
+    dim: wrap('2', '22'),
+    red: wrap('31', '39'),
+};
+const PLAIN = {
+    accent: (text) => text,
+    dim: (text) => text,
+    red: (text) => text,
+};
+export function makePalette(enabled) {
+    return enabled ? COLORED : PLAIN;
+}

package/packages/cli/dist/lib/composition.js

@@ -0,0 +1,20 @@
+/**
+ * Layer-composition policy (PLAN phase 9): layers must claim disjoint paths.
+ * A collision is refused, never resolved silently by copy order. Intended
+ * overwrites — if one ever becomes necessary — are declared here, visibly,
+ * not implied by ordering.
+ */
+export const ALLOWED_OVERWRITES = new Set([]);
+export function detectCollisions(layers, allowed) {
+    const claims = new Map();
+    for (const layer of layers) {
+        for (const file of layer.files) {
+            const owners = claims.get(file) ?? [];
+            owners.push(layer.name);
+            claims.set(file, owners);
+        }
+    }
+    return [...claims]
+        .filter(([file, owners]) => owners.length > 1 && !allowed.has(file))
+        .map(([file, owners]) => ({ path: file, layers: owners }));
+}

package/packages/cli/dist/lib/copy-tree.js

@@ -0,0 +1,91 @@
+import { chmod, copyFile, mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+/** Entry names never copied out of a template (local artifacts, never payload). */
+export const DEFAULT_IGNORE = [
+    '.git',
+    'node_modules',
+    'dist',
+    'coverage',
+    'cdk.out',
+    '.turbo',
+    '.DS_Store',
+    // packaging metadata of the template itself, meaningless in a generated project
+    '.npmignore',
+    'var',
+    // frontend build artifacts of in-place template runs
+    '.next',
+    'out',
+    'next-env.d.ts',
+];
+/** A file is treated as binary if its first bytes contain a NUL byte. */
+function isBinary(buffer) {
+    return buffer.subarray(0, 8192).includes(0);
+}
+export async function copyTree(srcDir, destDir, options = {}) {
+    const ignore = new Set(options.ignore ?? DEFAULT_IGNORE);
+    await mkdir(destDir, { recursive: true });
+    await copyDir(srcDir, destDir, '', { ...options, ignore });
+}
+/**
+ * The destination-relative file paths {@link copyTree} would produce — same
+ * ignore list, same name transform, no writes. Used to check layer
+ * composition for collisions before anything is copied.
+ */
+export async function listTree(srcDir, options = {}) {
+    const ignore = new Set(options.ignore ?? DEFAULT_IGNORE);
+    const files = [];
+    const walk = async (dir, relDir) => {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (ignore.has(entry.name))
+                continue;
+            const destName = options.transformName ? options.transformName(entry.name) : entry.name;
+            const relPath = relDir === '' ? destName : `${relDir}/${destName}`;
+            if (entry.isDirectory()) {
+                await walk(path.join(dir, entry.name), relPath);
+            }
+            else if (entry.isFile()) {
+                files.push(relPath);
+            }
+        }
+    };
+    await walk(srcDir, '');
+    return files;
+}
+async function copyDir(srcDir, destDir, relDir, options) {
+    const entries = await readdir(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (options.ignore.has(entry.name))
+            continue;
+        const srcPath = path.join(srcDir, entry.name);
+        const destName = options.transformName ? options.transformName(entry.name) : entry.name;
+        const destPath = path.join(destDir, destName);
+        const relPath = path.join(relDir, entry.name);
+        if (entry.isDirectory()) {
+            await mkdir(destPath, { recursive: true });
+            await copyDir(srcPath, destPath, relPath, options);
+        }
+        else if (entry.isFile()) {
+            await copyFileEntry(srcPath, destPath, relPath, options);
+        }
+        // Symlinks and other special entries are intentionally not copied:
+        // templates are plain trees.
+    }
+}
+async function copyFileEntry(srcPath, destPath, relPath, options) {
+    if (!options.transformContent) {
+        await copyFile(srcPath, destPath); // copyFile preserves the mode by itself
+        return;
+    }
+    const buffer = await readFile(srcPath);
+    if (isBinary(buffer)) {
+        await writeFile(destPath, buffer);
+    }
+    else {
+        await writeFile(destPath, options.transformContent(buffer.toString('utf8'), relPath));
+    }
+    // writeFile does NOT preserve permissions — restore them (chmod ignores umask),
+    // otherwise executable template files (scripts, hooks) arrive non-executable.
+    const { mode } = await stat(srcPath);
+    await chmod(destPath, mode & 0o777);
+}

package/packages/cli/dist/lib/prompts.js

@@ -0,0 +1,24 @@
+import { createInterface } from 'node:readline';
+/**
+ * Pick a target interactively: by number, by name, or Enter for the default.
+ * Anything unrecognised falls back to the default — generation should never
+ * dead-end on a typo.
+ */
+export function promptTarget(targets, defaultTarget, streams) {
+    if (!streams.isInteractive) {
+        return Promise.resolve(defaultTarget);
+    }
+    const menu = targets
+        .map((name, index) => `  ${index + 1}. ${name}${name === defaultTarget ? ' (default)' : ''}`)
+        .join('\n');
+    const rl = createInterface({ input: streams.input, output: streams.output });
+    return new Promise((resolve) => {
+        rl.question(`Target:\n${menu}\nChoose [1-${targets.length}]: `, (answer) => {
+            rl.close();
+            const trimmed = answer.trim();
+            const byNumber = targets[Number.parseInt(trimmed, 10) - 1];
+            const byName = targets.find((name) => name === trimmed);
+            resolve(byName ?? byNumber ?? defaultTarget);
+        });
+    });
+}

package/packages/cli/dist/lib/substitute.js

@@ -0,0 +1,22 @@
+export function substituteContent(content, ctx) {
+    return content
+        .replaceAll('__PROJECT_NAME__', ctx.projectName)
+        .replaceAll('__PROJECT_SCOPE__', ctx.projectScope)
+        .replaceAll('__REGION__', ctx.region)
+        .replaceAll('@app/', `@${ctx.projectScope}/`);
+}
+/**
+ * Files that must exist in the generated project under a dotted name, but are
+ * stored un-dotted in the template because `npm publish` strips the dotted
+ * original from tarballs (the create-react-app `gitignore` trick).
+ */
+const UNDOTTED_NAMES = {
+    gitignore: '.gitignore',
+};
+export function substituteFileName(name, ctx) {
+    const substituted = name
+        .replaceAll('__PROJECT_NAME__', ctx.projectName)
+        .replaceAll('__PROJECT_SCOPE__', ctx.projectScope)
+        .replaceAll('__REGION__', ctx.region);
+    return UNDOTTED_NAMES[substituted] ?? substituted;
+}

package/packages/cli/dist/lib/summary.js

@@ -0,0 +1,41 @@
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+const names = async (dir, strip) => {
+    try {
+        return (await readdir(dir)).map((entry) => entry.replace(strip, '')).sort();
+    }
+    catch {
+        return [];
+    }
+};
+export async function collectGovernance(projectDir) {
+    const claude = path.join(projectDir, '.claude');
+    return {
+        rules: await names(path.join(claude, 'rules'), /\.md$/),
+        agents: await names(path.join(claude, 'agents'), /\.md$/),
+        hooks: (await names(path.join(claude, 'hooks'), /\.mjs$/))
+            // guard-core-purity → "core purity": the mechanism, not the filename
+            .map((hook) => hook.replace(/^(guard|block)-/, '').replaceAll('-', ' ')),
+        skills: await names(path.join(claude, 'skills'), /$^/),
+    };
+}
+export function renderSummary(projectName, target, dirArg, summary, p) {
+    const row = (label, count, detail, note = '') => {
+        const tag = note ? `  ${note}` : '';
+        return `  ${label.padEnd(8)}${String(count).padEnd(3)}${tag.padEnd(note ? 11 : 0)}  ${p.dim(detail)}`;
+    };
+    return [
+        `Created  ${p.accent(projectName)}  ${p.dim('·')}  ${target}`,
+        '',
+        row('Rules', summary.rules.length, '.claude/rules/'),
+        row('Agents', summary.agents.length, summary.agents.join(', ')),
+        row('Hooks', summary.hooks.length, summary.hooks.join(', '), 'enforced'),
+        row('Skills', summary.skills.length, summary.skills.join(', ')),
+        '',
+        'Next',
+        p.dim(`  cd ${dirArg}`),
+        p.dim('  pnpm install'),
+        p.dim('  pnpm check'),
+        '',
+    ].join('\n');
+}

package/packages/cli/dist/lib/targets.js

@@ -0,0 +1,14 @@
+export const TARGETS = {
+    'aws-serverless': {
+        skeletonDir: 'aws-serverless',
+        stacks: ['node-ts', 'aws-cdk'],
+        defaultRegion: 'eu-central-1',
+    },
+    'node-service': {
+        skeletonDir: 'node-service',
+        stacks: ['node-ts'],
+    },
+};
+export const TARGET_NAMES = Object.keys(TARGETS);
+/** Zero options at the personal stage: one implicit target (PLAN.md §6). */
+export const DEFAULT_TARGET = 'aws-serverless';

package/packages/cli/dist/templates.js

@@ -0,0 +1,21 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Resolve the repo/package `templates/` directory.
+ *
+ * This file lives at `packages/cli/src/templates.ts` in the repo and at
+ * `packages/cli/dist/templates.js` in the published package — three levels below
+ * the root in both cases, so one relative walk serves dev, tarball and git installs.
+ */
+export function templatesRoot() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'templates');
+}
+export function skeletonDir(skeleton) {
+    return path.join(templatesRoot(), 'skeleton', skeleton);
+}
+export function agentOsUniversalDir() {
+    return path.join(templatesRoot(), 'agent-os', 'universal');
+}
+export function agentOsStackDir(stack) {
+    return path.join(templatesRoot(), 'agent-os', 'stack', stack);
+}

package/scripts/prepare.mjs

@@ -0,0 +1,29 @@
+// Runs on `pnpm install` locally AND when npm installs this package from git
+// (`npx github:<user>/create-agent-rig`). It must therefore work with only
+// the root devDependencies present and no pnpm available.
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = path.dirname(fileURLToPath(import.meta.url)) + '/..';
+
+// 1. Wire up the pre-commit hook when working inside the git checkout.
+if (existsSync(path.join(root, '.git'))) {
+  spawnSync('git', ['config', 'core.hooksPath', '.husky'], { cwd: root, stdio: 'inherit' });
+}
+
+// 2. Build the CLI so the `bin` entry exists (required for git/tarball installs).
+const require = createRequire(import.meta.url);
+const tscPath = path.join(
+  path.dirname(require.resolve('typescript/package.json')),
+  'lib',
+  'tsc.js',
+);
+const result = spawnSync(
+  process.execPath,
+  [tscPath, '-p', path.join(root, 'packages/cli/tsconfig.build.json')],
+  { cwd: root, stdio: 'inherit' },
+);
+process.exit(result.status ?? 1);