fbt-os 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fuckbigtech.ai (operated by Kinetic Labs Inc.)
+
+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,68 @@
+# fbt-os
+
+**v0 setup CLI for the FuckBigTech local-first agent OS.** Zero deps. Zero network calls. Nothing leaves your machine.
+
+> ⚠️ **v0 scope.** This CLI scaffolds a private local memory vault, detects which agent harnesses + runtimes + provider keys are present on your system, and runs deterministic setup checks. The full agent OS — autonomous meta-routing, prompt decomposition, cloud-burst, vault-aware harness plugins — is being built. Star the project / subscribe at [fuckbigtech.ai](https://fuckbigtech.ai) for the v1 drop.
+
+> The npm package is `fbt-os` (npm's word filter blocks the full brand name). The installed binary keeps the brand: type `fuckbigtech` after install.
+
+## Install
+
+```bash
+npm install -g fbt-os
+```
+
+Requires Node 20+. Works on macOS, Linux, WSL.
+
+## Verify before running
+
+```bash
+fuckbigtech dry-run
+```
+
+Prints everything the CLI **would** do without doing it. No writes, no env reads, no shells.
+
+## Initialize a local memory vault
+
+```bash
+fuckbigtech init --with-memory
+```
+
+Scaffolds a private Markdown memory tree under `~/.fuckbigtech/memory/` (mode `0700`, files `0600`). The `--with-memory` flag is an explicit opt-in.
+
+## Run setup checks
+
+```bash
+fuckbigtech doctor          # detect harnesses, runtimes, provider key presence (boolean only — values never read)
+fuckbigtech memory-test quick   # validate the local vault scaffold
+fuckbigtech route-test demo     # exercise the v0 route classifier
+```
+
+## Connect an existing vault
+
+```bash
+fuckbigtech connect /path/to/your/vault
+```
+
+Validates the path looks like an FBT-shaped memory tree before writing the config pointer.
+
+## What this CLI promises
+
+- **No network calls.** `grep -rE 'fetch|http|https|net|dgram' bin/` returns zero hits.
+- **No paid model calls.** All routing decisions in v0 are deterministic and offline.
+- **No key uploads.** Provider env keys (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, etc.) are tested for *presence only* with a boolean — the values are never read, logged, or written.
+- **No shell mutation.** Doesn't touch your `.bashrc`, `.zshrc`, `PATH`, or any system path. All writes are scoped to `~/.fuckbigtech/` (override via `FBT_CONFIG_DIR` and `FBT_VAULT_PATH`).
+- **Permissive defaults.** Vault dir is `0700`, files `0600` — only your user can read.
+
+## What v0 doesn't do yet
+
+- Autonomous prompt routing across harnesses (Claude / Codex / OpenCode / Hermes).
+- Multi-part prompt decomposition.
+- Cloud-burst with git-worktree-based vault sync.
+- The `oc` meta-router with the Llama 3.3 70B routing model.
+
+These ship in v1. For the canonical product spec see [fuckbigtech.ai](https://fuckbigtech.ai).
+
+## License
+
+MIT. See [LICENSE](./LICENSE).

package/bin/fuckbigtech.mjs

@@ -0,0 +1,467 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { spawnSync } from 'node:child_process';
+
+const cwd = process.cwd();
+const home = os.homedir();
+const configDir = process.env.FBT_CONFIG_DIR
+  ? path.resolve(process.env.FBT_CONFIG_DIR)
+  : path.join(home, '.fuckbigtech');
+const configPath = path.join(configDir, 'config.json');
+const defaultVault = process.env.FBT_VAULT_PATH
+  ? path.resolve(process.env.FBT_VAULT_PATH)
+  : path.join(configDir, 'memory');
+const args = process.argv.slice(2);
+
+const colors = {
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  green: '\x1b[32m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m',
+  bold: '\x1b[1m',
+  reset: '\x1b[0m',
+};
+
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+function paint(color, text) {
+  if (!useColor) return text;
+  return `${colors[color] || ''}${text}${colors.reset}`;
+}
+
+function line(text = '') {
+  console.log(text);
+}
+
+function header() {
+  line(paint('red', 'FUCKBIGTECH.AI'));
+  line(paint('yellow', 'Public repo. Private memory. No keys uploaded.'));
+  line();
+}
+
+function commandExists(command) {
+  if (!/^[a-zA-Z0-9._-]+$/.test(command)) return false;
+  return spawnSync('sh', ['-lc', 'command -v "$1"', 'sh', command], { stdio: 'ignore' }).status === 0;
+}
+
+function readConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeConfig(config) {
+  fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
+  fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+}
+
+function detect() {
+  const env = process.env;
+  return {
+    harnesses: [
+      ['Codex', commandExists('codex')],
+      ['Claude Code', commandExists('claude')],
+      ['OpenCode', commandExists('opencode') || commandExists('oc')],
+      ['Hermes', commandExists('hermes')],
+      ['OpenClaw', commandExists('openclaw')],
+    ],
+    runtimes: [
+      ['Ollama', commandExists('ollama')],
+      ['llama.cpp', commandExists('llama-cli') || commandExists('llama-server')],
+      ['vLLM', commandExists('vllm')],
+    ],
+    providers: [
+      ['OpenRouter', Boolean(env.OPENROUTER_API_KEY)],
+      ['OpenAI API', Boolean(env.OPENAI_API_KEY)],
+      ['Anthropic API', Boolean(env.ANTHROPIC_API_KEY)],
+      ['NVIDIA NIM', Boolean(env.NVIDIA_API_KEY)],
+      ['Groq', Boolean(env.GROQ_API_KEY)],
+      ['Mistral', Boolean(env.MISTRAL_API_KEY)],
+      ['Cerebras', Boolean(env.CEREBRAS_API_KEY)],
+    ],
+    stores: [
+      ['Obsidian app', commandExists('obsidian')],
+      ['qmd', commandExists('qmd')],
+      ['1Password CLI', commandExists('op')],
+      ['Doppler', commandExists('doppler')],
+    ],
+  };
+}
+
+function printCheck(name, ok, detail = '') {
+  const mark = ok ? paint('green', '✓') : paint('red', '✕');
+  line(`${mark} ${name.padEnd(18)} ${detail}`);
+}
+
+function printDetection() {
+  const detected = detect();
+  line(paint('yellow', 'Detected agent harnesses'));
+  detected.harnesses.forEach(([name, ok]) => printCheck(name, ok, ok ? 'available' : 'not found'));
+  line();
+  line(paint('yellow', 'Detected local runtimes'));
+  detected.runtimes.forEach(([name, ok]) => printCheck(name, ok, ok ? 'available' : 'not found'));
+  line();
+  line(paint('yellow', 'Detected provider keys'));
+  detected.providers.forEach(([name, ok]) => printCheck(name, ok, ok ? 'env key present' : 'missing or skipped'));
+  line();
+  line(paint('yellow', 'Detected local tooling'));
+  detected.stores.forEach(([name, ok]) => printCheck(name, ok, ok ? 'available' : 'not found'));
+}
+
+function createVault(vaultPath = defaultVault) {
+  const today = new Date().toISOString().slice(0, 10);
+  mkdirPrivate(vaultPath);
+  mkdirPrivate(path.join(vaultPath, 'daily'));
+  mkdirPrivate(path.join(vaultPath, 'handoffs'));
+  mkdirPrivate(path.join(vaultPath, 'fixtures'));
+  mkdirPrivate(path.join(vaultPath, '.handoff'));
+
+  writeIfMissing(path.join(vaultPath, 'Dashboard.md'), [
+    '# FBT Memory Dashboard',
+    '',
+    'This local Markdown vault is the private memory substrate for your agent harnesses.',
+    '',
+    '- Agent harnesses: Claude, Codex, Claude Code, OpenCode, Hermes, OpenClaw',
+    '- Memory store: this vault, optionally opened in Obsidian',
+    '- Retrieval/source verification: qmd or the configured FBT retrieval adapter',
+    '- Local runtime lane: Ollama, llama.cpp, vLLM, or another approved runtime',
+    '',
+  ].join('\n'));
+  writeIfMissing(path.join(vaultPath, 'MEMORY.md'), [
+    '# Memory Index',
+    '',
+    '- [[Dashboard]] — start here',
+    '- [[handoffs/latest]] — newest handoff',
+    `- [[daily/${today}]] — today`,
+    '',
+  ].join('\n'));
+  writeIfMissing(path.join(vaultPath, 'handoffs', 'latest.md'), [
+    '# Latest Handoff',
+    '',
+    'No handoff yet. Run `fuckbigtech route "summarize today"` after your first session.',
+    '',
+  ].join('\n'));
+  writeIfMissing(path.join(vaultPath, 'daily', `${today}.md`), [
+    `# ${today}`,
+    '',
+    '- FBT memory vault created.',
+    '',
+  ].join('\n'));
+  writeIfMissing(path.join(vaultPath, 'fixtures', 'demo-routing.json'), `${JSON.stringify({
+    name: 'demo-routing',
+    prompt: 'summarize today\'s handoff',
+    expected_lane: 'local/free',
+    reason: 'routine summarization should not require a premium model by default',
+  }, null, 2)}\n`);
+  writeIfMissing(path.join(vaultPath, '.handoff', 'HANDOFF.md'), [
+    '# Project Handoff',
+    '',
+    'FBT created this placeholder so agent harnesses have a shared recency surface.',
+    '',
+  ].join('\n'));
+  return vaultPath;
+}
+
+function writeIfMissing(filePath, content) {
+  if (!fs.existsSync(filePath)) fs.writeFileSync(filePath, content, { mode: 0o600 });
+}
+
+function mkdirPrivate(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true, mode: 0o700 });
+  fs.chmodSync(dirPath, 0o700);
+}
+
+function validateVault(vaultPath) {
+  const requiredFiles = ['Dashboard.md', 'MEMORY.md'];
+  const requiredFolders = ['daily'];
+  const missing = [
+    ...requiredFiles.filter((file) => !fs.existsSync(path.join(vaultPath, file))),
+    ...requiredFolders.filter((folder) => !fs.existsSync(path.join(vaultPath, folder))),
+  ];
+  if (!fs.existsSync(path.join(vaultPath, '.handoff')) && !fs.existsSync(path.join(vaultPath, 'handoffs'))) {
+    missing.push('.handoff/ or handoffs/');
+  }
+  return {
+    ok: fs.existsSync(vaultPath) && missing.length === 0,
+    missing,
+  };
+}
+
+function getVaultPath() {
+  const config = readConfig();
+  return config.vaultPath || defaultVault;
+}
+
+function memoryTest() {
+  const vaultPath = getVaultPath();
+  const checks = [
+    ['vault exists', fs.existsSync(vaultPath)],
+    ['Dashboard.md', fs.existsSync(path.join(vaultPath, 'Dashboard.md'))],
+    ['MEMORY.md', fs.existsSync(path.join(vaultPath, 'MEMORY.md'))],
+    ['daily folder', fs.existsSync(path.join(vaultPath, 'daily'))],
+    ['handoff folder', fs.existsSync(path.join(vaultPath, '.handoff')) || fs.existsSync(path.join(vaultPath, 'handoffs'))],
+    ['demo fixture', fs.existsSync(path.join(vaultPath, 'fixtures', 'demo-routing.json'))],
+    ['private boundary', !vaultPath.includes('node_modules')],
+    ['paid calls blocked by default', readConfig().paidCalls !== 'auto'],
+  ];
+  header();
+  line(paint('yellow', 'memory-test quick'));
+  checks.forEach(([name, ok]) => printCheck(name, ok, ok ? 'pass' : 'fail'));
+  const passed = checks.filter(([, ok]) => ok).length;
+  line();
+  line(`${passed}/${checks.length} checks passed`);
+  if (passed !== checks.length) {
+    line(paint('red', 'blocked: run `fuckbigtech init --with-memory` or connect a vault.'));
+    process.exitCode = 1;
+    return;
+  }
+  line(paint('green', 'result: pass'));
+}
+
+function doctor() {
+  header();
+  printDetection();
+  const config = readConfig();
+  const vaultPath = getVaultPath();
+  line();
+  line(paint('yellow', 'Local FBT config'));
+  printCheck('config store', fs.existsSync(configPath), configPath);
+  printCheck('memory vault', fs.existsSync(vaultPath), vaultPath);
+  printCheck('paid model guard', config.paidCalls !== 'auto', config.paidCalls || 'ask-before-spend');
+  line();
+  line(paint('green', 'No keys were uploaded. No paid calls were made.'));
+}
+
+function routeTest() {
+  header();
+  line(paint('yellow', 'route-test demo'));
+  line('Prompt: "summarize today\'s handoff"');
+  line('Decision: local/free lane');
+  line('Reason: routine summarization should not burn premium context.');
+  line('Paid calls: blocked');
+  line('Source requirement: read local handoff before answering');
+  line();
+  line(paint('green', 'result: pass'));
+}
+
+function routePrompt(prompt) {
+  header();
+  const text = prompt || 'summarize today\'s handoff';
+  const highRisk = /\b(send|deploy|publish|email|payment|delete|production|legal|medical|financial)\b/i.test(text);
+  const lane = highRisk ? 'premium/manual approval' : 'local/free';
+  line(paint('yellow', 'route decision'));
+  line(`Prompt: ${text}`);
+  line(`Lane: ${lane}`);
+  line(`Paid calls: ${highRisk ? 'ask first' : 'blocked by default'}`);
+  line(`Memory: ${fs.existsSync(getVaultPath()) ? 'local vault available' : 'no vault connected'}`);
+}
+
+async function ask(rl, question, fallback) {
+  const suffix = fallback ? ` (${fallback})` : '';
+  const answer = (await rl.question(`${question}${suffix}: `)).trim();
+  return answer || fallback;
+}
+
+async function interactive() {
+  header();
+  line('Claude hit the wall. Your workflow does not have to.');
+  line();
+  const rl = readline.createInterface({ input, output });
+  try {
+    line(paint('yellow', 'What are we fixing today?'));
+    line('[1] My agent hit a limit');
+    line('[2] My memory is scattered everywhere');
+    line('[3] I want boring work off premium models');
+    line('[4] I want to benchmark my current setup');
+    const goal = await ask(rl, 'Pick one', '1');
+    line();
+
+    line(paint('yellow', 'Memory setup'));
+    line('[1] Create a new FBT memory vault');
+    line('[2] Connect existing Obsidian/Markdown vault');
+    line('[3] Skip memory for now');
+    const memoryChoice = await ask(rl, 'Pick one', '1');
+    let vaultPath = getVaultPath();
+    if (memoryChoice === '1') {
+      vaultPath = await ask(rl, 'Vault path', defaultVault);
+      createVault(vaultPath);
+    } else if (memoryChoice === '2') {
+      vaultPath = await ask(rl, 'Existing vault path', defaultVault);
+      const validation = validateVault(path.resolve(vaultPath));
+      if (!validation.ok) {
+        line();
+        line(paint('red', 'That folder is not an FBT-compatible memory vault yet.'));
+        line(`Missing: ${validation.missing.join(', ')}`);
+        line('Run `fuckbigtech init --with-memory` or choose create-new for the v0 scaffold.');
+        return;
+      }
+    }
+
+    const config = {
+      ...readConfig(),
+      createdAt: readConfig().createdAt || new Date().toISOString(),
+      goal,
+      vaultPath: memoryChoice === '3' ? undefined : path.resolve(vaultPath),
+      paidCalls: 'ask-before-spend',
+      secrets: 'local-or-existing-env',
+    };
+    writeConfig(config);
+
+    line();
+    line(paint('yellow', 'Provider keys'));
+    line('Big Tech would like these in a web form. We are not doing that.');
+    line('[1] use existing .env/env vars only');
+    line('[2] configure later with `fuckbigtech keys`');
+    line('[3] 1Password/secret manager later');
+    await ask(rl, 'Pick one', '1');
+
+    line();
+    doctor();
+    line();
+    memoryTest();
+    line();
+    routeTest();
+    line();
+    line(paint('green', 'FBT is live.'));
+    line('Try:');
+    line('  fuckbigtech route "summarize today\'s handoff"');
+    line('  fuckbigtech start codex');
+  } finally {
+    rl.close();
+  }
+}
+
+function keys() {
+  header();
+  line(paint('yellow', 'API keys'));
+  line('FBT v0 reads provider keys from your local environment or secret manager.');
+  line('It does not upload keys, print keys, or make paid test calls during setup.');
+  line();
+  detect().providers.forEach(([name, ok]) => printCheck(name, ok, ok ? 'env key present' : 'missing or skipped'));
+  line();
+  line('Supported env names: OPENROUTER_API_KEY, OPENAI_API_KEY, ANTHROPIC_API_KEY, NVIDIA_API_KEY, GROQ_API_KEY, MISTRAL_API_KEY, CEREBRAS_API_KEY');
+}
+
+function startHarness(name) {
+  header();
+  const harness = name || 'codex';
+  const commands = {
+    codex: 'codex',
+    claude: 'claude',
+    'claude-code': 'claude',
+    opencode: 'opencode',
+    oc: 'oc',
+  };
+  const command = commands[harness];
+  line(paint('yellow', `start ${harness}`));
+  if (!command) {
+    line(paint('red', 'unsupported harness for v0 safe start.'));
+    line(`Supported: ${Object.keys(commands).join(', ')}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (!commandExists(command)) {
+    line(paint('red', `${command} not found.`));
+    line('FBT will not install or launch paid harnesses without your consent.');
+    process.exitCode = 1;
+    return;
+  }
+  line(`Run this with your normal auth/session state: ${paint('green', command)}`);
+  line('FBT does not read harness credentials.');
+}
+
+function help() {
+  header();
+  line('Usage: fuckbigtech [command]');
+  line();
+  line('Commands:');
+  line('  init --with-memory       create local FBT memory vault');
+  line('  connect <path>           validate and connect existing Markdown/Obsidian vault');
+  line('  doctor                   detect harnesses, runtimes, keys, and vault');
+  line('  dry-run                  show what FBT would write without changing files');
+  line('  memory-test quick         verify v0 memory scaffold');
+  line('  route-test demo           prove routine work routes away from paid lanes');
+  line('  route "<prompt>"          classify one task');
+  line('  keys                      inspect local provider key presence');
+  line('  start <harness>           show safe launch command for a harness');
+  line('  help                      print this help');
+}
+
+function dryRun() {
+  header();
+  const vaultPath = getVaultPath();
+  line(paint('yellow', 'dry-run'));
+  line('FBT would write:');
+  line(`  config: ${configPath}`);
+  line(`  vault:  ${vaultPath}`);
+  line('  files:  Dashboard.md, MEMORY.md, daily/<today>.md, handoffs/latest.md, fixtures/demo-routing.json');
+  line();
+  line('FBT would not:');
+  line('  modify shell rc files');
+  line('  overwrite existing vault files');
+  line('  copy provider keys');
+  line('  launch paid agent harnesses');
+  line('  make network calls');
+}
+
+async function main() {
+  const [command, ...rest] = args;
+  if (!command) return interactive();
+  if (command === 'help' || command === '--help' || command === '-h') return help();
+  if (command === 'doctor') return doctor();
+  if (command === 'dry-run') return dryRun();
+  if (command === 'keys') return keys();
+  if (command === 'route-test') return routeTest();
+  if (command === 'route') return routePrompt(rest.join(' '));
+  if (command === 'start') return startHarness(rest[0]);
+  if (command === 'memory-test') return memoryTest();
+  if (command === 'connect') {
+    header();
+    if (!rest[0]) {
+      line(paint('red', 'connect requires a vault path.'));
+      process.exitCode = 1;
+      return;
+    }
+    const target = path.resolve(rest[0]);
+    const validation = validateVault(target);
+    if (!validation.ok) {
+      line(paint('red', 'not connected: missing required memory files/folders.'));
+      line(`Missing: ${validation.missing.join(', ')}`);
+      process.exitCode = 1;
+      return;
+    }
+    writeConfig({ ...readConfig(), vaultPath: target, paidCalls: 'ask-before-spend', connectedAt: new Date().toISOString() });
+    printCheck('memory vault', true, target);
+    return;
+  }
+  if (command === 'init') {
+    header();
+    if (rest[0] !== '--with-memory') {
+      line(paint('red', 'init requires the --with-memory flag.'));
+      line('Usage: fuckbigtech init --with-memory');
+      line('This flag is the explicit opt-in to scaffold a local memory vault under ~/.fuckbigtech/.');
+      process.exitCode = 1;
+      return;
+    }
+    const vaultPath = createVault(defaultVault);
+    writeConfig({ ...readConfig(), vaultPath: path.resolve(vaultPath), paidCalls: 'ask-before-spend', createdAt: new Date().toISOString() });
+    printCheck('memory vault', true, vaultPath);
+    printCheck('paid model guard', true, 'ask-before-spend');
+    line(paint('green', 'result: initialized'));
+    return;
+  }
+  help();
+  process.exitCode = 1;
+}
+
+main().catch((error) => {
+  console.error(paint('red', error.message));
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "fbt-os",
+  "type": "module",
+  "version": "0.1.0",
+  "description": "Local-first agent OS CLI: memory vault scaffold, harness/runtime detection, route-classification, and setup checks. v0 — zero deps, zero network calls.",
+  "keywords": [
+    "agent",
+    "local-first",
+    "ollama",
+    "claude-code",
+    "codex",
+    "opencode",
+    "memory",
+    "vault",
+    "obsidian",
+    "cli",
+    "ai"
+  ],
+  "homepage": "https://fuckbigtech.ai",
+  "bugs": {
+    "url": "https://fuckbigtech.ai/audit"
+  },
+  "author": "fuckbigtech.ai",
+  "license": "MIT",
+  "bin": {
+    "fuckbigtech": "bin/fuckbigtech.mjs"
+  },
+  "files": [
+    "bin/",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "check": "node --check ./bin/fuckbigtech.mjs",
+    "test": "FBT_CONFIG_DIR=.tmp/fbt-config FBT_VAULT_PATH=.tmp/fbt-memory node ./bin/fuckbigtech.mjs init --with-memory && FBT_CONFIG_DIR=.tmp/fbt-config FBT_VAULT_PATH=.tmp/fbt-memory node ./bin/fuckbigtech.mjs doctor && FBT_CONFIG_DIR=.tmp/fbt-config FBT_VAULT_PATH=.tmp/fbt-memory node ./bin/fuckbigtech.mjs memory-test quick && FBT_CONFIG_DIR=.tmp/fbt-config FBT_VAULT_PATH=.tmp/fbt-memory node ./bin/fuckbigtech.mjs route-test demo"
+  }
+}