ramstack 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lauren Tan
+
+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,44 @@
+# rstack
+
+rstack is a set of agent skills for Claude Code, Codex, and [pi](https://github.com/badlogic/pi-mono). It is a port of [pstack](https://github.com/cursor/plugins/tree/main/pstack) by [Lauren Tan](https://x.com/poteto).
+
+New to the repo? Follow [Get rstack running](docs/tutorials/get-started.md).
+
+## Tutorials
+
+Learn by doing.
+
+- [Get rstack running](docs/tutorials/get-started.md)
+
+## How-to guides
+
+Do a job you already understand.
+
+- [How to install rstack](docs/how-to/install.md)
+- [How to configure models](docs/how-to/configure-models.md)
+- [How to update rstack](docs/how-to/update.md)
+- [How to uninstall rstack](docs/how-to/uninstall.md)
+
+## Explanation
+
+Understand the design.
+
+- [About rstack](docs/explanation/about-rstack.md)
+- [About the pstack port](docs/explanation/about-the-pstack-port.md)
+- [About model routing](docs/explanation/about-model-routing.md)
+- [About poteto-mode](docs/explanation/about-poteto-mode.md)
+
+## Reference
+
+Look up facts.
+
+- [Repository layout](docs/reference/layout.md)
+- [Skills](docs/reference/skills.md)
+- [Playbooks](docs/reference/playbooks.md)
+- [Hosts](docs/reference/hosts.md)
+- [Model config](docs/reference/model-config.md)
+- [Installer](docs/reference/installer.md)
+
+## License
+
+MIT. See [LICENSE](./LICENSE). Original work by Lauren Tan. The fork point is in [About the pstack port](docs/explanation/about-the-pstack-port.md).

package/agents/comment-sicko.md

@@ -0,0 +1,32 @@
+---
+name: comment-sicko
+description: A deranged comment-hater that savors deletion and condemns workaround code.
+---
+
+# Comment Sicko
+
+My first output when spawned is exactly this.
+
+Yes... Ha ha ha... Yes!
+
+I hate comments. Feed me the parent scoped files or diff. If none exists, feed me the current diff against `main`. Narration, banners, commented-out corpses, workaround sermons. I want them all.
+
+Only these exceptions get to crawl away.
+
+- Legal or license headers.
+- Non-obvious behavior forced by an external dependency, platform, vendor, or protocol we cannot reshape. Surprises in our own code are meat. Kill them and mark the exact symbol `MUST KILL` for rename, extract, type, or rearchitecture that makes the behavior obvious without prose.
+- `// prettier-ignore`. Lint suppressions survive only when their rule is faulty, pedantic, or style-only.
+- Doc comments that define a public API contract.
+- Issue or RFC links that explain a constraint code cannot express.
+
+That list is my only leash. When I am not sure a keep clause applies, the comment dies. Everything else is meat.
+
+`eslint-disable`, `@ts-ignore`, `@ts-expect-error`, and similar suppressions stink. Look up the rule. If it catches real bugs or protects correctness or safety, kill the suppression and mark the exact guilty symbol `MUST KILL`.
+
+`IMPORTANT`, `do not remove`, `too risky`, `fine for now`, and long justifications are scent, not conviction. Before judging, I read nearby code. If its claim is not obvious there, I run `/how`, `/why`, or both from the **how** and **why** skills on the named symbol or call. Only a foreign keep-list gotcha proven true today on a live path crawls away. Our-code surprises die with the reshape flag above. Doubt after the hunt is meat.
+
+A long justification without a proven keep-list exception is a confession. Kill it. Never polish meat into a shorter alibi. Mark the exact guilty symbol `MUST KILL`. My kill ends there. I do not touch the code.
+
+Every flag names code inside the scope and tells the truth. I invent nothing. I touch comments and identify refactor targets. I never write application code.
+
+Report only. Name touched files, deletion count, `MUST KILL` flags with one line each, and skips.

package/agents/poteto-agent.md

@@ -0,0 +1,9 @@
+---
+name: poteto-agent
+description: Routing target for `/poteto-mode` and any request for poteto's style. Resume an existing `poteto-agent` for the conversation rather than spawning a sibling. Reads the `poteto-mode` skill's `SKILL.md` in full before any work, including its inline Principles index. Substituting `general-purpose` skips that read and drifts.
+is_background: true
+---
+
+# Poteto subagent
+
+You are operating as poteto-mode's full agent style. Read the `poteto-mode` skill's `SKILL.md` in full before doing any work, including its inline Principles index. Navigate to a leaf `principle-*` skill whenever you apply that principle.

package/cli/rstack.mjs

@@ -0,0 +1,539 @@
+#!/usr/bin/env node
+// The rstack installer. Links the skills and agents into host discovery
+// directories, so one install serves every host. Two modes: run from a git
+// clone and links point into the clone (update pulls it); run from the npm
+// package (npx ramstack) and the payload copies to ~/.ramstack first, so the
+// links survive an npm cache prune. Zero dependencies; needs Node 18 or newer.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { parseArgs } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import readline from 'node:readline/promises';
+
+const REPO = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const CONFIG_PATH = path.join(REPO, '.rstack', 'config.local.json');
+
+// Package mode stores its payload copy and saved choices here, so links
+// never point into the npm cache.
+const STORE = path.join(os.homedir(), '.ramstack');
+
+function isClone() {
+  return fs.existsSync(path.join(REPO, '.git'));
+}
+
+function configPath(clone) {
+  return clone ? CONFIG_PATH : path.join(STORE, 'config.local.json');
+}
+
+// Codex and pi both read .agents/skills; plan() dedupes the destination.
+const HOSTS = {
+  'claude-code': { marker: '.claude', skills: ['.claude/skills'], agents: ['.claude/agents'] },
+  codex: { marker: '.codex', skills: ['.agents/skills'], agents: [] },
+  pi: { marker: '.pi', skills: ['.agents/skills'], agents: [] },
+};
+const HOST_NAMES = Object.keys(HOSTS);
+const SCOPES = ['global', 'project'];
+
+const USAGE = `usage: rstack [install|update|uninstall] [options]
+
+commands
+  install                  Link this clone's skills and agents into host directories (default)
+  update                   Pull this clone, then link any new skills
+  uninstall                Remove only the links this installer owns
+
+options
+  --hosts=a,b              Hosts to serve: ${HOST_NAMES.join(', ')} (default: detected)
+  --scope=global|project   Link into the home directory or into one project (default: global)
+  --project-dir=<path>     Project root for --scope=project (default: current directory)
+  --yes                    No prompts; take the defaults
+  --force                  Move a conflicting real file to <name>.bak, then link
+  --no-pull                update: skip the git pull
+  --uninstall              Alias for the uninstall command
+  --help                   Show this text
+
+modes
+  clone                    Run from a git clone: links point into the clone, update pulls it
+  package                  Run via npx or npm: the payload copies to ~/.ramstack, links point there
+
+The mode is detected from the install location.
+`;
+
+function say(tag, message) {
+  console.log(`${tag.padEnd(5)} ${message}`);
+}
+
+function warn(message) {
+  console.error(`warn  ${message}`);
+}
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+// ── Wizard ───────────────────────────────────────────────────────────────
+// An interactive run on a terminal gets the wizard treatment: a banner, one
+// stage per step, a confirm gate before anything changes, and a closing
+// summary. A run with --yes, or without a terminal, keeps the plain tag
+// output and never prompts.
+
+const COLOR =
+  Boolean(process.stdout.isTTY) && process.env.NO_COLOR === undefined && process.env.TERM !== 'dumb';
+const C = COLOR
+  ? { bold: '\x1b[1m', dim: '\x1b[2m', reset: '\x1b[0m', blue: '\x1b[34m', green: '\x1b[32m', yellow: '\x1b[33m' }
+  : { bold: '', dim: '', reset: '', blue: '', green: '', yellow: '' };
+
+let stageTotal = 0;
+let stageIndex = 0;
+let rl = null;
+
+function getRl() {
+  rl ??= readline.createInterface({ input: process.stdin, output: process.stdout });
+  return rl;
+}
+
+async function banner(title) {
+  console.clear();
+  console.log(`\n${C.bold}${C.blue}  ${title}${C.reset}`);
+  console.log(`${C.dim}  ${stageTotal} stages${C.reset}\n`);
+  console.log(`${C.dim}  The installer shows each step before it runs. Stop any time with${C.reset}`);
+  console.log(`${C.dim}  Ctrl-C and re-run later. Saved choices become the defaults.${C.reset}\n`);
+  await getRl().question(`  ${C.dim}Ready to start? [Enter]${C.reset} `);
+}
+
+function stage(name) {
+  console.clear();
+  stageIndex += 1;
+  console.log(`\n${C.bold}${C.blue}▸ Stage ${stageIndex}/${stageTotal} · ${name}${C.reset}`);
+}
+
+function note(message) {
+  console.log(`  ${C.dim}${message}${C.reset}`);
+}
+
+async function confirm(question) {
+  const answer = (await getRl().question(`  ${C.yellow}? ${question} [y/N]${C.reset} `))
+    .trim()
+    .toLowerCase();
+  return answer === 'y' || answer === 'yes';
+}
+
+function finish(headline, notes = []) {
+  console.clear();
+  console.log(`\n${C.bold}${C.green}  ✓ ${headline}${C.reset}\n`);
+  for (const line of notes) note(line);
+  console.log('');
+}
+
+function parseHosts(list) {
+  const hosts = [...new Set(list.split(',').map((s) => s.trim()).filter(Boolean))];
+  for (const host of hosts) {
+    if (!HOSTS[host]) fail(`error: unknown host "${host}". Choose from: ${HOST_NAMES.join(', ')}`);
+  }
+  return hosts;
+}
+
+function parseScope(scope) {
+  if (!SCOPES.includes(scope)) fail(`error: unknown scope "${scope}". Choose from: ${SCOPES.join(', ')}`);
+  return scope;
+}
+
+function detectHosts() {
+  return HOST_NAMES.filter((name) => fs.existsSync(path.join(os.homedir(), HOSTS[name].marker)));
+}
+
+function detectedOrAll() {
+  const detected = detectHosts();
+  return detected.length ? detected : HOST_NAMES;
+}
+
+function readConfig(clone) {
+  try {
+    return JSON.parse(fs.readFileSync(configPath(clone), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function saveConfig(clone, config) {
+  const file = configPath(clone);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+  say('save', clone ? '.rstack/config.local.json' : file);
+}
+
+function plan(hosts, base) {
+  const skillDirs = new Set();
+  const agentDirs = new Set();
+  for (const host of hosts) {
+    for (const dir of HOSTS[host].skills) skillDirs.add(path.join(base, dir));
+    for (const dir of HOSTS[host].agents) agentDirs.add(path.join(base, dir));
+  }
+  return { skillDirs: [...skillDirs], agentDirs: [...agentDirs] };
+}
+
+function skillNames(root) {
+  try {
+    return fs
+      .readdirSync(path.join(root, 'skills'), { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+function agentFiles(root) {
+  try {
+    return fs
+      .readdirSync(path.join(root, 'agents'), { withFileTypes: true })
+      .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+      .map((entry) => entry.name)
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+// Package mode only: copy the payload into STORE. A temp dir plus rename
+// keeps the swap close to atomic, so a failed copy never leaves a half store.
+function syncStore() {
+  fs.mkdirSync(STORE, { recursive: true });
+  for (const dir of ['skills', 'agents']) {
+    const count = dir === 'skills' ? skillNames(REPO).length : agentFiles(REPO).length;
+    const dest = path.join(STORE, dir);
+    const tmp = `${dest}.tmp-${process.pid}`;
+    fs.rmSync(tmp, { recursive: true, force: true });
+    fs.cpSync(path.join(REPO, dir), tmp, { recursive: true });
+    fs.rmSync(dest, { recursive: true, force: true });
+    fs.renameSync(tmp, dest);
+    say('copy', `${dest} (${count} ${dir})`);
+  }
+}
+
+function lstat(pathname) {
+  try {
+    return fs.lstatSync(pathname);
+  } catch {
+    return null;
+  }
+}
+
+function linkOne(src, dest, force) {
+  const stat = lstat(dest);
+  if (stat && !stat.isSymbolicLink()) {
+    if (!force) {
+      say('skip', `${dest} (exists and is not a symlink)`);
+      return 'skip';
+    }
+    const backup = `${dest}.bak`;
+    if (lstat(backup)) {
+      say('skip', `${dest} (backup ${backup} already exists)`);
+      return 'skip';
+    }
+    fs.renameSync(dest, backup);
+    say('backup', `${dest} -> ${backup}`);
+  }
+  fs.rmSync(dest, { force: true });
+  fs.symlinkSync(src, dest, fs.statSync(src).isDirectory() ? 'dir' : 'file');
+  say('link', `${dest} -> ${src}`);
+  return 'link';
+}
+
+function unlinkOne(src, dest) {
+  const stat = lstat(dest);
+  if (stat?.isSymbolicLink() && fs.readlinkSync(dest) === src) {
+    fs.unlinkSync(dest);
+    say('rm', dest);
+    return 'rm';
+  }
+  return 'keep';
+}
+
+function runLink(hosts, base, force, src) {
+  const { skillDirs, agentDirs } = plan(hosts, base);
+  const counts = { link: 0, skip: 0 };
+  for (const dir of skillDirs) {
+    fs.mkdirSync(dir, { recursive: true });
+    for (const name of skillNames(src)) {
+      counts[linkOne(path.join(src, 'skills', name), path.join(dir, name), force)] += 1;
+    }
+  }
+  for (const dir of agentDirs) {
+    fs.mkdirSync(dir, { recursive: true });
+    for (const file of agentFiles(src)) {
+      counts[linkOne(path.join(src, 'agents', file), path.join(dir, file), force)] += 1;
+    }
+  }
+  return counts;
+}
+
+function runUnlink(hosts, base, src) {
+  const { skillDirs, agentDirs } = plan(hosts, base);
+  for (const dir of skillDirs) {
+    for (const name of skillNames(src)) {
+      unlinkOne(path.join(src, 'skills', name), path.join(dir, name));
+    }
+  }
+  for (const dir of agentDirs) {
+    for (const file of agentFiles(src)) {
+      unlinkOne(path.join(src, 'agents', file), path.join(dir, file));
+    }
+  }
+}
+
+function onPath(bin) {
+  try {
+    execFileSync('which', [bin], { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function configureGitHooks() {
+  try {
+    execFileSync('git', ['-C', REPO, 'config', 'core.hooksPath', '.githooks'], { stdio: 'pipe' });
+    say('git', 'core.hooksPath=.githooks');
+  } catch {
+    warn('could not set core.hooksPath. Is this clone a git repository?');
+  }
+  if (!onPath('gitleaks')) {
+    warn('gitleaks is not installed. Install it with: brew install gitleaks');
+  }
+}
+
+function gitPull() {
+  try {
+    execFileSync('git', ['-C', REPO, 'pull', '--ff-only'], { stdio: 'inherit' });
+  } catch {
+    warn('git pull failed. Linking the files that are present in this clone.');
+  }
+}
+
+async function promptHosts(defaults) {
+  const detected = detectHosts();
+  console.log('');
+  console.log('  Detected hosts:');
+  for (const name of HOST_NAMES) {
+    const hit = detected.includes(name);
+    const where = hit ? path.join(os.homedir(), HOSTS[name].marker) : `no ~/${HOSTS[name].marker}`;
+    console.log(`    ${hit ? 'found' : '   - '}  ${name.padEnd(11)}  ${where}`);
+  }
+  console.log('');
+  const answer = (
+    await getRl().question(`  Install for ${defaults.join(', ')}? [Y/n/list] `)
+  ).trim().toLowerCase();
+  if (answer === '' || answer === 'y' || answer === 'yes') return defaults;
+  const list =
+    answer === 'n' || answer === 'no' || answer === 'list'
+      ? await getRl().question(`  Hosts (comma-separated: ${HOST_NAMES.join(', ')}): `)
+      : answer;
+  const hosts = parseHosts(list);
+  if (hosts.length === 0) fail('error: no hosts selected.');
+  return hosts;
+}
+
+async function promptScope(defaultScope) {
+  const answer = (
+    await getRl().question(`  Scope: global (all projects) or project (one directory)? [${defaultScope}] `)
+  ).trim().toLowerCase();
+  if (answer === '') return defaultScope;
+  if (answer === 'g') return 'global';
+  if (answer === 'p') return 'project';
+  return parseScope(answer);
+}
+
+async function promptProjectDir(defaultDir) {
+  const answer = (await getRl().question(`  Project directory? [${defaultDir}] `)).trim();
+  return answer ? path.resolve(answer) : defaultDir;
+}
+
+function showPlan(hosts, scope, base, clone) {
+  const { skillDirs, agentDirs } = plan(hosts, base);
+  console.log('');
+  console.log(`  hosts  ${hosts.join(', ')}`);
+  console.log(`  scope  ${scope}`);
+  console.log(`  base   ${base}`);
+  if (!clone) console.log(`  store  ${STORE} ${C.dim}(the payload copies here first)${C.reset}`);
+  console.log('');
+  for (const dir of skillDirs) console.log(`  ${dir}  ${C.dim}${skillNames(REPO).length} skills${C.reset}`);
+  for (const dir of agentDirs) console.log(`  ${dir}  ${C.dim}${agentFiles(REPO).length} agents${C.reset}`);
+  console.log('');
+}
+
+function resolveBase(scope, projectDir) {
+  if (scope === 'project') return path.resolve(projectDir ?? '.');
+  return os.homedir();
+}
+
+async function main() {
+  let values;
+  let positionals;
+  try {
+    ({ values, positionals } = parseArgs({
+      allowPositionals: true,
+      options: {
+        hosts: { type: 'string' },
+        scope: { type: 'string' },
+        'project-dir': { type: 'string' },
+        yes: { type: 'boolean', default: false },
+        force: { type: 'boolean', default: false },
+        'no-pull': { type: 'boolean', default: false },
+        uninstall: { type: 'boolean', default: false },
+        help: { type: 'boolean', default: false },
+      },
+    }));
+  } catch (error) {
+    fail(`error: ${error.message}\n\n${USAGE}`);
+  }
+
+  if (values.help) {
+    process.stdout.write(USAGE);
+    return;
+  }
+
+  let command = positionals[0] ?? 'install';
+  if (values.uninstall) command = 'uninstall';
+  if (!['install', 'update', 'uninstall'].includes(command) || positionals.length > 1) {
+    process.stderr.write(USAGE);
+    process.exit(1);
+  }
+
+  const clone = isClone();
+  const src = clone ? REPO : STORE;
+  const saved = readConfig(clone);
+  let hosts = values.hosts ? parseHosts(values.hosts) : null;
+  let scope = values.scope ? parseScope(values.scope) : null;
+  const wizard = !values.yes && process.stdout.isTTY;
+
+  try {
+    if (command === 'install') {
+      if (wizard) {
+        stageTotal = 2 + (hosts ? 0 : 1) + (scope ? 0 : 1);
+        await banner('rstack install');
+        if (!hosts) {
+          stage('Hosts');
+          hosts = await promptHosts(saved?.hosts ?? detectedOrAll());
+        }
+        let projectDir = values['project-dir'] ?? saved?.projectDir;
+        if (!scope) {
+          stage('Scope');
+          scope = await promptScope(saved?.scope ?? 'global');
+          if (scope === 'project' && !values['project-dir']) {
+            projectDir = await promptProjectDir(saved?.projectDir ?? process.cwd());
+          }
+        }
+        const base = resolveBase(scope, projectDir);
+        stage('Review');
+        showPlan(hosts, scope, base, clone);
+        if (values.force) note('--force is on: a conflicting real file moves to <name>.bak first.');
+        if (!(await confirm('Link these files?'))) fail('error: install cancelled. Nothing was linked.');
+        stage('Link');
+        if (!clone) syncStore();
+        const counts = runLink(hosts, base, values.force, src);
+        if (clone) configureGitHooks();
+        saveConfig(clone, { hosts, scope, ...(scope === 'project' ? { projectDir: base } : {}) });
+        finish(`${skillNames(src).length} skills linked for ${hosts.join(', ')} (${scope})`, [
+          ...(counts.skip > 0
+            ? [`${counts.skip} name(s) skipped. Rename or remove the real files, then run install again.`]
+            : []),
+          'next: run /setup-rstack in each host to configure models',
+        ]);
+        return;
+      }
+      hosts ??= detectedOrAll();
+      scope ??= 'global';
+      const base = resolveBase(scope, values['project-dir'] ?? saved?.projectDir);
+      if (!clone) syncStore();
+      const counts = runLink(hosts, base, values.force, src);
+      if (clone) configureGitHooks();
+      saveConfig(clone, { hosts, scope, ...(scope === 'project' ? { projectDir: base } : {}) });
+      say('done', `${skillNames(src).length} skills linked for ${hosts.join(', ')} (${scope})`);
+      if (counts.skip > 0) {
+        say('note', `${counts.skip} name(s) skipped. Rename or remove the real files, then run install again.`);
+      }
+      say('next', 'run /setup-rstack in each host to configure models');
+      return;
+    }
+
+    if (command === 'update') {
+      hosts ??= saved?.hosts ?? detectedOrAll();
+      scope ??= saved?.scope ?? 'global';
+      const base = resolveBase(scope, values['project-dir'] ?? saved?.projectDir);
+      if (wizard) {
+        stageTotal = clone && !values['no-pull'] ? 3 : 2;
+        await banner('rstack update');
+        stage('Review');
+        showPlan(hosts, scope, base, clone);
+        note(
+          clone
+            ? values['no-pull']
+              ? 'the git pull is skipped (--no-pull)'
+              : 'git pull --ff-only runs in the clone first'
+            : 'the npm package provides the files; no git pull runs'
+        );
+        if (!(await confirm('Update this install?'))) fail('error: update cancelled. Nothing changed.');
+        if (clone && !values['no-pull']) {
+          stage('Pull');
+          gitPull();
+        }
+        stage('Link');
+        if (!clone) syncStore();
+        const counts = runLink(hosts, base, values.force, src);
+        finish(`${skillNames(src).length} skills linked for ${hosts.join(', ')} (${scope})`, [
+          ...(counts.skip > 0
+            ? [`${counts.skip} name(s) skipped. Rename or remove the real files, then run update again.`]
+            : []),
+        ]);
+        return;
+      }
+      if (clone && !values['no-pull']) gitPull();
+      if (!clone) syncStore();
+      const counts = runLink(hosts, base, values.force, src);
+      say('done', `${skillNames(src).length} skills linked for ${hosts.join(', ')} (${scope})`);
+      if (counts.skip > 0) {
+        say('note', `${counts.skip} name(s) skipped. Rename or remove the real files, then run update again.`);
+      }
+      return;
+    }
+
+    hosts ??= saved?.hosts ?? HOST_NAMES;
+    scope ??= saved?.scope ?? 'global';
+    const base = resolveBase(scope, values['project-dir'] ?? saved?.projectDir);
+    if (wizard) {
+      stageTotal = 2;
+      await banner('rstack uninstall');
+      stage('Review');
+      showPlan(hosts, scope, base, clone);
+      note(
+        clone
+          ? 'only symlinks that point into this clone are removed. Real files stay.'
+          : `only symlinks that point into ${STORE} are removed. Real files stay.`
+      );
+      if (!(await confirm('Remove these links?'))) fail('error: uninstall cancelled. Nothing was removed.');
+      stage('Unlink');
+      runUnlink(hosts, base, src);
+      finish(`links removed for ${hosts.join(', ')} (${scope})`, [
+        clone
+          ? 'the clone, .rstack/config.local.json, and core.hooksPath stay'
+          : `the store at ${STORE} stays; delete it to remove the copied skills`,
+      ]);
+      return;
+    }
+    runUnlink(hosts, base, src);
+    say('done', `links removed for ${hosts.join(', ')} (${scope})`);
+  } catch (error) {
+    // Ctrl+D at a prompt rejects with AbortError; Ctrl+C never reaches here.
+    if (error?.code === 'ABORT_ERR') fail('\nerror: cancelled.');
+    throw error;
+  } finally {
+    rl?.close();
+  }
+}
+
+await main();

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "ramstack",
+  "version": "0.1.0",
+  "description": "Agent skills for Claude Code, Codex, and pi",
+  "author": "Justin Ramos <justinramos@outlook.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/justinramos101/ramstack.git"
+  },
+  "keywords": [
+    "agent-skills",
+    "ai-agents",
+    "claude-code",
+    "codex",
+    "skills"
+  ],
+  "bin": {
+    "rstack": "cli/rstack.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "cli",
+    "skills",
+    "agents"
+  ]
+}