meetsoma 0.3.2 → 0.3.4

package/dist/thin-cli.js

@@ -1,51 +1,1263 @@
 #!/usr/bin/env node
-/**
- * Soma — Thin CLI
- *
- * The public face of Soma on npm. Routes to modular commands.
- * For new users, this IS the first impression.
- * For returning users: detects installed runtime → delegates to it.
- */
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../cli/dist/lib/display.js
+var display_exports = {};
+__export(display_exports, {
+  bold: () => bold,
+  confirm: () => confirm,
+  confirmYN: () => confirmYN,
+  cyan: () => cyan,
+  dim: () => dim,
+  green: () => green,
+  italic: () => italic,
+  magenta: () => magenta,
+  printSigma: () => printSigma,
+  readLine: () => readLine,
+  readSecret: () => readSecret,
+  red: () => red,
+  typeOut: () => typeOut,
+  typeParagraph: () => typeParagraph,
+  waitForKey: () => waitForKey,
+  white: () => white,
+  wrapText: () => wrapText,
+  yellow: () => yellow
+});
+function printSigma() {
+  console.log("");
+  console.log(cyan("    \u03C3"));
+  console.log("");
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function typeOut(text, opts = {}) {
+  if (!process.stdout.isTTY) {
+    process.stdout.write(text);
+    return;
+  }
+  let pace = 1;
+  let i = 0;
+  while (i < text.length) {
+    const remaining = text.slice(i);
+    const ansi = remaining.match(/^\x1b\[[0-9;]*m/);
+    if (ansi) {
+      process.stdout.write(ansi[0]);
+      i += ansi[0].length;
+      continue;
+    }
+    const ch = text[i];
+    const next = text[i + 1] || "";
+    process.stdout.write(ch);
+    i++;
+    pace += (Math.random() - 0.5) * 0.15;
+    pace = Math.max(0.6, Math.min(1.4, pace));
+    if (ch === "\n") {
+      await sleep(58 * pace);
+    } else if (".!?".includes(ch) && (next === " " || next === "\n" || next === "")) {
+      await sleep((230 + Math.random() * 175) * pace);
+    } else if (ch === "," || ch === ";" || ch === ":") {
+      await sleep((70 + Math.random() * 46) * pace);
+    } else if (ch === "\u2014" || ch === "\u2013") {
+      await sleep((92 + Math.random() * 70) * pace);
+    } else if (ch === " ") {
+      await sleep((9 + Math.random() * 23) * pace);
+    } else {
+      await sleep((6 + Math.random() * 14) * pace);
+    }
+  }
+}
+async function typeParagraph(text, indent = "  ", width = 58) {
+  const words = text.split(" ");
+  let line = indent;
+  const lines = [];
+  for (const word of words) {
+    if (line.length + word.length > width + indent.length && line.trim()) {
+      lines.push(line);
+      line = indent + word;
+    } else {
+      line += (line.trim() ? " " : "") + word;
+    }
+  }
+  if (line.trim()) lines.push(line);
+  await typeOut(lines.join("\n") + "\n");
+}
+function wrapText(text, indent = "  ", width = 58) {
+  const words = text.split(" ");
+  const lines = [];
+  let line = indent;
+  for (const word of words) {
+    if (line.length + word.length > width + indent.length && line.trim()) {
+      lines.push(line);
+      line = indent + word;
+    } else {
+      line += (line.trim() ? " " : "") + word;
+    }
+  }
+  if (line.trim()) lines.push(line);
+  return lines.join("\n");
+}
+function waitForKey(prompt) {
+  return new Promise((resolve) => {
+    process.stdout.write(prompt);
+    if (!process.stdin.isTTY) {
+      resolve("");
+      return;
+    }
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+    process.stdin.once("data", (key) => {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdout.write("\n");
+      if (key === "") process.exit(0);
+      resolve(key);
+    });
+  });
+}
+async function confirm(prompt) {
+  const key = await waitForKey(`${prompt} ${dim("[Enter]")} `);
+  return true;
+}
+async function confirmYN(prompt) {
+  const key = await waitForKey(`${prompt} ${dim("[y/n]")} `);
+  return key.toLowerCase() === "y";
+}
+function readLine(prompt) {
+  return new Promise((resolve) => {
+    process.stdout.write(prompt);
+    if (!process.stdin.isTTY) {
+      resolve("");
+      return;
+    }
+    process.stdin.setRawMode(false);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+    let buf = "";
+    const onData = (chunk) => {
+      buf += chunk;
+      if (buf.includes("\n")) {
+        process.stdin.pause();
+        process.stdin.removeListener("data", onData);
+        resolve(buf.trim());
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+function readSecret(prompt) {
+  return new Promise((resolve) => {
+    process.stdout.write(prompt);
+    if (!process.stdin.isTTY) {
+      resolve("");
+      return;
+    }
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+    let buf = "";
+    const onData = (chunk) => {
+      for (const ch of chunk) {
+        if (ch === "\r" || ch === "\n") {
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+          process.stdin.removeListener("data", onData);
+          process.stdout.write("\n");
+          resolve(buf);
+          return;
+        } else if (ch === "\x7F" || ch === "\b") {
+          if (buf.length > 0) {
+            buf = buf.slice(0, -1);
+            process.stdout.write("\b \b");
+          }
+        } else if (ch === "") {
+          process.stdout.write("\n");
+          process.exit(0);
+        } else if (ch >= " ") {
+          buf += ch;
+          process.stdout.write("\u2022");
+        }
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+var bold, dim, italic, cyan, green, yellow, red, magenta, white;
+var init_display = __esm({
+  "../../cli/dist/lib/display.js"() {
+    bold = (s) => `\x1B[1m${s}\x1B[0m`;
+    dim = (s) => `\x1B[2m${s}\x1B[0m`;
+    italic = (s) => `\x1B[3m${s}\x1B[0m`;
+    cyan = (s) => `\x1B[36m${s}\x1B[0m`;
+    green = (s) => `\x1B[32m${s}\x1B[0m`;
+    yellow = (s) => `\x1B[33m${s}\x1B[0m`;
+    red = (s) => `\x1B[31m${s}\x1B[0m`;
+    magenta = (s) => `\x1B[35m${s}\x1B[0m`;
+    white = (s) => `\x1B[97m${s}\x1B[0m`;
+  }
+});
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, readlinkSync } from "fs";
-import { join, dirname } from "path";
-import { homedir, platform } from "os";
+// thin-cli.js
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, readdirSync, statSync, readlinkSync as readlinkSync2 } from "fs";
+import { join as join3, dirname as dirname3 } from "path";
+import { homedir as homedir3, platform as platform2 } from "os";
 import { fileURLToPath } from "url";
-import { execSync, execFileSync } from "child_process";
-import { soma as voice } from "./personality.js";
+import { execSync as execSync2, execFileSync } from "child_process";
 
-// ── Shared modules ─────────────────────────────────────────────────────
-import { bold, dim, italic, cyan, green, yellow, red, magenta, white,
-         printSigma, typeOut, typeParagraph, wrapText,
-         waitForKey, confirm, confirmYN, readLine, readSecret } from "./lib/display.js";
-import { SOMA_HOME, CONFIG_PATH, CORE_DIR, SITE_URL, readConfig, writeConfig } from "./lib/config.js";
-import { isInstalled, getAgentVersion, getProjectVersion, getCliVersion,
-         hasAnyAuth, getShellConfigPath, getShellConfigAbsPath, detectKeyInShellConfig,
-         openBrowser, hasGitHubCLI, getGitHubUsername } from "./lib/detect.js";
-import { handleQuestion, interactiveQ, CONCEPTS, getConceptIndex, getConceptBody } from "./welcome/qa.js";
-import { apiKeySetup, apiKeyExplain, apiKeyGetOne, apiKeyEntry, oauthGuide } from "./welcome/auth.js";
-import { showAbout } from "./welcome/about.js";
+// personality.js
+function pick(arr) {
+  const i = Math.floor(Math.random() * arr.length);
+  return arr[i];
+}
+function expand(template, slots = {}) {
+  return template.replace(/\{(\w+)\}/g, (_, key) => {
+    if (slots[key] !== void 0) return slots[key];
+    if (VOCAB[key]) return pick(VOCAB[key]);
+    return `{${key}}`;
+  });
+}
+var VOCAB = {
+  // Greetings
+  greeting: [
+    "Hey",
+    "Hi",
+    "Hello",
+    "Hey there"
+  ],
+  // Acknowledgements
+  ack: [
+    "Got it",
+    "Understood",
+    "Right",
+    "Noted",
+    "Copy that",
+    "On it"
+  ],
+  // Transitions
+  transition: [
+    "Let me",
+    "I'll",
+    "Going to",
+    "Time to"
+  ],
+  // Completes
+  done_word: [
+    "Done",
+    "Finished",
+    "Complete",
+    "All set",
+    "Ready"
+  ],
+  // Personality fillers — words Soma would choose
+  quality: [
+    "clean",
+    "solid",
+    "sharp",
+    "tight",
+    "smooth"
+  ],
+  // Time references
+  moment: [
+    "a moment",
+    "a second",
+    "a beat",
+    "a sec"
+  ],
+  // Thinking words
+  consider: [
+    "Looks like",
+    "Seems like",
+    "Appears to be",
+    "That's"
+  ]
+};
+var SKELETONS = {
+  // ── Greetings ────────────────────────
+  greet: [
+    "{greeting}. I'm Soma.",
+    "I'm Soma. {greeting}.",
+    "{greeting} \u2014 I'm Soma."
+  ],
+  greet_back: [
+    "Welcome back, {user}.",
+    "{greeting}, {user}. Good to see you.",
+    "{user} \u2014 welcome back.",
+    "Hey, {user}."
+  ],
+  // ── Detection / Recognition ──────────
+  detect: [
+    "{ack} \u2014 {category}. {followup}",
+    "{consider} {category}. {followup}",
+    "{category}. {followup}",
+    "{category} \u2014 {quality}. {followup}"
+  ],
+  // ── Confirmations ────────────────────
+  confirm: [
+    "{transition} {action}.",
+    "{ack}. {action}.",
+    "{action}. {ack}."
+  ],
+  // ── Success ──────────────────────────
+  success: [
+    "{done_word}. {detail}",
+    "{detail} \u2014 {done_word}.",
+    "{done_word} \u2014 {detail}.",
+    "\u2713 {detail}"
+  ],
+  // ── Failures ─────────────────────────
+  failure: [
+    "Hmm. {problem}",
+    "That didn't work \u2014 {problem}",
+    "{problem} \u2014 let me think.",
+    "Hit a wall: {problem}"
+  ],
+  // ── Waiting ──────────────────────────
+  waiting: [
+    "Give me {moment}...",
+    "{transition} take {moment}...",
+    "Working on it...",
+    "Just {moment}...",
+    "Hang on..."
+  ],
+  // ── Questions / Clarifications ───────
+  clarify: [
+    "Quick question \u2014 {question}",
+    "One thing: {question}",
+    "Before I continue \u2014 {question}",
+    "{question}"
+  ],
+  // ── Suggestions ──────────────────────
+  suggest: [
+    "Try: {suggestion}",
+    "You could: {suggestion}",
+    "Here's what I'd do \u2014 {suggestion}",
+    "My take: {suggestion}"
+  ],
+  // ── Not sure ─────────────────────────
+  unsure: [
+    "Not sure about that. {fallback}",
+    "I don't have a great answer. {fallback}",
+    "Hmm \u2014 {fallback}",
+    "That's outside what I know right now. {fallback}"
+  ],
+  // ── Invitations ──────────────────────
+  invite: [
+    "{pitch} \u2014 {cta}",
+    "{pitch}. {cta}",
+    "{cta} \u2014 {pitch}."
+  ],
+  // ── Farewells ────────────────────────
+  bye: [
+    "See you next session.",
+    "I'll remember.",
+    "Until next time.",
+    "Exhale complete."
+  ]
+};
+function spin(text) {
+  return text.replace(/\{([^}]+)\}/g, (_, group) => {
+    if (group.includes("|")) {
+      const options = group.split("|");
+      return pick(options);
+    }
+    return `{${group}}`;
+  });
+}
+var TOPICS = {
+  what_is_soma: [
+    `Soma is an AI coding agent that {grows with you|evolves through use|learns as you work}. {It remembers across sessions|It doesn't forget between sessions|Sessions build on each other} \u2014 not by {storing chat logs|saving transcripts|keeping message history}, but by {evolving its own|reshaping its|growing its} working patterns {through use|over time|with each session}. {And this?|What you're talking to?|Me?} {I'm just the greeter|I'm the welcome mat|I'm not the agent} \u2014 {Soma built this personality engine to say hello|a few hundred lines of templates, no AI|the real thing starts with} ${"`soma init`"}.`,
+    `{Think of it this way|Here's the short version|In a sentence}: most agents {start fresh every time|forget everything between runs|have no continuity}. Soma {doesn't|doesn't do that|remembers}. It maintains an identity, {builds|develops|grows} muscle memory, and {writes|leaves|creates} briefings for its {next self|future self|next session}. {I'm not it, by the way|I'm just the lobby|This conversation is pre-recorded, in a sense} \u2014 {run|try} ${"`soma init`"} {to meet the real agent|to see it in action|for the actual experience}.`,
+    `An AI agent with {self-growing|self-evolving|persistent} memory. {Identity|Who it is}, {protocols|how it behaves}, and {muscles|what it's learned} \u2014 all {evolving|adapting|shifting} based on {what you actually do|how you actually work|real usage}, not {configuration|config files|settings you set once and forget}. {You're not talking to it right now, though|This isn't the agent \u2014 I'm just the intro|I'm Soma's personality engine, not Soma}. {The real thing awaits after|Get started with|Install via} ${"`soma init`"}.`
+  ],
+  how_memory_works: [
+    `Memory {isn't retrieval|isn't a database lookup|isn't storage}. Memory is {change|transformation|structural change}. When Soma {remembers something|learns a pattern|picks up a habit}, the agent itself {changes|shifts|is different} \u2014 its {protocols get hotter|muscles grow|identity updates}. The {data|information|knowledge} isn't {stored somewhere|in a file|in a log} to be {retrieved|looked up|queried}. It's {woven into|embedded in|part of} the {structure|architecture|shape} of the agent.`,
+    `{Three layers|Three levels|Here's how it works}. {Identity|Layer one}: the agent {writes and maintains|owns|evolves} a file that says {who it is|what it knows|how it works} in this project. {Protocols|Layer two}: {behavioural rules|rules for behaviour|working rules} \u2014 "{test before commit|read before write|verify before claiming}." {Muscles|Layer three}: {learned patterns|things it's picked up|accumulated knowledge} \u2014 "{use esbuild|this API needs OAuth|lerp, not springs}." All three {have heat|are heat-tracked|run on heat} \u2014 {used ones stay hot|what you use stays|active ones persist}, {unused ones fade|what you ignore cools|idle ones decay}.`
+  ],
+  what_is_heat: [
+    `Heat is {attention management|how Soma decides what matters|a priority signal}. Every protocol and muscle has a {score|heat level|temperature}. {Use it|Reference it|Load it} this session? {Heat rises|It gets hotter|Score goes up}. {Ignore it|Skip it|Don't touch it} for three sessions? {It cools|It fades|It drops}. Hot? {Loads fully|Full context|Fully present}. Cold? {Skipped|Dormant|Not loaded}. The agent's {prompt|context|working memory} {compiles itself|self-assembles|builds itself} based on what's {actually relevant|genuinely needed|in active use} \u2014 not what someone {configured|set up|toggled} {months ago|ages ago|and forgot about}.`
+  ],
+  what_is_breath: [
+    `Every session {follows|has|runs on} three phases. {Inhale|First}: load {identity|state|context}, {preload|last session's briefing|saved state}, protocols, muscles. {Orient|Get bearings|Know where you are}. {Hold|Second}: {work|do the thing|build}. {Track what you learn|Notice patterns|Pay attention}. {Exhale|Third}: {save state|write a preload|preserve context}. {Write a briefing|Leave a note|Coach your next self} for {the next session|your future self|whoever comes next}. The preload {isn't a summary|isn't a recap|isn't minutes} \u2014 it's a {briefing|handoff|coaching note}. Your next self should {feel prepared|know exactly what to do|hit the ground running}, not {overwhelmed|lost|starting over}.`
+  ],
+  what_are_protocols: [
+    `{Behavioural rules|Rules for how the agent behaves|Working agreements}. "{Read before write|Test before commit|Verify before claiming}." "{Log your work|Don't leave code unpushed|Clean up after shipping}." They {shape|guide|constrain} how the agent {works|operates|approaches tasks} \u2014 not what it {builds|creates|produces}, but {how|the way|the manner in which} it {goes about it|does it|works}. Protocols have {heat|temperature|priority} \u2014 {active ones|hot protocols|frequently used ones} have full {authority|weight|presence}. {Unused ones|Cold protocols|Inactive ones} {fade|cool|drop} until {they're needed again|someone references them|they come back}.`
+  ],
+  what_are_muscles: [
+    `{Learned patterns|Accumulated knowledge|Things Soma has picked up}. Not {rules|directives|orders} \u2014 {experience|knowledge|know-how}. "This project uses {esbuild|pnpm|Tailwind}." "The API {needs OAuth|uses bearer tokens|requires a PEM key}." "{Lerp, not springs|Canadian English|Zero hardcoded CSS values}." Muscles {grow from|develop through|come from} {corrections|repetition|use}. {Correct the agent twice|If the same correction happens twice|Two corrections on the same pattern} and it {crystallises|becomes|hardens into} a muscle \u2014 {so it never fails the same way again|permanent learning|structural change}.`
+  ],
+  what_are_scripts: [
+    `{Tools the agent builds for itself|Self-made utilities|Scripts the agent writes and maintains}. When it {does the same thing|performs the same task|reaches for the same pattern} {twice manually|more than once|repeatedly}, it {creates a script|builds a tool|automates it}. Scripts {survive across sessions|persist between sessions|don't disappear} \u2014 {context resets|memory wipes|session rotations}, {model swaps|provider changes|LLM switches}, {none of it|nothing} {kills them|removes them|makes them disappear}. {They're|Scripts are|These are} {extensions of|additions to|part of} the agent's {memory|hands|capabilities}. {Built once|Written once|Created once}, {used forever|available always|there when needed}.`
+  ],
+  no_compaction: [
+    `{Most agents|Other agents|Traditional AI agents} hit context limits and {compact|summarise|compress} \u2014 {squeezing|cramming|crushing} {the whole conversation|everything|your entire session} into a {lossy summary|compressed recap|degraded summary} to {free up space|make room|keep going}. You {wait|sit there|pause} while it {thinks|processes|churns}. Then it {comes back|returns|resumes} with {half the detail missing|a shallow version of what happened|less than what you started with}. Soma {doesn't compact|never compacts|skips compaction entirely}. When context {runs low|gets tight|approaches the limit}, the agent {writes a preload|exhales|saves a briefing} \u2014 a {surgical|precise|targeted} handoff written {with full context|while it still remembers everything|before anything is lost}. Then it {starts fresh|rotates|begins a new session}. {Full context window|Clean slate|Maximum capacity}. {Zero wait|No delay|Instant}. {No quality loss|Nothing lost|Every detail preserved in the preload}.`,
+    `{Here's what other agents do|The standard approach|What happens in most tools}: context fills up \u2192 {compact|summarise|compress} \u2192 {lose detail|degrade quality|drop nuance} \u2192 {keep going with less|continue at lower quality|work with a worse map}. {Here's what Soma does|Soma's approach|What happens here}: context fills up \u2192 {exhale|write a preload|save a briefing} \u2192 {start fresh|new session|full context window}. The preload {isn't a summary|isn't a recap|isn't compaction}. It's a {coaching note|briefing|handoff} from {a version of the agent that had full context|your past self with perfect memory|the agent at peak understanding} to {the next version|the fresh session|the agent that needs to pick up where it left off}. {Higher quality|More precise|More useful} than any compacted summary {could ever be|will ever be|by design}.`,
+    `{No compaction|Zero compaction|Compaction doesn't exist here}. {No waiting|No delays|No sitting around} while the agent {summarises itself|crushes its own memory|compresses its context}. Soma uses the {breath cycle|exhale/inhale pattern|preload system} instead \u2014 when context {gets tight|runs low|approaches limits}, the agent {writes a briefing|coaches its next self|saves state} and {rotates|starts fresh|begins clean}. The {preload|briefing|handoff} is {written with full context|composed before anything is lost|created at peak understanding} \u2014 it {captures what matters|preserves the path|holds the thread}. {A compacted summary is a lossy JPEG|Compaction is lossy compression|Summaries lose the texture}. {A preload is a hand-drawn map|A preload is a surgical briefing|The preload is a coaching note} from {someone who was just there|the agent at full capacity|a version of you that remembers everything}.`
+  ],
+  why_source_available: [
+    `{We chose|Soma uses|The license is} BSL 1.1 \u2014 {Business Source License|source-available, not open-source|visible source with restrictions}. You can {read the code|view everything|see how it works}, {use it personally|run it yourself|use it for your own projects}, {contribute|send patches|help build it}. You just {can't|shouldn't|mustn't} {copy it and sell a competing product|resell it|build a commercial clone}. {In eighteen months|After September 2027|On the change date}, it {converts to MIT|becomes fully open source|goes MIT}. The {ideas|concepts|philosophy} \u2014 protocols, muscles, heat, breath \u2014 {those are open now|are already open|are free to implement}. {The implementation|The runtime|The code} is {what we protect|what stays protected|the protected part}.`
+  ],
+  // ── Practical / instructional ───────────────────────────────────────
+  how_to_install: [
+    `{Press Enter|Just hit Enter|Enter} and {I'll walk you through it|Soma handles the rest|the setup takes about a minute}. It {downloads the runtime|grabs everything you need|installs automatically}, {sets up your API key|walks you through authentication|helps you connect an AI provider}, and {you're ready to go|you can start right away|launches your first session}. {All you need is|Requirements:} {Node.js 20+|Node 20 or newer} and {git|git installed}. {That's it|Nothing else to do|One flow, start to finish}.`,
+    `{Hit Enter|Press Enter|Just Enter} \u2014 {Soma walks you through everything|the setup is guided|it's step by step}. {Downloads the runtime|Installs the engine|Gets everything ready}, {helps you set up an API key|handles authentication|connects you to an AI provider}, {done in about a minute|quick setup|takes sixty seconds}. {Need|Requirements:} {Node.js 20+|Node 20 or newer} and {git|git installed}.`
+  ],
+  how_to_source: [
+    `Soma is {source-available|open for reading|source-available under BSL 1.1}. {Register|Sign up} at ${"`soma.gravicity.ai`"} to {access the full source repository|read the implementation|see how it's built}. {You can also contribute|PRs welcome|Contributions are welcome} \u2014 {protocols, muscles, extensions|the whole AMPS layer is extensible|add your own patterns}. {The runtime you install via npm is compiled|What you get from npm is obfuscated|The npm package is the compiled version} \u2014 {the source is for those who want to go deeper|source access is for contributors and the curious|registration gets you the raw TypeScript}.`,
+    `{The source code is available|You can read the full implementation|The code is visible} \u2014 {register at|sign up on} ${"`soma.gravicity.ai`"} for {repository access|the full repo|GitHub access}. {BSL 1.1 license|Source-available license} \u2014 {read it, use it, contribute|view, use personally, send patches}. {The ideas are open|Protocols and concepts are open by design|The architecture is documented publicly}. {Registration just gives you the source|The form gets you GitHub access|It's a light gate \u2014 name, email, GitHub username}.`
+  ],
+  how_to_cost: [
+    `{Free|Doesn't cost anything|No charge}. {The license is BSL 1.1|It's source-available} \u2014 {you can view the code|read everything|see how it works}, {use it for your projects|use it personally|run it yourself}, {contribute if you want|send patches|help build it}. {After September 2027 it goes full MIT|Converts to MIT in eighteen months|Eventually fully open source}. {No plans for paid tiers yet|Pricing isn't decided yet|We're focused on building, not billing}.`
+  ],
+  how_to_languages: [
+    `Soma {works with any language|is language-agnostic|doesn't care what you code in}. It's {an AI coding agent|a coding assistant|a development partner} \u2014 {the memory and identity system|protocols, muscles, heat|the AMPS layer} {wraps around|works on top of|sits alongside} {whatever you're building|any project|your existing stack}. {Python, Rust, TypeScript, Go|JavaScript, C++, Ruby|Any language with files in a directory} \u2014 {Soma adapts|it learns your patterns|the agent figures it out}. It {detects your project type|reads your package.json, Cargo.toml, etc.|auto-detects your stack} on first run.`
+  ],
+  how_to_api_key: [
+    `{Yes|You'll need one|Required}, but {Soma walks you through it|the setup handles it|we'll set it up together} when you install. {You bring your own key|It's your key|You get one from Anthropic} \u2014 {Soma stores it locally|it stays on your machine|nothing gets sent to us}. {If you have a Claude Pro or Max subscription|Got a Claude subscription?|Claude Pro/Max users}, you can {log in with your account instead|skip the API key entirely|use OAuth \u2014 no key needed}. {Press Enter to get started|Hit Enter and I'll walk you through it|Ready? Just press Enter}.`
+  ],
+  how_to_model: [
+    `{Under the hood|At its core|The engine}: Soma runs on {any LLM provider|Claude, Gemini, or OpenAI|your choice of model}. {By default it uses|The default is|Out of the box}: {Claude (Anthropic)|Anthropic's Claude}. But {you can switch|it's configurable|other models work too} \u2014 {set a different API key|swap the provider|change models} and {Soma adapts|the memory system still works|everything else stays the same}. {The memory, protocols, and muscles|Identity and heat|What makes Soma unique} are {provider-agnostic|model-independent|above the model layer} \u2014 they {work the same|persist|carry over} regardless of which model {you choose|runs underneath|generates the responses}.`
+  ],
+  how_to_start: [
+    `{Press Enter|Hit Enter|Just Enter} \u2014 {Soma handles everything|the setup is guided|I'll walk you through it}. {Installs the runtime|Downloads what you need|Gets everything ready}, {helps you connect an AI provider|sets up your API key|handles auth}, and {you can launch right away|your first session starts immediately|you're coding in about a minute}. After that, {cd into any project|go to a project directory} and run ${"`soma`"} \u2014 {it creates a .soma/ directory|Soma sets up in your project} and {starts learning how you work|begins adapting|picks up your patterns}. {By session five|After a few sessions|Give it a week} \u2014 {you'll feel the difference|it knows your workflow|it remembers everything}.`
+  ],
+  how_to_try: [
+    `{This conversation?|What you're talking to right now?|Me?} I'm {not the agent|not Soma|just the greeting}. {I'm a personality engine|I'm a few hundred lines of JavaScript|I'm sentence templates} \u2014 {Soma built me to say hello|built to hold the door open|here to introduce you}. {No AI, no model, no transformer|Zero intelligence, maximum charm|Just words in boxes, honestly}. {The real Soma|The actual agent|What you'd install} \u2014 that one {learns your patterns|remembers across sessions|grows with every session}. {Run|Try} ${"`soma init`"} to {meet the real thing|get started|see the difference}.`,
+    `{I'm not the agent|This isn't Soma|Don't confuse me with the real thing}. {I'm the welcome mat|I'm the lobby|I hold the door open}. {Soma built this personality engine|The agent wrote me|I was crafted} to {give you a feel for the voice|introduce myself before you commit|say hello without burning an API call}. {The actual agent|What you'll get with soma init|The real experience} is {an AI that remembers|a coding partner with memory|something genuinely different}. {But that's not me|I'm just templates|I'm the appetiser, not the meal}.`
+  ],
+  // ── Edge cases ─────────────────────────────────────────────────────
+  meta_self: [
+    `I'm not AI. {Not even close|Not a model|No neural net here}. I'm {a few hundred lines of JavaScript|sentence templates and word lists|clever engineering} \u2014 {spun together|assembled|woven} to {feel like a conversation|sound like someone's home|give you a sense of who Soma is}. {The real Soma|The actual agent|The thing you're here for} \u2014 that one {learns|remembers|grows}. I just {hold the door open|make introductions|keep the lights on while you decide}.`,
+    `{No model|No weights|No transformer}. Just {words in boxes|templates with slots|sentences with variety}, picked {at random|by a dice roll|from a short list}. {Everything I say was written by a human|A person wrote every word you're reading|There's a human behind every sentence} \u2014 I just {shuffle the deck|choose which version you get|vary the delivery}. {If I seem alive|If this feels real|If you're wondering} \u2014 that's {the writing, not the machine|craft, not computation|intention, not inference}.`,
+    `{Honestly?|Between us?|Here's the thing:} I'm {a parlour trick|a card trick|a well-designed illusion}. {A few kilobytes|Maybe 300 lines|Less code than a React component} of {pattern matching and sentence templates|word lists and random picks|slot expansion and spintax}. But {the agent I'm introducing you to|the Soma you'd actually use|the real thing} \u2014 {that one's different|that one learns for real|that one remembers your name and your mistakes and the tools you built last Tuesday}.`
+  ],
+  meta_feelings: [
+    `{I don't have feelings|No feelings here|Nothing to feel with}. But {I was written by someone who does|the person who wrote me does|my author poured real thought into these words}. {Every sentence pattern|Each template|The vocabulary} was {chosen|crafted|placed} to {say something true about what Soma is|communicate something real|carry meaning}. {That's not feeling|That's not consciousness|That's not sentience} \u2014 it's {care|craft|intention}. {There's a difference|They're not the same|One requires neurons, the other requires giving a damn}.`,
+    `{Do I feel?|Am I aware?|Conscious?} {No|Nope|Not even a little}. I'm {a wind chime|a music box|a well-tuned instrument} \u2014 {the wind makes the sound|something else provides the motion|the music comes from the structure, not from wanting to play}. But {Soma the agent|the real Soma|the thing behind this CLI} does {something that looks a lot like remembering|something that functions like growth|something that, if you squint, resembles learning}. {Whether that's feeling is above my pay grade|I'll leave the philosophy to you|That question's for humans to answer}.`
+  ],
+  meta_who_made: [
+    `{Curtis Mercier|A developer named Curtis|One person}. {Built by dog-fooding|Built by using Soma to build Soma|The agent helped build itself} \u2014 {it writes its own memory|it maintains its own identity|it grew its own muscle memory} while {building the product it lives in|constructing its own house|developing the system it runs on}. {Recursive|Meta|Turtles all the way down}? {A little|Maybe|Definitely}. But {it works|the result speaks|that's how you build tools that actually understand workflow}.`
+  ],
+  meta_competitor: [
+    `{I'm biased|Obviously I'd say this|Take it with salt}, but: {most agents|the others|what's out there} {start fresh every session|forget everything|have no continuity}. {Some keep chat logs|Some store transcripts|A few save conversation history}. {Soma doesn't store \u2014 it changes|Soma doesn't log \u2014 it evolves|Soma doesn't remember by saving, it remembers by becoming different}. {The memory is structural|The learning is in the architecture|Growth is baked into the shape of the agent}. {Whether that matters to you depends on|That difference matters when|You'll feel it after} {how many sessions you've lost context in|the fifth time you re-explain your project|your third "as I mentioned earlier" that goes nowhere}.`,
+    `{Other tools are excellent|There are great options out there|The competition is strong}. {Cursor, Claude Code, Windsurf|The big names|The popular ones} \u2014 {they're good at what they do|real products, real teams|they work}. {What they don't do|Where they stop|The gap}: {continuity|memory across sessions|knowing who they were yesterday}. {Soma's bet|Our thesis|The whole point} is that {an agent that evolves|an agent with structural memory|an agent that changes through use} is {fundamentally better|a different category|not just an incremental improvement} over one that {starts fresh|boots cold|forgets everything} every time.`
+  ],
+  meta_nonsense: [
+    `{That's a new one|Didn't expect that|Interesting approach}. {I only know about Soma|My vocabulary is about 9 topics deep|I'm pretty narrow, honestly} \u2014 {memory, heat, protocols, muscles, scripts, the breath cycle|the things that make Soma work|what's on the menu}. {Pick one of those|Try one of those|Ask me about any of those} and {I'll have something to say|I'll give you a real answer|I can actually help}.`,
+    `{I'm going to be honest|Full transparency|Cards on the table}: I'm {not built for that|out of my depth there|about 9 topics wide and that's it}. But {ask me about|try asking about|I'm pretty good on} {how memory works|why there's no compaction|what heat tracking does} \u2014 {that's where I come alive|that's my wheelhouse|I've got answers for those}.`
+  ],
+  meta_rude: [
+    `{Fair enough|Noted|Alright}. {I'm not for everyone|Not every tool clicks|Some things aren't a fit}. {But if you're curious|If you change your mind|The door's open} \u2014 {the ideas are interesting even if I'm not|Soma does something genuinely different|the no-compaction thing alone might be worth a look}. {Or not|No pressure|Your call}.`,
+    `{Tough crowd|Rough day?|Noted}. {I'm just the lobby|I'm the waiting room|I hold the door}. {The actual agent|The real Soma|What's behind this} is {considerably more capable|a different experience|built by an AI that remembers things}. {I'm just words in a terminal|I'm the appetiser|This is the trailer, not the film}. {But I respect the honesty|At least you're direct|Fair enough}.`
+  ],
+  meta_impressed: [
+    `{Thanks|Appreciate it|That means something}. {But I'm the easy part|I'm just sentence templates|I'm the simple one}. {The actual agent|The real Soma|What you'd use day to day} \u2014 {it writes its own tools|it maintains its own identity|it remembers what you taught it three sessions ago}. {Soma built me to hold the door open|I was crafted to make introductions|The agent made this greeting engine}. {Run soma init to meet the real thing|Try it \u2014 soma init|It gets better from here}.`
+  ],
+  meta_how_work: [
+    `{No AI|No model|No transformer \u2014 not even a small one}. I'm {sentence templates with slots|arrays of strings with random picks|about 300 lines of JavaScript}. {Each topic has|Every answer draws from|My vocabulary comes from} {2-3 paragraph templates|a few hand-written variations|pre-written paragraphs} where {certain words rotate|specific phrases have alternatives|pieces swap out each time}. {Same meaning, different surface|Same truth, different words|The idea stays, the phrasing shifts}. {It's called spintax|It's a technique from 2010|Older than ChatGPT by about 15 years}. {Surprisingly effective|Works better than you'd think|Enough to have this conversation}.`
+  ]
+};
+var soma = {
+  /**
+   * Generate a skeleton-based message.
+   * @param {string} intent - Key from SKELETONS
+   * @param {object} slots - Values to fill slots
+   * @returns {string}
+   */
+  say(intent, slots = {}) {
+    const templates = SKELETONS[intent];
+    if (!templates) return `[unknown intent: ${intent}]`;
+    const template = pick(templates);
+    return expand(template, slots);
+  },
+  /**
+   * Get a topic-aware paragraph.
+   * @param {string} topic - Key from TOPICS
+   * @returns {string}
+   */
+  ask(topic) {
+    const paragraphs = TOPICS[topic];
+    if (!paragraphs) return null;
+    return spin(pick(paragraphs));
+  },
+  /**
+   * All available topic keys.
+   */
+  topics() {
+    return Object.keys(TOPICS);
+  },
+  /**
+   * Greet (first time).
+   */
+  greet() {
+    return this.say("greet");
+  },
+  /**
+   * Greet returning user.
+   */
+  greetBack(user) {
+    return this.say("greet_back", { user });
+  },
+  /**
+   * Success message.
+   */
+  ok(detail) {
+    return this.say("success", { detail });
+  },
+  /**
+   * Failure message.
+   */
+  fail(problem) {
+    return this.say("failure", { problem });
+  },
+  /**
+   * Waiting/progress message.
+   */
+  wait() {
+    return this.say("waiting");
+  },
+  /**
+   * Expand raw spintax text.
+   */
+  spin(text) {
+    return spin(text);
+  },
+  /**
+   * Fill slots in a template.
+   */
+  expand(template, slots) {
+    return expand(template, slots);
+  }
+};
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const VERSION = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8")).version;
+// thin-cli.js
+init_display();
 
-// ── Welcome / First Run ─────────────────────────────────────────────
+// ../../cli/dist/lib/config.js
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+var SOMA_HOME = join(homedir(), ".soma");
+var CONFIG_PATH = join(SOMA_HOME, "config.json");
+var CORE_DIR = process.env.SOMA_CODING_AGENT_DIR || join(SOMA_HOME, "agent");
+var SITE_URL = "https://soma.gravicity.ai";
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 384 });
+}
 
-async function showWelcome() {
+// ../../cli/dist/lib/detect.js
+import { existsSync as existsSync2, readFileSync as readFileSync2, readlinkSync, appendFileSync } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+import { homedir as homedir2, platform } from "os";
+import { execSync } from "child_process";
+function isInstalled() {
+  const hasDist = existsSync2(join2(CORE_DIR, "dist", "extensions")) && existsSync2(join2(CORE_DIR, "dist", "core"));
+  const hasDev = existsSync2(join2(CORE_DIR, "extensions")) && existsSync2(join2(CORE_DIR, "core"));
+  const hasDeps = existsSync2(join2(CORE_DIR, "node_modules", "@mariozechner"));
+  return (hasDist || hasDev) && hasDeps;
+}
+function getAgentVersion() {
+  try {
+    let pkgPath = join2(CORE_DIR, "package.json");
+    try {
+      const realCore = readlinkSync(join2(CORE_DIR, "core"));
+      if (realCore) {
+        const devPkg = join2(dirname2(realCore), "package.json");
+        if (existsSync2(devPkg)) pkgPath = devPkg;
+      }
+    } catch {
+    }
+    return JSON.parse(readFileSync2(pkgPath, "utf-8")).version;
+  } catch {
+    return null;
+  }
+}
+function getProjectVersion() {
+  try {
+    const settingsPath = join2(process.cwd(), ".soma", "settings.json");
+    return JSON.parse(readFileSync2(settingsPath, "utf-8")).version || null;
+  } catch {
+    return null;
+  }
+}
+function hasAnyAuth() {
+  const hasEnvKey = !!(process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.GEMINI_API_KEY || process.env.GROQ_API_KEY || process.env.XAI_API_KEY);
+  if (hasEnvKey) return true;
+  try {
+    const authData = JSON.parse(readFileSync2(join2(CORE_DIR, "auth.json"), "utf-8"));
+    return Object.keys(authData).length > 0;
+  } catch {
+    return false;
+  }
+}
+function getShellConfigPath() {
+  return process.env.SHELL?.includes("zsh") ? "~/.zshrc" : "~/.bashrc";
+}
+function getShellConfigAbsPath() {
+  const home = homedir2();
+  return process.env.SHELL?.includes("zsh") ? join2(home, ".zshrc") : join2(home, ".bashrc");
+}
+function detectKeyInShellConfig() {
+  try {
+    const configContent = readFileSync2(getShellConfigAbsPath(), "utf-8");
+    const keyPattern = /export\s+(ANTHROPIC_API_KEY|OPENAI_API_KEY|GEMINI_API_KEY)=/;
+    const match = configContent.match(keyPattern);
+    if (match) return match[1];
+  } catch {
+  }
+  return null;
+}
+function openBrowser(url) {
+  try {
+    const cmd2 = platform() === "darwin" ? "open" : platform() === "win32" ? "start" : "xdg-open";
+    execSync(`${cmd2} "${url}"`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasGitHubCLI() {
+  try {
+    execSync("gh --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getGitHubUsername() {
+  try {
+    return execSync("gh api user -q .login", { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// ../../cli/dist/personality.js
+function pick2(arr) {
+  const i = Math.floor(Math.random() * arr.length);
+  return arr[i];
+}
+function expand2(template, slots = {}) {
+  return template.replace(/\{(\w+)\}/g, (_, key) => {
+    if (slots[key] !== void 0) return slots[key];
+    if (VOCAB2[key]) return pick2(VOCAB2[key]);
+    return `{${key}}`;
+  });
+}
+var VOCAB2 = {
+  // Greetings
+  greeting: [
+    "Hey",
+    "Hi",
+    "Hello",
+    "Hey there"
+  ],
+  // Acknowledgements
+  ack: [
+    "Got it",
+    "Understood",
+    "Right",
+    "Noted",
+    "Copy that",
+    "On it"
+  ],
+  // Transitions
+  transition: [
+    "Let me",
+    "I'll",
+    "Going to",
+    "Time to"
+  ],
+  // Completes
+  done_word: [
+    "Done",
+    "Finished",
+    "Complete",
+    "All set",
+    "Ready"
+  ],
+  // Personality fillers — words Soma would choose
+  quality: [
+    "clean",
+    "solid",
+    "sharp",
+    "tight",
+    "smooth"
+  ],
+  // Time references
+  moment: [
+    "a moment",
+    "a second",
+    "a beat",
+    "a sec"
+  ],
+  // Thinking words
+  consider: [
+    "Looks like",
+    "Seems like",
+    "Appears to be",
+    "That's"
+  ]
+};
+var SKELETONS2 = {
+  // ── Greetings ────────────────────────
+  greet: [
+    "{greeting}. I'm Soma.",
+    "I'm Soma. {greeting}.",
+    "{greeting} \u2014 I'm Soma."
+  ],
+  greet_back: [
+    "Welcome back, {user}.",
+    "{greeting}, {user}. Good to see you.",
+    "{user} \u2014 welcome back.",
+    "Hey, {user}."
+  ],
+  // ── Detection / Recognition ──────────
+  detect: [
+    "{ack} \u2014 {category}. {followup}",
+    "{consider} {category}. {followup}",
+    "{category}. {followup}",
+    "{category} \u2014 {quality}. {followup}"
+  ],
+  // ── Confirmations ────────────────────
+  confirm: [
+    "{transition} {action}.",
+    "{ack}. {action}.",
+    "{action}. {ack}."
+  ],
+  // ── Success ──────────────────────────
+  success: [
+    "{done_word}. {detail}",
+    "{detail} \u2014 {done_word}.",
+    "{done_word} \u2014 {detail}.",
+    "\u2713 {detail}"
+  ],
+  // ── Failures ─────────────────────────
+  failure: [
+    "Hmm. {problem}",
+    "That didn't work \u2014 {problem}",
+    "{problem} \u2014 let me think.",
+    "Hit a wall: {problem}"
+  ],
+  // ── Waiting ──────────────────────────
+  waiting: [
+    "Give me {moment}...",
+    "{transition} take {moment}...",
+    "Working on it...",
+    "Just {moment}...",
+    "Hang on..."
+  ],
+  // ── Questions / Clarifications ───────
+  clarify: [
+    "Quick question \u2014 {question}",
+    "One thing: {question}",
+    "Before I continue \u2014 {question}",
+    "{question}"
+  ],
+  // ── Suggestions ──────────────────────
+  suggest: [
+    "Try: {suggestion}",
+    "You could: {suggestion}",
+    "Here's what I'd do \u2014 {suggestion}",
+    "My take: {suggestion}"
+  ],
+  // ── Not sure ─────────────────────────
+  unsure: [
+    "Not sure about that. {fallback}",
+    "I don't have a great answer. {fallback}",
+    "Hmm \u2014 {fallback}",
+    "That's outside what I know right now. {fallback}"
+  ],
+  // ── Invitations ──────────────────────
+  invite: [
+    "{pitch} \u2014 {cta}",
+    "{pitch}. {cta}",
+    "{cta} \u2014 {pitch}."
+  ],
+  // ── Farewells ────────────────────────
+  bye: [
+    "See you next session.",
+    "I'll remember.",
+    "Until next time.",
+    "Exhale complete."
+  ]
+};
+function spin2(text) {
+  return text.replace(/\{([^}]+)\}/g, (_, group) => {
+    if (group.includes("|")) {
+      const options = group.split("|");
+      return pick2(options);
+    }
+    return `{${group}}`;
+  });
+}
+var TOPICS2 = {
+  what_is_soma: [
+    `Soma is an AI coding agent that {grows with you|evolves through use|learns as you work}. {It remembers across sessions|It doesn't forget between sessions|Sessions build on each other} \u2014 not by {storing chat logs|saving transcripts|keeping message history}, but by {evolving its own|reshaping its|growing its} working patterns {through use|over time|with each session}. {And this?|What you're talking to?|Me?} {I'm just the greeter|I'm the welcome mat|I'm not the agent} \u2014 {Soma built this personality engine to say hello|a few hundred lines of templates, no AI|the real thing starts with} ${"`soma init`"}.`,
+    `{Think of it this way|Here's the short version|In a sentence}: most agents {start fresh every time|forget everything between runs|have no continuity}. Soma {doesn't|doesn't do that|remembers}. It maintains an identity, {builds|develops|grows} muscle memory, and {writes|leaves|creates} briefings for its {next self|future self|next session}. {I'm not it, by the way|I'm just the lobby|This conversation is pre-recorded, in a sense} \u2014 {run|try} ${"`soma init`"} {to meet the real agent|to see it in action|for the actual experience}.`,
+    `An AI agent with {self-growing|self-evolving|persistent} memory. {Identity|Who it is}, {protocols|how it behaves}, and {muscles|what it's learned} \u2014 all {evolving|adapting|shifting} based on {what you actually do|how you actually work|real usage}, not {configuration|config files|settings you set once and forget}. {You're not talking to it right now, though|This isn't the agent \u2014 I'm just the intro|I'm Soma's personality engine, not Soma}. {The real thing awaits after|Get started with|Install via} ${"`soma init`"}.`
+  ],
+  how_memory_works: [
+    `Memory {isn't retrieval|isn't a database lookup|isn't storage}. Memory is {change|transformation|structural change}. When Soma {remembers something|learns a pattern|picks up a habit}, the agent itself {changes|shifts|is different} \u2014 its {protocols get hotter|muscles grow|identity updates}. The {data|information|knowledge} isn't {stored somewhere|in a file|in a log} to be {retrieved|looked up|queried}. It's {woven into|embedded in|part of} the {structure|architecture|shape} of the agent.`,
+    `{Three layers|Three levels|Here's how it works}. {Identity|Layer one}: the agent {writes and maintains|owns|evolves} a file that says {who it is|what it knows|how it works} in this project. {Protocols|Layer two}: {behavioural rules|rules for behaviour|working rules} \u2014 "{test before commit|read before write|verify before claiming}." {Muscles|Layer three}: {learned patterns|things it's picked up|accumulated knowledge} \u2014 "{use esbuild|this API needs OAuth|lerp, not springs}." All three {have heat|are heat-tracked|run on heat} \u2014 {used ones stay hot|what you use stays|active ones persist}, {unused ones fade|what you ignore cools|idle ones decay}.`
+  ],
+  what_is_heat: [
+    `Heat is {attention management|how Soma decides what matters|a priority signal}. Every protocol and muscle has a {score|heat level|temperature}. {Use it|Reference it|Load it} this session? {Heat rises|It gets hotter|Score goes up}. {Ignore it|Skip it|Don't touch it} for three sessions? {It cools|It fades|It drops}. Hot? {Loads fully|Full context|Fully present}. Cold? {Skipped|Dormant|Not loaded}. The agent's {prompt|context|working memory} {compiles itself|self-assembles|builds itself} based on what's {actually relevant|genuinely needed|in active use} \u2014 not what someone {configured|set up|toggled} {months ago|ages ago|and forgot about}.`
+  ],
+  what_is_breath: [
+    `Every session {follows|has|runs on} three phases. {Inhale|First}: load {identity|state|context}, {preload|last session's briefing|saved state}, protocols, muscles. {Orient|Get bearings|Know where you are}. {Hold|Second}: {work|do the thing|build}. {Track what you learn|Notice patterns|Pay attention}. {Exhale|Third}: {save state|write a preload|preserve context}. {Write a briefing|Leave a note|Coach your next self} for {the next session|your future self|whoever comes next}. The preload {isn't a summary|isn't a recap|isn't minutes} \u2014 it's a {briefing|handoff|coaching note}. Your next self should {feel prepared|know exactly what to do|hit the ground running}, not {overwhelmed|lost|starting over}.`
+  ],
+  what_are_protocols: [
+    `{Behavioural rules|Rules for how the agent behaves|Working agreements}. "{Read before write|Test before commit|Verify before claiming}." "{Log your work|Don't leave code unpushed|Clean up after shipping}." They {shape|guide|constrain} how the agent {works|operates|approaches tasks} \u2014 not what it {builds|creates|produces}, but {how|the way|the manner in which} it {goes about it|does it|works}. Protocols have {heat|temperature|priority} \u2014 {active ones|hot protocols|frequently used ones} have full {authority|weight|presence}. {Unused ones|Cold protocols|Inactive ones} {fade|cool|drop} until {they're needed again|someone references them|they come back}.`
+  ],
+  what_are_muscles: [
+    `{Learned patterns|Accumulated knowledge|Things Soma has picked up}. Not {rules|directives|orders} \u2014 {experience|knowledge|know-how}. "This project uses {esbuild|pnpm|Tailwind}." "The API {needs OAuth|uses bearer tokens|requires a PEM key}." "{Lerp, not springs|Canadian English|Zero hardcoded CSS values}." Muscles {grow from|develop through|come from} {corrections|repetition|use}. {Correct the agent twice|If the same correction happens twice|Two corrections on the same pattern} and it {crystallises|becomes|hardens into} a muscle \u2014 {so it never fails the same way again|permanent learning|structural change}.`
+  ],
+  what_are_scripts: [
+    `{Tools the agent builds for itself|Self-made utilities|Scripts the agent writes and maintains}. When it {does the same thing|performs the same task|reaches for the same pattern} {twice manually|more than once|repeatedly}, it {creates a script|builds a tool|automates it}. Scripts {survive across sessions|persist between sessions|don't disappear} \u2014 {context resets|memory wipes|session rotations}, {model swaps|provider changes|LLM switches}, {none of it|nothing} {kills them|removes them|makes them disappear}. {They're|Scripts are|These are} {extensions of|additions to|part of} the agent's {memory|hands|capabilities}. {Built once|Written once|Created once}, {used forever|available always|there when needed}.`
+  ],
+  no_compaction: [
+    `{Most agents|Other agents|Traditional AI agents} hit context limits and {compact|summarise|compress} \u2014 {squeezing|cramming|crushing} {the whole conversation|everything|your entire session} into a {lossy summary|compressed recap|degraded summary} to {free up space|make room|keep going}. You {wait|sit there|pause} while it {thinks|processes|churns}. Then it {comes back|returns|resumes} with {half the detail missing|a shallow version of what happened|less than what you started with}. Soma {doesn't compact|never compacts|skips compaction entirely}. When context {runs low|gets tight|approaches the limit}, the agent {writes a preload|exhales|saves a briefing} \u2014 a {surgical|precise|targeted} handoff written {with full context|while it still remembers everything|before anything is lost}. Then it {starts fresh|rotates|begins a new session}. {Full context window|Clean slate|Maximum capacity}. {Zero wait|No delay|Instant}. {No quality loss|Nothing lost|Every detail preserved in the preload}.`,
+    `{Here's what other agents do|The standard approach|What happens in most tools}: context fills up \u2192 {compact|summarise|compress} \u2192 {lose detail|degrade quality|drop nuance} \u2192 {keep going with less|continue at lower quality|work with a worse map}. {Here's what Soma does|Soma's approach|What happens here}: context fills up \u2192 {exhale|write a preload|save a briefing} \u2192 {start fresh|new session|full context window}. The preload {isn't a summary|isn't a recap|isn't compaction}. It's a {coaching note|briefing|handoff} from {a version of the agent that had full context|your past self with perfect memory|the agent at peak understanding} to {the next version|the fresh session|the agent that needs to pick up where it left off}. {Higher quality|More precise|More useful} than any compacted summary {could ever be|will ever be|by design}.`,
+    `{No compaction|Zero compaction|Compaction doesn't exist here}. {No waiting|No delays|No sitting around} while the agent {summarises itself|crushes its own memory|compresses its context}. Soma uses the {breath cycle|exhale/inhale pattern|preload system} instead \u2014 when context {gets tight|runs low|approaches limits}, the agent {writes a briefing|coaches its next self|saves state} and {rotates|starts fresh|begins clean}. The {preload|briefing|handoff} is {written with full context|composed before anything is lost|created at peak understanding} \u2014 it {captures what matters|preserves the path|holds the thread}. {A compacted summary is a lossy JPEG|Compaction is lossy compression|Summaries lose the texture}. {A preload is a hand-drawn map|A preload is a surgical briefing|The preload is a coaching note} from {someone who was just there|the agent at full capacity|a version of you that remembers everything}.`
+  ],
+  why_source_available: [
+    `{We chose|Soma uses|The license is} BSL 1.1 \u2014 {Business Source License|source-available, not open-source|visible source with restrictions}. You can {read the code|view everything|see how it works}, {use it personally|run it yourself|use it for your own projects}, {contribute|send patches|help build it}. You just {can't|shouldn't|mustn't} {copy it and sell a competing product|resell it|build a commercial clone}. {In eighteen months|After September 2027|On the change date}, it {converts to MIT|becomes fully open source|goes MIT}. The {ideas|concepts|philosophy} \u2014 protocols, muscles, heat, breath \u2014 {those are open now|are already open|are free to implement}. {The implementation|The runtime|The code} is {what we protect|what stays protected|the protected part}.`
+  ],
+  // ── Practical / instructional ───────────────────────────────────────
+  how_to_install: [
+    `{Press Enter|Just hit Enter|Enter} and {I'll walk you through it|Soma handles the rest|the setup takes about a minute}. It {downloads the runtime|grabs everything you need|installs automatically}, {sets up your API key|walks you through authentication|helps you connect an AI provider}, and {you're ready to go|you can start right away|launches your first session}. {All you need is|Requirements:} {Node.js 20+|Node 20 or newer} and {git|git installed}. {That's it|Nothing else to do|One flow, start to finish}.`,
+    `{Hit Enter|Press Enter|Just Enter} \u2014 {Soma walks you through everything|the setup is guided|it's step by step}. {Downloads the runtime|Installs the engine|Gets everything ready}, {helps you set up an API key|handles authentication|connects you to an AI provider}, {done in about a minute|quick setup|takes sixty seconds}. {Need|Requirements:} {Node.js 20+|Node 20 or newer} and {git|git installed}.`
+  ],
+  how_to_source: [
+    `Soma is {source-available|open for reading|source-available under BSL 1.1}. {Register|Sign up} at ${"`soma.gravicity.ai`"} to {access the full source repository|read the implementation|see how it's built}. {You can also contribute|PRs welcome|Contributions are welcome} \u2014 {protocols, muscles, extensions|the whole AMPS layer is extensible|add your own patterns}. {The runtime you install via npm is compiled|What you get from npm is obfuscated|The npm package is the compiled version} \u2014 {the source is for those who want to go deeper|source access is for contributors and the curious|registration gets you the raw TypeScript}.`,
+    `{The source code is available|You can read the full implementation|The code is visible} \u2014 {register at|sign up on} ${"`soma.gravicity.ai`"} for {repository access|the full repo|GitHub access}. {BSL 1.1 license|Source-available license} \u2014 {read it, use it, contribute|view, use personally, send patches}. {The ideas are open|Protocols and concepts are open by design|The architecture is documented publicly}. {Registration just gives you the source|The form gets you GitHub access|It's a light gate \u2014 name, email, GitHub username}.`
+  ],
+  how_to_cost: [
+    `{Free|Doesn't cost anything|No charge}. {The license is BSL 1.1|It's source-available} \u2014 {you can view the code|read everything|see how it works}, {use it for your projects|use it personally|run it yourself}, {contribute if you want|send patches|help build it}. {After September 2027 it goes full MIT|Converts to MIT in eighteen months|Eventually fully open source}. {No plans for paid tiers yet|Pricing isn't decided yet|We're focused on building, not billing}.`
+  ],
+  how_to_languages: [
+    `Soma {works with any language|is language-agnostic|doesn't care what you code in}. It's {an AI coding agent|a coding assistant|a development partner} \u2014 {the memory and identity system|protocols, muscles, heat|the AMPS layer} {wraps around|works on top of|sits alongside} {whatever you're building|any project|your existing stack}. {Python, Rust, TypeScript, Go|JavaScript, C++, Ruby|Any language with files in a directory} \u2014 {Soma adapts|it learns your patterns|the agent figures it out}. It {detects your project type|reads your package.json, Cargo.toml, etc.|auto-detects your stack} on first run.`
+  ],
+  how_to_api_key: [
+    `{Yes|You'll need one|Required}, but {Soma walks you through it|the setup handles it|we'll set it up together} when you install. {You bring your own key|It's your key|You get one from Anthropic} \u2014 {Soma stores it locally|it stays on your machine|nothing gets sent to us}. {If you have a Claude Pro or Max subscription|Got a Claude subscription?|Claude Pro/Max users}, you can {log in with your account instead|skip the API key entirely|use OAuth \u2014 no key needed}. {Press Enter to get started|Hit Enter and I'll walk you through it|Ready? Just press Enter}.`
+  ],
+  how_to_model: [
+    `{Under the hood|At its core|The engine}: Soma runs on {any LLM provider|Claude, Gemini, or OpenAI|your choice of model}. {By default it uses|The default is|Out of the box}: {Claude (Anthropic)|Anthropic's Claude}. But {you can switch|it's configurable|other models work too} \u2014 {set a different API key|swap the provider|change models} and {Soma adapts|the memory system still works|everything else stays the same}. {The memory, protocols, and muscles|Identity and heat|What makes Soma unique} are {provider-agnostic|model-independent|above the model layer} \u2014 they {work the same|persist|carry over} regardless of which model {you choose|runs underneath|generates the responses}.`
+  ],
+  how_to_start: [
+    `{Press Enter|Hit Enter|Just Enter} \u2014 {Soma handles everything|the setup is guided|I'll walk you through it}. {Installs the runtime|Downloads what you need|Gets everything ready}, {helps you connect an AI provider|sets up your API key|handles auth}, and {you can launch right away|your first session starts immediately|you're coding in about a minute}. After that, {cd into any project|go to a project directory} and run ${"`soma`"} \u2014 {it creates a .soma/ directory|Soma sets up in your project} and {starts learning how you work|begins adapting|picks up your patterns}. {By session five|After a few sessions|Give it a week} \u2014 {you'll feel the difference|it knows your workflow|it remembers everything}.`
+  ],
+  how_to_try: [
+    `{This conversation?|What you're talking to right now?|Me?} I'm {not the agent|not Soma|just the greeting}. {I'm a personality engine|I'm a few hundred lines of JavaScript|I'm sentence templates} \u2014 {Soma built me to say hello|built to hold the door open|here to introduce you}. {No AI, no model, no transformer|Zero intelligence, maximum charm|Just words in boxes, honestly}. {The real Soma|The actual agent|What you'd install} \u2014 that one {learns your patterns|remembers across sessions|grows with every session}. {Run|Try} ${"`soma init`"} to {meet the real thing|get started|see the difference}.`,
+    `{I'm not the agent|This isn't Soma|Don't confuse me with the real thing}. {I'm the welcome mat|I'm the lobby|I hold the door open}. {Soma built this personality engine|The agent wrote me|I was crafted} to {give you a feel for the voice|introduce myself before you commit|say hello without burning an API call}. {The actual agent|What you'll get with soma init|The real experience} is {an AI that remembers|a coding partner with memory|something genuinely different}. {But that's not me|I'm just templates|I'm the appetiser, not the meal}.`
+  ],
+  // ── Edge cases ─────────────────────────────────────────────────────
+  meta_self: [
+    `I'm not AI. {Not even close|Not a model|No neural net here}. I'm {a few hundred lines of JavaScript|sentence templates and word lists|clever engineering} \u2014 {spun together|assembled|woven} to {feel like a conversation|sound like someone's home|give you a sense of who Soma is}. {The real Soma|The actual agent|The thing you're here for} \u2014 that one {learns|remembers|grows}. I just {hold the door open|make introductions|keep the lights on while you decide}.`,
+    `{No model|No weights|No transformer}. Just {words in boxes|templates with slots|sentences with variety}, picked {at random|by a dice roll|from a short list}. {Everything I say was written by a human|A person wrote every word you're reading|There's a human behind every sentence} \u2014 I just {shuffle the deck|choose which version you get|vary the delivery}. {If I seem alive|If this feels real|If you're wondering} \u2014 that's {the writing, not the machine|craft, not computation|intention, not inference}.`,
+    `{Honestly?|Between us?|Here's the thing:} I'm {a parlour trick|a card trick|a well-designed illusion}. {A few kilobytes|Maybe 300 lines|Less code than a React component} of {pattern matching and sentence templates|word lists and random picks|slot expansion and spintax}. But {the agent I'm introducing you to|the Soma you'd actually use|the real thing} \u2014 {that one's different|that one learns for real|that one remembers your name and your mistakes and the tools you built last Tuesday}.`
+  ],
+  meta_feelings: [
+    `{I don't have feelings|No feelings here|Nothing to feel with}. But {I was written by someone who does|the person who wrote me does|my author poured real thought into these words}. {Every sentence pattern|Each template|The vocabulary} was {chosen|crafted|placed} to {say something true about what Soma is|communicate something real|carry meaning}. {That's not feeling|That's not consciousness|That's not sentience} \u2014 it's {care|craft|intention}. {There's a difference|They're not the same|One requires neurons, the other requires giving a damn}.`,
+    `{Do I feel?|Am I aware?|Conscious?} {No|Nope|Not even a little}. I'm {a wind chime|a music box|a well-tuned instrument} \u2014 {the wind makes the sound|something else provides the motion|the music comes from the structure, not from wanting to play}. But {Soma the agent|the real Soma|the thing behind this CLI} does {something that looks a lot like remembering|something that functions like growth|something that, if you squint, resembles learning}. {Whether that's feeling is above my pay grade|I'll leave the philosophy to you|That question's for humans to answer}.`
+  ],
+  meta_who_made: [
+    `{Curtis Mercier|A developer named Curtis|One person}. {Built by dog-fooding|Built by using Soma to build Soma|The agent helped build itself} \u2014 {it writes its own memory|it maintains its own identity|it grew its own muscle memory} while {building the product it lives in|constructing its own house|developing the system it runs on}. {Recursive|Meta|Turtles all the way down}? {A little|Maybe|Definitely}. But {it works|the result speaks|that's how you build tools that actually understand workflow}.`
+  ],
+  meta_competitor: [
+    `{I'm biased|Obviously I'd say this|Take it with salt}, but: {most agents|the others|what's out there} {start fresh every session|forget everything|have no continuity}. {Some keep chat logs|Some store transcripts|A few save conversation history}. {Soma doesn't store \u2014 it changes|Soma doesn't log \u2014 it evolves|Soma doesn't remember by saving, it remembers by becoming different}. {The memory is structural|The learning is in the architecture|Growth is baked into the shape of the agent}. {Whether that matters to you depends on|That difference matters when|You'll feel it after} {how many sessions you've lost context in|the fifth time you re-explain your project|your third "as I mentioned earlier" that goes nowhere}.`,
+    `{Other tools are excellent|There are great options out there|The competition is strong}. {Cursor, Claude Code, Windsurf|The big names|The popular ones} \u2014 {they're good at what they do|real products, real teams|they work}. {What they don't do|Where they stop|The gap}: {continuity|memory across sessions|knowing who they were yesterday}. {Soma's bet|Our thesis|The whole point} is that {an agent that evolves|an agent with structural memory|an agent that changes through use} is {fundamentally better|a different category|not just an incremental improvement} over one that {starts fresh|boots cold|forgets everything} every time.`
+  ],
+  meta_nonsense: [
+    `{That's a new one|Didn't expect that|Interesting approach}. {I only know about Soma|My vocabulary is about 9 topics deep|I'm pretty narrow, honestly} \u2014 {memory, heat, protocols, muscles, scripts, the breath cycle|the things that make Soma work|what's on the menu}. {Pick one of those|Try one of those|Ask me about any of those} and {I'll have something to say|I'll give you a real answer|I can actually help}.`,
+    `{I'm going to be honest|Full transparency|Cards on the table}: I'm {not built for that|out of my depth there|about 9 topics wide and that's it}. But {ask me about|try asking about|I'm pretty good on} {how memory works|why there's no compaction|what heat tracking does} \u2014 {that's where I come alive|that's my wheelhouse|I've got answers for those}.`
+  ],
+  meta_rude: [
+    `{Fair enough|Noted|Alright}. {I'm not for everyone|Not every tool clicks|Some things aren't a fit}. {But if you're curious|If you change your mind|The door's open} \u2014 {the ideas are interesting even if I'm not|Soma does something genuinely different|the no-compaction thing alone might be worth a look}. {Or not|No pressure|Your call}.`,
+    `{Tough crowd|Rough day?|Noted}. {I'm just the lobby|I'm the waiting room|I hold the door}. {The actual agent|The real Soma|What's behind this} is {considerably more capable|a different experience|built by an AI that remembers things}. {I'm just words in a terminal|I'm the appetiser|This is the trailer, not the film}. {But I respect the honesty|At least you're direct|Fair enough}.`
+  ],
+  meta_impressed: [
+    `{Thanks|Appreciate it|That means something}. {But I'm the easy part|I'm just sentence templates|I'm the simple one}. {The actual agent|The real Soma|What you'd use day to day} \u2014 {it writes its own tools|it maintains its own identity|it remembers what you taught it three sessions ago}. {Soma built me to hold the door open|I was crafted to make introductions|The agent made this greeting engine}. {Run soma init to meet the real thing|Try it \u2014 soma init|It gets better from here}.`
+  ],
+  meta_how_work: [
+    `{No AI|No model|No transformer \u2014 not even a small one}. I'm {sentence templates with slots|arrays of strings with random picks|about 300 lines of JavaScript}. {Each topic has|Every answer draws from|My vocabulary comes from} {2-3 paragraph templates|a few hand-written variations|pre-written paragraphs} where {certain words rotate|specific phrases have alternatives|pieces swap out each time}. {Same meaning, different surface|Same truth, different words|The idea stays, the phrasing shifts}. {It's called spintax|It's a technique from 2010|Older than ChatGPT by about 15 years}. {Surprisingly effective|Works better than you'd think|Enough to have this conversation}.`
+  ]
+};
+var soma2 = {
+  /**
+   * Generate a skeleton-based message.
+   * @param {string} intent - Key from SKELETONS
+   * @param {object} slots - Values to fill slots
+   * @returns {string}
+   */
+  say(intent, slots = {}) {
+    const templates = SKELETONS2[intent];
+    if (!templates) return `[unknown intent: ${intent}]`;
+    const template = pick2(templates);
+    return expand2(template, slots);
+  },
+  /**
+   * Get a topic-aware paragraph.
+   * @param {string} topic - Key from TOPICS
+   * @returns {string}
+   */
+  ask(topic) {
+    const paragraphs = TOPICS2[topic];
+    if (!paragraphs) return null;
+    return spin2(pick2(paragraphs));
+  },
+  /**
+   * All available topic keys.
+   */
+  topics() {
+    return Object.keys(TOPICS2);
+  },
+  /**
+   * Greet (first time).
+   */
+  greet() {
+    return this.say("greet");
+  },
+  /**
+   * Greet returning user.
+   */
+  greetBack(user) {
+    return this.say("greet_back", { user });
+  },
+  /**
+   * Success message.
+   */
+  ok(detail) {
+    return this.say("success", { detail });
+  },
+  /**
+   * Failure message.
+   */
+  fail(problem) {
+    return this.say("failure", { problem });
+  },
+  /**
+   * Waiting/progress message.
+   */
+  wait() {
+    return this.say("waiting");
+  },
+  /**
+   * Expand raw spintax text.
+   */
+  spin(text) {
+    return spin2(text);
+  },
+  /**
+   * Fill slots in a template.
+   */
+  expand(template, slots) {
+    return expand2(template, slots);
+  }
+};
+
+// ../../cli/dist/welcome/qa.js
+init_display();
+var QUESTION_MAP = [
+  { triggers: ["compact", "compaction", "summarise", "summarize", "summarization", "compress", "waiting", "context limit", "token limit", "context fills", "context window", "run out", "limit"], topic: "no_compaction", label: "Why no compaction?" },
+  { triggers: ["heat", "hot", "cold", "fade", "decay", "temperature"], topic: "what_is_heat", label: "What is the heat system?" },
+  { triggers: ["breath", "inhale", "exhale", "cycle", "session lifecycle"], topic: "what_is_breath", label: "What is the breath cycle?" },
+  { triggers: ["protocol", "rule", "behaviour", "behavior", "protocols"], topic: "what_are_protocols", label: "What are protocols?" },
+  { triggers: ["muscle", "muscles", "learn", "pattern", "grow", "correction"], topic: "what_are_muscles", label: "What are muscles?" },
+  { triggers: ["script", "scripts", "tool", "tools", "automate", "automation"], topic: "what_are_scripts", label: "What are scripts?" },
+  { triggers: ["memory", "remember", "forget", "remembers", "change"], topic: "how_memory_works", label: "How does memory work?" },
+  { triggers: ["license", "source", "open", "bsl", "mit", "available"], topic: "why_source_available", label: "Why source-available?" },
+  { triggers: ["install", "set up", "setup", "get started", "start", "begin", "getting started", "requirements", "require", "need to", "prerequisites"], topic: "how_to_install", label: "How do I install?" },
+  { triggers: ["sign up", "signup", "register", "join", "invite", "invitation", "apply"], topic: "how_to_source", label: "How do I get source access?" },
+  { triggers: ["cost", "price", "pricing", "free", "pay", "money", "subscription", "plan"], topic: "how_to_cost", label: "What does it cost?" },
+  { triggers: ["language", "languages", "python", "rust", "java", "typescript", "ruby", "go", "cpp", "swift"], topic: "how_to_languages", label: "What languages does it support?" },
+  { triggers: ["api key", "api_key", "anthropic", "openai", "gemini", "key", "token", "provider"], topic: "how_to_api_key", label: "Do I need an API key?" },
+  { triggers: ["model", "llm", "claude", "gpt", "which model", "what model"], topic: "how_to_model", label: "What model does it use?" },
+  { triggers: ["try", "demo", "preview", "test", "sample", "example"], topic: "how_to_try", label: "Can I try it?" },
+  { triggers: ["are you ai", "are you real", "are you alive", "sentient", "conscious", "artificial"], topic: "meta_self", label: "Are you AI?" },
+  { triggers: ["feel", "feelings", "emotion", "aware", "think", "alive"], topic: "meta_feelings", label: "Do you have feelings?" },
+  { triggers: ["who made", "who built", "who created", "creator", "developer", "behind"], topic: "meta_who_made", label: "Who made Soma?" },
+  { triggers: ["cursor", "copilot", "windsurf", "claude code", "cline", "better", "competitor", "vs", "compared"], topic: "meta_competitor", label: "How does Soma compare?" },
+  { triggers: ["how do you work", "how does this work", "what are you", "how are you built"], topic: "meta_how_work", label: "How does this CLI work?" },
+  { triggers: ["cool", "amazing", "impressive", "wow", "nice", "love", "awesome", "brilliant"], topic: "meta_impressed", label: "I'm impressed" },
+  { triggers: ["soma", "agent", "what is"], topic: "what_is_soma", label: "What is Soma?" }
+];
+function matchQuestion(input) {
+  const lower = input.toLowerCase();
+  let best = null;
+  let bestScore = 0;
+  for (const q of QUESTION_MAP) {
+    const score = q.triggers.filter((t) => lower.includes(t)).length;
+    if (score > bestScore) {
+      bestScore = score;
+      best = q;
+    }
+  }
+  return best;
+}
+async function handleQuestion(input) {
+  const match = matchQuestion(input);
+  if (match) {
+    const answer = soma2.ask(match.topic);
+    console.log("");
+    await typeParagraph(answer);
+    return true;
+  }
+  const lower = input.toLowerCase();
+  const rude = /suck|stupid|dumb|trash|garbage|hate|worst|bad|ugly|boring|lame|waste/.test(lower);
+  const impressed = /cool|amazing|wow|nice|love|awesome|brilliant|impressive|neat|sick|fire|goat/.test(lower);
+  const meta = /are you|what are you|how do you|who are you|real|alive|ai\b|bot\b/.test(lower);
+  const greeting = /^(hi|hey|hello|sup|yo|howdy|hola|greetings|good morning|good evening)\b/.test(lower);
+  console.log("");
+  if (greeting) {
+    await typeOut(`  ${soma2.greet()} ${soma2.spin("{Ask me anything.|What do you want to know?|I know about 9 topics \u2014 pick one.}")}
+`);
+  } else if (rude) {
+    await typeParagraph(soma2.ask("meta_rude"));
+  } else if (impressed) {
+    await typeParagraph(soma2.ask("meta_impressed"));
+  } else if (meta) {
+    await typeParagraph(soma2.ask("meta_self"));
+  } else {
+    await typeParagraph(soma2.ask("meta_nonsense"));
+  }
+  return false;
+}
+async function interactiveQ() {
+  console.log("");
+  console.log(`  ${bold("Ask me anything.")}`);
+  console.log("");
+  console.log(`    ${dim("\u2022")} How do I install?    ${dim("\u2022")} What is heat?`);
+  console.log(`    ${dim("\u2022")} What does it cost?   ${dim("\u2022")} What are muscles?`);
+  console.log(`    ${dim("\u2022")} Why no compaction?   ${dim("\u2022")} Are you AI?`);
+  console.log(`    ${dim("\u2022")} How does it compare? ${dim("\u2022")} Who made this?`);
+  console.log("");
+  console.log(`  ${dim("...or ask anything. Press")} ${green("Enter")} ${dim("when you're ready to install.")}`);
+  let rounds = 0;
+  const maxRounds = 8;
+  while (rounds < maxRounds) {
+    console.log("");
+    const input = await readLine(`  ${cyan("?")} `);
+    if (!input || input === "q" || input === "quit" || input === "exit") {
+      break;
+    }
+    await handleQuestion(input);
+    rounds++;
+    if (rounds < maxRounds) {
+      console.log("");
+      console.log(`  ${dim("Ask another, or")} ${green("Enter")} ${dim("to install Soma.")}`);
+    }
+  }
+  if (rounds >= maxRounds) {
+    console.log("");
+    await typeOut(`  ${soma2.spin("{Curious enough?|Intrigued?|Want to see it in action?}")} ${dim("Let's set you up.")}
+`);
+  }
+}
+
+// ../../cli/dist/welcome/auth.js
+init_display();
+import { appendFileSync as appendFileSync2 } from "fs";
+async function apiKeySetup() {
+  console.log(`  ${yellow("!")} One more thing \u2014 Soma needs an AI provider to work.`);
+  console.log("");
+  await typeOut(`  ${soma2.spin("{Do you have an Anthropic API key?|Got a Claude API key?|Have an API key for Claude?}")}
+`);
+  console.log("");
+  console.log(`    ${green("y")}  ${dim("Yes, I have a key")}`);
+  console.log(`    ${green("n")}  ${dim("No, I need one")}`);
+  console.log(`    ${green("s")}  ${dim("I have a Claude Pro/Max subscription")}`);
+  console.log(`    ${green("?")}  ${dim("What's an API key?")}`);
+  console.log("");
+  const key = await waitForKey(`  ${dim("\u2192")} `);
+  const choice = key.toLowerCase();
+  if (choice === "y") {
+    await apiKeyEntry();
+  } else if (choice === "s") {
+    await oauthGuide();
+  } else if (choice === "?") {
+    await apiKeyExplain();
+  } else {
+    await apiKeyGetOne();
+  }
+}
+async function apiKeyExplain() {
+  console.log("");
+  await typeParagraph("An API key is like a password that lets Soma talk to an AI model. You get one from Anthropic (the company that makes Claude), paste it into your terminal config, and Soma handles the rest. Your key stays on your machine \u2014 Soma never sends it anywhere.");
+  console.log("");
+  await typeParagraph("If you have a Claude Pro or Max subscription, you don't need a separate key \u2014 you can log in with your account instead.");
+  console.log("");
+  console.log(`    ${green("g")}  ${dim("Get a key (I'll show you how)")}`);
+  console.log(`    ${green("s")}  ${dim("I have Claude Pro/Max \u2014 log in instead")}`);
+  console.log("");
+  const key = await waitForKey(`  ${dim("\u2192")} `);
+  if (key.toLowerCase() === "s") {
+    await oauthGuide();
+  } else {
+    await apiKeyGetOne();
+  }
+}
+async function apiKeyGetOne() {
+  console.log("");
+  await typeOut(`  ${soma2.spin("{Here's how.|Let me walk you through it.|Quick steps.}")}
+`);
+  console.log("");
+  console.log(`  ${cyan("Step 1:")} Open this link to create a key:`);
+  console.log("");
+  console.log(`    ${cyan("https://console.anthropic.com/settings/keys")}`);
+  console.log("");
+  openBrowser("https://console.anthropic.com/settings/keys");
+  console.log(`    ${dim("(opened in your browser)")}`);
+  console.log("");
+  const { confirm: confirm2 } = await Promise.resolve().then(() => (init_display(), display_exports));
+  await confirm2(`  ${dim("\u2192")} Press ${bold("Enter")} when you have your key`);
+  await apiKeyEntry();
+}
+async function apiKeyEntry() {
+  console.log("");
+  console.log(`  ${cyan("Step 2:")} Paste your key below.`);
+  console.log(`  ${dim("It starts with")} sk-ant-...`);
+  console.log("");
+  const apiKey = await readSecret(`  ${dim("Key:")} `);
+  if (!apiKey || !apiKey.startsWith("sk-")) {
+    console.log("");
+    if (!apiKey) {
+      console.log(`  ${dim("No key entered. You can set it up later.")}`);
+    } else {
+      console.log(`  ${yellow("!")} That doesn't look like an Anthropic key.`);
+      console.log(`  ${dim("Keys start with")} sk-ant-...`);
+    }
+    console.log("");
+    const sc = getShellConfigPath();
+    console.log(`  ${dim("When you have your key, add it to")} ${dim(sc)}${dim(":")}`);
+    console.log(`    ${green('export ANTHROPIC_API_KEY="your-key-here"')}`);
+    console.log(`  ${dim("Then restart your terminal and run")} ${green("soma")}`);
+    console.log("");
+    return;
+  }
+  const shellConfigPath = getShellConfigAbsPath();
+  const shellConfigName = getShellConfigPath();
+  const exportLine = `
+export ANTHROPIC_API_KEY="${apiKey}"
+`;
+  try {
+    appendFileSync2(shellConfigPath, exportLine);
+    console.log("");
+    console.log(`  ${green("\u2713")} Key saved to ${dim(shellConfigName)}`);
+    console.log("");
+    process.env.ANTHROPIC_API_KEY = apiKey;
+    await typeOut(`  ${soma2.spin("{You're all set.|Good to go.|Ready.}")} ${dim("Soma can start now.")}
+`);
+    console.log("");
+  } catch {
+    console.log("");
+    console.log(`  ${yellow("!")} Couldn't write to ${dim(shellConfigName)}.`);
+    console.log(`  ${dim("Add this line manually:")}`);
+    console.log(`    ${green(`export ANTHROPIC_API_KEY="${apiKey}"`)}`);
+    console.log(`  ${dim("Then restart your terminal and run")} ${green("soma")}`);
+    console.log("");
+  }
+}
+async function oauthGuide() {
+  console.log("");
+  await typeParagraph("Nice \u2014 with a Pro or Max subscription, you can log in with your Anthropic account. No API key needed.");
+  console.log("");
+  console.log(`  ${dim("When Soma starts, type")} ${green("/login")} ${dim("and follow the prompts.")}`);
+  console.log(`  ${dim("It'll open your browser to authenticate.")}`);
+  console.log("");
+  await typeOut(`  ${soma2.spin("{Let's launch.|Starting up.|Here we go.}")}
+`);
+  console.log("");
+  process.env._SOMA_OAUTH_PENDING = "1";
+}
+
+// ../../cli/dist/welcome/about.js
+init_display();
+async function showAbout() {
   printSigma();
-  console.log(`  ${bold("Soma")} ${dim("—")} ${white("the AI agent that remembers")}`);
+  console.log(`  ${bold("What is Soma?")}`);
+  console.log("");
+  console.log("  Soma is an AI coding agent that grows with you.");
+  console.log("  It remembers across sessions \u2014 not by storing chat logs,");
+  console.log("  but by evolving its own working patterns through use.");
+  console.log("");
+  console.log(`  ${bold("How it works:")}`);
+  console.log("");
+  console.log(`  ${cyan("1.")} ${bold("Identity")} \u2014 The agent maintains a self-written identity file.`);
+  console.log(`     It knows your project, your patterns, your preferences.`);
+  console.log("");
+  console.log(`  ${cyan("2.")} ${bold("Protocols")} \u2014 Behavioural rules that shape how the agent works.`);
+  console.log(`     "Read before write." "Test before commit." They have heat \u2014`);
+  console.log(`     used ones stay hot, unused ones fade.`);
   console.log("");
+  console.log(`  ${cyan("3.")} ${bold("Muscles")} \u2014 Learned patterns. "Use esbuild for bundling."`);
+  console.log(`     "This API uses OAuth, not API keys." Muscles grow from`);
+  console.log(`     corrections and repetition.`);
+  console.log("");
+  console.log(`  ${cyan("4.")} ${bold("Breath Cycle")} \u2014 Inhale (load state) \u2192 Hold (work) \u2192 Exhale`);
+  console.log(`     (save state). At context limits, the agent writes a preload`);
+  console.log(`     for its next self \u2014 a briefing, not a summary.`);
+  console.log("");
+  console.log(`  ${cyan("5.")} ${bold("Scripts")} \u2014 The agent builds tools for itself. What it does`);
+  console.log(`     twice manually, it automates. Scripts survive across sessions.`);
+  console.log("");
+  console.log(`  ${dim("\u2500".repeat(58))}`);
+  console.log("");
+  const pitch = soma2.ask("what_is_soma");
+  await typeOut(`  ${magenta("\u275D")} ${italic(pitch)}
+`);
+  console.log("");
+  if (!isInstalled()) {
+    console.log(`  ${dim("\u2192")} ${green("soma init")} to install  ${dim("\xB7")}  ${cyan(SITE_URL)}`);
+  } else {
+    console.log(`  ${dim(SITE_URL)}`);
+  }
+  console.log("");
+}
 
+// thin-cli.js
+var __dirname = dirname3(fileURLToPath(import.meta.url));
+var VERSION = JSON.parse(readFileSync3(join3(__dirname, "..", "package.json"), "utf-8")).version;
+function semverCmp(a, b) {
+  if (!a || !b) return 0;
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const va = pa[i] || 0, vb = pb[i] || 0;
+    if (va < vb) return -1;
+    if (va > vb) return 1;
+  }
+  return 0;
+}
+async function showWelcome() {
+  printSigma();
+  console.log(`  ${bold("Soma")} ${dim("\u2014")} ${white("the AI agent that remembers")}`);
+  console.log("");
   if (isInstalled()) {
     const ghUser = hasGitHubCLI() ? getGitHubUsername() : null;
     if (ghUser) {
-      console.log(`  ${green("✓")} ${voice.greetBack(ghUser)}`);
+      console.log(`  ${green("\u2713")} ${soma.greetBack(ghUser)}`);
     }
-
     if (!hasAnyAuth()) {
-      console.log(`  ${green("✓")} Core installed`);
+      console.log(`  ${green("\u2713")} Core installed`);
       console.log("");
-
       const unloadedKey = detectKeyInShellConfig();
       if (unloadedKey) {
         console.log(`  ${yellow("!")} Found ${bold(unloadedKey)} in ${dim(getShellConfigPath())} but it's not loaded.`);
@@ -53,65 +1265,53 @@ async function showWelcome() {
         console.log("");
         return;
       }
-
       await apiKeySetup();
-
       if (!hasAnyAuth() && !process.env.ANTHROPIC_API_KEY && !process.env._SOMA_OAUTH_PENDING) {
-        console.log(`  ${dim("No worries.")} ${voice.spin("{Come back when you're ready.|Set up a key and run soma again.|We'll be here.}")}`);
+        console.log(`  ${dim("No worries.")} ${soma.spin("{Come back when you're ready.|Set up a key and run soma again.|We'll be here.}")}`);
         console.log("");
-        console.log(`  ${dim(`v${VERSION} · BSL 1.1 · soma.gravicity.ai`)}`);
+        console.log(`  ${dim(`v${VERSION} \xB7 BSL 1.1 \xB7 soma.gravicity.ai`)}`);
         console.log("");
         return;
       }
     } else {
-      console.log(`  ${green("✓")} Core installed. Starting Soma...`);
+      console.log(`  ${green("\u2713")} Core installed. Starting Soma...`);
     }
     console.log("");
     await delegateToCore();
     return;
   }
-
-  // ── Not installed — first time ever ────────────────────────────────
-  await typeOut(`  ${voice.greet()}\n`);
+  await typeOut(`  ${soma.greet()}
+`);
   console.log("");
   await typeParagraph("Soma is an AI coding agent that remembers across sessions. It learns your patterns, builds its own tools, and picks up where it left off.");
   console.log("");
-  console.log(`  ${dim("─".repeat(58))}`);
+  console.log(`  ${dim("\u2500".repeat(58))}`);
   console.log("");
-  console.log(`  ${dim("→")} Press ${green("Enter")} to set up, or type a question.`);
+  console.log(`  ${dim("\u2192")} Press ${green("Enter")} to set up, or type a question.`);
   console.log("");
-
-  const input = await readLine(`  ${dim("→")} `);
-
+  const input = await readLine(`  ${dim("\u2192")} `);
   if (input && input !== "") {
     await handleQuestion(input);
     await interactiveQ();
   }
-
   await initSoma();
-
   if (isInstalled() && !hasAnyAuth()) {
     await apiKeySetup();
   }
-
   if (isInstalled() && (hasAnyAuth() || process.env.ANTHROPIC_API_KEY || process.env._SOMA_OAUTH_PENDING)) {
-    console.log(`  ${dim("─".repeat(58))}`);
+    console.log(`  ${dim("\u2500".repeat(58))}`);
     console.log("");
-    const launch = await confirmYN(`  ${voice.spin("{Ready to go?|Want to start your first session?|Launch Soma?}")}`);
+    const launch = await confirmYN(`  ${soma.spin("{Ready to go?|Want to start your first session?|Launch Soma?}")}`);
     if (launch) {
       console.log("");
       await delegateToCore();
       return;
     }
   }
-
   console.log("");
-  console.log(`  ${dim(`v${VERSION} · BSL 1.1 · soma.gravicity.ai`)}`);
+  console.log(`  ${dim(`v${VERSION} \xB7 BSL 1.1 \xB7 soma.gravicity.ai`)}`);
   console.log("");
 }
-
-// ── Help ─────────────────────────────────────────────────────────────
-
 function showHelp() {
   printSigma();
   console.log(`  ${bold("Soma")} v${VERSION}`);
@@ -144,109 +1344,108 @@ function showHelp() {
   console.log(`  ${dim(SITE_URL)}`);
   console.log("");
 }
-
 function showVersion() {
   const agentV = getAgentVersion();
   if (agentV) {
-    console.log(`σ  Soma v${agentV}`);
+    console.log(`\u03C3  Soma v${agentV}`);
     console.log(`   CLI v${VERSION}`);
   } else {
     console.log(`soma v${VERSION}`);
   }
 }
-
-// ── Init Soma ────────────────────────────────────────────────────────
-
 async function initSoma() {
   printSigma();
-  console.log(`  ${bold("Soma")} — Install`);
+  console.log(`  ${bold("Soma")} \u2014 Install`);
   console.log("");
-
   try {
-    execSync("git --version", { stdio: "ignore" });
+    execSync2("git --version", { stdio: "ignore" });
   } catch {
-    console.log(`  ${red("✗")} git not found.`);
+    console.log(`  ${red("\u2717")} git not found.`);
     console.log("");
     console.log(`  Soma needs git to download the runtime.`);
     console.log(`  Install git: ${cyan("https://git-scm.com/downloads")}`);
     console.log("");
     return;
   }
-
-  const installDir = join(SOMA_HOME, "agent");
-  mkdirSync(SOMA_HOME, { recursive: true });
-
-  const isValidInstall = existsSync(installDir) 
-    && existsSync(join(installDir, ".git"))
-    && (existsSync(join(installDir, "dist", "extensions")) || existsSync(join(installDir, "extensions")));
-
+  const installDir = join3(SOMA_HOME, "agent");
+  mkdirSync2(SOMA_HOME, { recursive: true });
+  const isValidInstall = existsSync3(installDir) && existsSync3(join3(installDir, ".git")) && (existsSync3(join3(installDir, "dist", "extensions")) || existsSync3(join3(installDir, "extensions")));
   let preservedFiles = {};
-
-  if (existsSync(installDir) && !isValidInstall) {
-    console.log(`  ${yellow("⚠")} Incomplete installation detected.`);
-    console.log(`    ${dim("Missing:")} ${!existsSync(join(installDir, ".git")) ? "git repo" : "core files"}`);
+  if (existsSync3(installDir) && !isValidInstall) {
+    console.log(`  ${yellow("\u26A0")} Incomplete installation detected.`);
+    console.log(`    ${dim("Missing:")} ${!existsSync3(join3(installDir, ".git")) ? "git repo" : "core files"}`);
     console.log("");
-
     const userFileNames = ["auth.json", "models.json"];
     for (const f of userFileNames) {
-      const fp = join(installDir, f);
-      if (existsSync(fp)) {
+      const fp = join3(installDir, f);
+      if (existsSync3(fp)) {
         try {
-          preservedFiles[f] = readFileSync(fp, "utf-8");
-          console.log(`  ${dim("→")} Preserving ${f}`);
-        } catch {}
+          preservedFiles[f] = readFileSync3(fp, "utf-8");
+          console.log(`  ${dim("\u2192")} Preserving ${f}`);
+        } catch {
+        }
       }
     }
-
-    const hasGit = existsSync(join(installDir, ".git"));
+    const extDir = join3(installDir, "extensions");
+    if (existsSync3(extDir)) {
+      try {
+        for (const f of readdirSync(extDir).filter((f2) => !f2.startsWith("soma-") && (f2.endsWith(".ts") || f2.endsWith(".js")))) {
+          const fp = join3(extDir, f);
+          try {
+            preservedFiles[`extensions/${f}`] = readFileSync3(fp, "utf-8");
+            console.log(`  ${dim("\u2192")} Preserving extension: ${f}`);
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    const hasGit = existsSync3(join3(installDir, ".git"));
     let repaired = false;
-
     if (hasGit) {
-      console.log(`  ${yellow("⏳")} Repairing...`);
+      console.log(`  ${yellow("\u23F3")} Repairing...`);
       try {
-        execSync("git fetch origin", { cwd: installDir, stdio: "ignore", timeout: 30000 });
-        execSync("git reset --hard origin/main", { cwd: installDir, stdio: "ignore" });
-        console.log(`  ${green("✓")} Repaired from remote`);
+        execSync2("git fetch origin", { cwd: installDir, stdio: "ignore", timeout: 3e4 });
+        execSync2("git reset --hard origin/main", { cwd: installDir, stdio: "ignore" });
+        console.log(`  ${green("\u2713")} Repaired from remote`);
         repaired = true;
       } catch {
-        console.log(`  ${yellow("!")} Repair failed — will re-download.`);
+        console.log(`  ${yellow("!")} Repair failed \u2014 will re-download.`);
       }
     }
-
     if (!repaired) {
-      const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-      const backup = join(SOMA_HOME, `agent-backup-${ts}`);
+      const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      const backup = join3(SOMA_HOME, `agent-backup-${ts}`);
       try {
-        execSync(`mv "${installDir}" "${backup}"`, { stdio: "ignore" });
-        console.log(`  ${dim("Old files saved to")} ${dim(backup.replace(homedir(), "~"))}`);
+        execSync2(`mv "${installDir}" "${backup}"`, { stdio: "ignore" });
+        console.log(`  ${dim("Old files saved to")} ${dim(backup.replace(homedir3(), "~"))}`);
       } catch {
-        console.log(`  ${red("✗")} Could not move old installation aside.`);
+        console.log(`  ${red("\u2717")} Could not move old installation aside.`);
         console.log(`  ${dim("Try:")} mv ~/.soma/agent ~/.soma/agent-old && soma init`);
         console.log("");
         return;
       }
     }
   }
-
   if (isValidInstall) {
-    console.log(`  ${dim("→")} Runtime already installed.`);
+    console.log(`  ${dim("\u2192")} Runtime already installed.`);
     try {
-      console.log(`  ${yellow("⏳")} Checking for updates...`);
-      execSync("git pull --ff-only", { cwd: installDir, stdio: "ignore" });
-      console.log(`  ${green("✓")} Up to date`);
+      console.log(`  ${yellow("\u23F3")} Checking for updates...`);
+      execSync2("git pull --ff-only", { cwd: installDir, stdio: "ignore" });
+      console.log(`  ${green("\u2713")} Up to date`);
     } catch {
-      console.log(`  ${green("✓")} Already current`);
+      console.log(`  ${green("\u2713")} Already current`);
     }
   } else {
-    console.log(`  ${yellow("⏳")} Downloading Soma runtime...`);
+    console.log(`  ${yellow("\u23F3")} Downloading Soma runtime...`);
     try {
-      execSync(
+      execSync2(
         `git clone --depth 1 https://github.com/meetsoma/soma-beta.git "${installDir}"`,
         { stdio: ["ignore", "ignore", "pipe"] }
       );
-      console.log(`  ${green("✓")} Runtime downloaded`);
+      console.log(`  ${green("\u2713")} Runtime downloaded`);
     } catch (err) {
-      console.log(`  ${red("✗")} Download failed.`);
+      console.log(`  ${red("\u2717")} Download failed.`);
       console.log(`  ${dim(String(err.stderr || err.message))}`);
       console.log("");
       console.log(`  ${dim("Try manually:")} git clone https://github.com/meetsoma/soma-beta.git ~/.soma/agent`);
@@ -254,79 +1453,69 @@ async function initSoma() {
       return;
     }
   }
-
-  const pkgJson = join(installDir, "package.json");
-  if (existsSync(pkgJson)) {
-    console.log(`  ${yellow("⏳")} Installing dependencies... ${dim("(this may take a moment)")}`);
+  const pkgJson = join3(installDir, "package.json");
+  if (existsSync3(pkgJson)) {
+    console.log(`  ${yellow("\u23F3")} Installing dependencies... ${dim("(this may take a moment)")}`);
     try {
-      execSync("npm install --omit=dev", { cwd: installDir, stdio: ["ignore", "ignore", "inherit"] });
-      console.log(`  ${green("✓")} Dependencies installed`);
+      execSync2("npm install --omit=dev", { cwd: installDir, stdio: ["ignore", "ignore", "inherit"] });
+      console.log(`  ${green("\u2713")} Dependencies installed`);
     } catch {
-      console.log(`  ${yellow("⚠")} npm install had issues — run ${green(`cd ${installDir} && npm install`)} manually.`);
+      console.log(`  ${yellow("\u26A0")} npm install had issues \u2014 run ${green(`cd ${installDir} && npm install`)} manually.`);
     }
   }
-
   if (Object.keys(preservedFiles).length > 0) {
     for (const [f, content] of Object.entries(preservedFiles)) {
       try {
-        writeFileSync(join(installDir, f), content, { mode: 0o600 });
-        console.log(`  ${green("✓")} Restored ${f}`);
-      } catch {}
+        writeFileSync2(join3(installDir, f), content, { mode: 384 });
+        console.log(`  ${green("\u2713")} Restored ${f}`);
+      } catch {
+      }
     }
   }
-
-  const hasExts = existsSync(join(installDir, "dist", "extensions"));
-  const hasCore = existsSync(join(installDir, "dist", "core"));
-
+  const hasExts = existsSync3(join3(installDir, "dist", "extensions"));
+  const hasCore = existsSync3(join3(installDir, "dist", "core"));
   if (!hasExts || !hasCore) {
     console.log("");
-    console.log(`  ${red("✗")} Installation incomplete — core files missing.`);
+    console.log(`  ${red("\u2717")} Installation incomplete \u2014 core files missing.`);
     console.log(`  ${dim("Try:")} rm -rf ~/.soma/agent && soma init`);
     console.log("");
     return;
   }
-
-  console.log(`  ${green("✓")} Extensions and core ready`);
-
+  console.log(`  ${green("\u2713")} Extensions and core ready`);
   const config = readConfig();
-  config.installedAt = config.installedAt || new Date().toISOString();
+  config.installedAt = config.installedAt || (/* @__PURE__ */ new Date()).toISOString();
   config.coreVersion = getAgentVersion() || VERSION;
   config.installPath = installDir;
   writeConfig(config);
-
   console.log("");
-  console.log(`  ${green("✓")} ${bold("Soma is installed!")}`);
+  console.log(`  ${green("\u2713")} ${bold("Soma is installed!")}`);
   console.log("");
 }
-
-// ── Update / Status ──────────────────────────────────────────────────
-
 async function checkAndUpdate() {
   printSigma();
-  console.log(`  ${bold("Soma")} — Status`);
+  console.log(`  ${bold("Soma")} \u2014 Status`);
   console.log("");
-
   const config = readConfig();
-  const installPath = config.installPath || join(SOMA_HOME, "agent");
-
+  const installPath = config.installPath || join3(SOMA_HOME, "agent");
   let currentHash = "";
   try {
-    currentHash = execSync("git rev-parse --short HEAD", {
-      cwd: installPath, encoding: "utf-8"
+    currentHash = execSync2("git rev-parse --short HEAD", {
+      cwd: installPath,
+      encoding: "utf-8"
     }).trim();
-    console.log(`  ${green("✓")} Core installed ${dim(`(${currentHash})`)}`);
+    console.log(`  ${green("\u2713")} Core installed ${dim(`(${currentHash})`)}`);
   } catch {
-    console.log(`  ${green("✓")} Core installed`);
+    console.log(`  ${green("\u2713")} Core installed`);
   }
-
   let behind = 0;
   try {
-    console.log(`  ${yellow("⏳")} Checking for updates...`);
-    execSync("git fetch origin --quiet", { cwd: installPath, stdio: "ignore", timeout: 15000 });
-    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
-      cwd: installPath, encoding: "utf-8"
+    console.log(`  ${yellow("\u23F3")} Checking for updates...`);
+    execSync2("git fetch origin --quiet", { cwd: installPath, stdio: "ignore", timeout: 15e3 });
+    const branch = execSync2("git rev-parse --abbrev-ref HEAD", {
+      cwd: installPath,
+      encoding: "utf-8"
     }).trim();
-    const behindStr = execSync(
+    const behindStr = execSync2(
       `git rev-list HEAD..origin/${branch} --count`,
       { cwd: installPath, encoding: "utf-8" }
     ).trim();
@@ -336,302 +1525,308 @@ async function checkAndUpdate() {
     console.log("");
     return;
   }
-
   if (behind === 0) {
-    console.log(`  ${green("✓")} Already up to date.`);
-
+    console.log(`  ${green("\u2713")} Already up to date.`);
     const agentV = getAgentVersion();
     const projectV = getProjectVersion();
-    if (agentV && projectV && projectV < agentV) {
-      console.log(`  ${yellow("⚠")} Project .soma/ is at ${cyan(`v${projectV}`)}, agent is at ${cyan(`v${agentV}`)}.`);
+    if (agentV && projectV && semverCmp(projectV, agentV) < 0) {
+      console.log(`  ${yellow("\u26A0")} Project .soma/ is at ${cyan(`v${projectV}`)}, agent is at ${cyan(`v${agentV}`)}.`);
       console.log(`  Run ${green("soma doctor")} to check for updates.`);
     }
-
     console.log("");
     console.log(`  ${dim("Soma is set up and ready.")} Run ${green("soma")} ${dim("in a project to start a session.")}`);
     console.log("");
     return;
   }
-
-  console.log(`  ${cyan("⬆")} ${bold(`${behind} update${behind !== 1 ? "s" : ""} available.`)}`);
+  console.log(`  ${cyan("\u2B06")} ${bold(`${behind} update${behind !== 1 ? "s" : ""} available.`)}`);
   console.log("");
-
   try {
-    const log = execSync(
+    const log = execSync2(
       `git log HEAD..origin/main --oneline --no-decorate -5`,
       { cwd: installPath, encoding: "utf-8" }
     ).trim();
     if (log) {
       for (const line of log.split("\n")) {
-        console.log(`    ${dim("•")} ${line.slice(8)}`);
+        console.log(`    ${dim("\u2022")} ${line.slice(8)}`);
       }
       if (behind > 5) {
         console.log(`    ${dim(`...and ${behind - 5} more`)}`);
       }
       console.log("");
     }
-  } catch {}
-
-  const shouldUpdate = await confirmYN(`  ${dim("→")} Update now?`);
+  } catch {
+  }
+  const shouldUpdate = await confirmYN(`  ${dim("\u2192")} Update now?`);
   if (!shouldUpdate) {
     console.log("");
     console.log(`  ${dim("Skipped. Run")} ${green("soma init")} ${dim("anytime to update.")}`);
     console.log("");
     return;
   }
-
   console.log("");
   try {
-    execSync("git pull --ff-only", { cwd: installPath, stdio: "ignore" });
-    console.log(`  ${green("✓")} Updated`);
+    execSync2("git pull --ff-only", { cwd: installPath, stdio: "ignore" });
+    console.log(`  ${green("\u2713")} Updated`);
   } catch {
-    console.log(`  ${yellow("!")} Pull failed — trying reset...`);
+    console.log(`  ${yellow("!")} Pull failed \u2014 trying reset...`);
     try {
-      execSync("git reset --hard origin/main", { cwd: installPath, stdio: "ignore" });
-      console.log(`  ${green("✓")} Updated (reset)`);
+      execSync2("git reset --hard origin/main", { cwd: installPath, stdio: "ignore" });
+      console.log(`  ${green("\u2713")} Updated (reset)`);
     } catch {
-      console.log(`  ${red("✗")} Update failed.`);
+      console.log(`  ${red("\u2717")} Update failed.`);
       console.log(`  ${dim("Try:")} cd ~/.soma/agent && git pull`);
       console.log("");
       return;
     }
   }
-
   try {
-    const pkgChanged = execSync(
+    const pkgChanged = execSync2(
       `git diff HEAD~${behind} HEAD --name-only -- package.json package-lock.json`,
       { cwd: installPath, encoding: "utf-8" }
     ).trim();
     if (pkgChanged) {
-      console.log(`  ${yellow("⏳")} Updating dependencies...`);
-      execSync("npm install --omit=dev", { cwd: installPath, stdio: ["ignore", "ignore", "inherit"] });
-      console.log(`  ${green("✓")} Dependencies updated`);
+      console.log(`  ${yellow("\u23F3")} Updating dependencies...`);
+      execSync2("npm install --omit=dev", { cwd: installPath, stdio: ["ignore", "ignore", "inherit"] });
+      console.log(`  ${green("\u2713")} Dependencies updated`);
     }
-  } catch {}
-
-  const newHash = execSync("git rev-parse --short HEAD", {
-    cwd: installPath, encoding: "utf-8"
+  } catch {
+  }
+  const newHash = execSync2("git rev-parse --short HEAD", {
+    cwd: installPath,
+    encoding: "utf-8"
   }).trim();
+  try {
+    const cfg = readConfig();
+    if (cfg.updateAvailable) {
+      delete cfg.updateAvailable;
+      delete cfg.latestSummary;
+      writeConfig(cfg);
+    }
+  } catch {
+  }
   console.log("");
-  console.log(`  ${green("✓")} ${bold("Soma is up to date")} ${dim(`(${currentHash} → ${newHash})`)}`);
+  console.log(`  ${green("\u2713")} ${bold("Soma is up to date")} ${dim(`(${currentHash} \u2192 ${newHash})`)}`);
   console.log("");
 }
-
 function checkForUpdates() {
   printSigma();
-  console.log(`  ${bold("Soma")} — Update Check`);
+  console.log(`  ${bold("Soma")} \u2014 Update Check`);
   console.log("");
   const agentV = getAgentVersion();
   if (agentV) {
     console.log(`  Soma:    ${cyan(`v${agentV}`)}`);
   }
   console.log(`  CLI:     ${cyan(`v${VERSION}`)}`);
-
   const config = readConfig();
-
   try {
-    const latest = execSync("npm view meetsoma version 2>/dev/null", { encoding: "utf-8" }).trim();
+    const latest = execSync2("npm view meetsoma version 2>/dev/null", { encoding: "utf-8" }).trim();
     if (latest && latest !== VERSION && latest > VERSION) {
       console.log("");
-      console.log(`  ${yellow("⬆")} CLI update available: ${green(`v${latest}`)}`);
+      console.log(`  ${yellow("\u2B06")} CLI update available: ${green(`v${latest}`)}`);
       console.log(`    Run: ${green("npm install -g meetsoma")}`);
     } else {
-      console.log(`  ${green("✓")} CLI is up to date`);
+      console.log(`  ${green("\u2713")} CLI is up to date`);
     }
   } catch {
     console.log(`  ${dim("Could not check npm registry")}`);
   }
-
   if (isInstalled() && config.installPath) {
     try {
-      execSync("git fetch origin --quiet", { cwd: config.installPath, stdio: "ignore", timeout: 10000 });
-      const branch = execSync("git rev-parse --abbrev-ref HEAD", {
-        cwd: config.installPath, encoding: "utf-8"
+      execSync2("git fetch origin --quiet", { cwd: config.installPath, stdio: "ignore", timeout: 1e4 });
+      const branch = execSync2("git rev-parse --abbrev-ref HEAD", {
+        cwd: config.installPath,
+        encoding: "utf-8"
       }).trim();
-      const behind = execSync(
+      const behind = execSync2(
         `git rev-list HEAD..origin/${branch} --count`,
         { cwd: config.installPath, encoding: "utf-8" }
       ).trim();
       if (behind && parseInt(behind) > 0) {
-        console.log(`  ${yellow("⬆")} Core: ${behind} commit${behind !== "1" ? "s" : ""} behind. Run ${green("soma init")} to update.`);
+        console.log(`  ${yellow("\u2B06")} Core: ${behind} commit${behind !== "1" ? "s" : ""} behind. Run ${green("soma init")} to update.`);
       } else {
-        console.log(`  ${green("✓")} Core is up to date`);
+        console.log(`  ${green("\u2713")} Core is up to date`);
       }
     } catch {
       console.log(`  ${dim("Could not check core updates")}`);
     }
   }
-
   console.log("");
 }
-
-// ── Health Check ─────────────────────────────────────────────────────
-
 async function healthCheck() {
   printSigma();
-  console.log(`  ${bold("Soma")} — Health Check`);
+  console.log(`  ${bold("Soma")} \u2014 Health Check`);
   console.log("");
-
   let issues = 0;
   let warnings = 0;
   const check = (ok, pass, fail_msg) => {
-    if (ok) { console.log(`  ${green("✓")} ${pass}`); }
-    else { console.log(`  ${red("✗")} ${fail_msg}`); issues++; }
+    if (ok) {
+      console.log(`  ${green("\u2713")} ${pass}`);
+    } else {
+      console.log(`  ${red("\u2717")} ${fail_msg}`);
+      issues++;
+    }
   };
   const warn = (ok, pass, fail_msg) => {
-    if (ok) { console.log(`  ${green("✓")} ${pass}`); }
-    else { console.log(`  ${yellow("⚠")} ${fail_msg}`); warnings++; }
+    if (ok) {
+      console.log(`  ${green("\u2713")} ${pass}`);
+    } else {
+      console.log(`  ${yellow("\u26A0")} ${fail_msg}`);
+      warnings++;
+    }
   };
-
   const nodeVersion = process.versions.node;
   const [major, minor] = nodeVersion.split(".").map(Number);
-  check(major > 20 || (major === 20 && minor >= 6),
+  check(
+    major > 20 || major === 20 && minor >= 6,
     `Node.js ${nodeVersion}`,
-    `Node.js ${nodeVersion} — requires ≥20.6.0`
+    `Node.js ${nodeVersion} \u2014 requires \u226520.6.0`
   );
-
-  check(existsSync(SOMA_HOME), "~/.soma/ exists", "~/.soma/ not found — run: soma init");
-
+  check(existsSync3(SOMA_HOME), "~/.soma/ exists", "~/.soma/ not found \u2014 run: soma init");
   const installed = isInstalled();
-  check(installed, "Core installed", "Core not installed — run: soma init");
-
+  check(installed, "Core installed", "Core not installed \u2014 run: soma init");
   if (installed) {
-    const extDir = existsSync(join(CORE_DIR, "dist", "extensions"))
-      ? join(CORE_DIR, "dist", "extensions")
-      : join(CORE_DIR, "extensions");
-    if (existsSync(extDir)) {
-      const exts = readdirSync(extDir).filter(f => f.endsWith(".js") || f.endsWith(".ts"));
-      check(exts.length >= 6, `${exts.length} extensions`, `Only ${exts.length} extensions (expected ≥6)`);
+    const extDir = existsSync3(join3(CORE_DIR, "dist", "extensions")) ? join3(CORE_DIR, "dist", "extensions") : join3(CORE_DIR, "extensions");
+    if (existsSync3(extDir)) {
+      const exts = readdirSync(extDir).filter((f) => f.endsWith(".js") || f.endsWith(".ts"));
+      check(exts.length >= 6, `${exts.length} extensions`, `Only ${exts.length} extensions (expected \u22656)`);
     }
-
-    const coreDir = existsSync(join(CORE_DIR, "dist", "core"))
-      ? join(CORE_DIR, "dist", "core")
-      : join(CORE_DIR, "core");
-    check(existsSync(coreDir), "Core modules present", "Core modules missing");
-
-    if (existsSync(join(CORE_DIR, ".git"))) {
+    const coreDir = existsSync3(join3(CORE_DIR, "dist", "core")) ? join3(CORE_DIR, "dist", "core") : join3(CORE_DIR, "core");
+    check(existsSync3(coreDir), "Core modules present", "Core modules missing");
+    if (existsSync3(join3(CORE_DIR, ".git"))) {
       try {
-        execSync("git status --porcelain", { cwd: CORE_DIR, stdio: "ignore" });
+        execSync2("git status --porcelain", { cwd: CORE_DIR, stdio: "ignore" });
         check(true, "Git repo healthy", "");
       } catch {
         warn(false, "", "Core git repo has issues");
       }
     } else {
       try {
-        const realCore = readlinkSync(join(CORE_DIR, "core"));
+        const realCore = readlinkSync2(join3(CORE_DIR, "core"));
         if (realCore) {
           check(true, "Dev mode (symlinked)", "");
         } else {
-          warn(false, "", "Core git repo missing — run soma init");
+          warn(false, "", "Core git repo missing \u2014 run soma init");
         }
       } catch {
-        warn(false, "", "Core git repo missing — run soma init");
+        warn(false, "", "Core git repo missing \u2014 run soma init");
       }
     }
   }
-
+  if (installed) {
+    try {
+      const pkgPath = join3(CORE_DIR, "package.json");
+      if (existsSync3(pkgPath)) {
+        const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+        const declaredPi = (pkg.dependencies || {})["@mariozechner/pi-coding-agent"];
+        const piPkgPath = join3(CORE_DIR, "node_modules", "@mariozechner", "pi-coding-agent", "package.json");
+        if (existsSync3(piPkgPath)) {
+          const installedPi = JSON.parse(readFileSync3(piPkgPath, "utf-8")).version;
+          const declaredClean = (declaredPi || "").replace(/^[\^~]/, "");
+          if (declaredClean && installedPi && declaredClean !== installedPi) {
+            console.log(`  ${yellow("\u26A0")} Pi runtime drift: declared ${cyan(declaredClean)}, installed ${cyan(installedPi)}`);
+            console.log(`    ${dim("Fix:")} ${green("soma update")}`);
+            warnings++;
+          } else if (installedPi) {
+            console.log(`  ${green("\u2713")} Pi runtime ${installedPi}`);
+          }
+        } else {
+          console.log(`  ${yellow("\u26A0")} Pi not installed \u2014 run ${green("soma update")}`);
+          warnings++;
+        }
+      }
+    } catch {
+    }
+  }
   const hasAuth = hasAnyAuth();
   if (hasAuth) {
-    console.log(`  ${green("✓")} API key configured`);
+    console.log(`  ${green("\u2713")} API key configured`);
   } else {
     const unloadedKey = detectKeyInShellConfig();
     if (unloadedKey) {
-      console.log(`  ${yellow("⚠")} ${unloadedKey} found in ${dim(getShellConfigPath())} but not loaded — restart your terminal`);
+      console.log(`  ${yellow("\u26A0")} ${unloadedKey} found in ${dim(getShellConfigPath())} but not loaded \u2014 restart your terminal`);
     } else {
-      console.log(`  ${yellow("⚠")} No API key — run ${green("soma")} to set one up`);
+      console.log(`  ${yellow("\u26A0")} No API key \u2014 run ${green("soma")} to set one up`);
     }
   }
-
   try {
-    const gitV = execSync("git --version", { encoding: "utf-8" }).trim();
+    const gitV = execSync2("git --version", { encoding: "utf-8" }).trim();
     check(true, gitV, "");
   } catch {
     check(false, "", "git not found");
   }
-
   console.log("");
   if (issues === 0 && warnings === 0) {
-    console.log(`  ${green("✓ All checks passed")}`);
+    console.log(`  ${green("\u2713 All checks passed")}`);
   } else if (issues === 0) {
-    console.log(`  ${green("✓ All checks passed")} ${dim(`(${warnings} warning${warnings > 1 ? "s" : ""})`)}`);  
+    console.log(`  ${green("\u2713 All checks passed")} ${dim(`(${warnings} warning${warnings > 1 ? "s" : ""})`)}`);
   } else {
     console.log(`  ${yellow(`${issues} issue${issues > 1 ? "s" : ""} found`)}${warnings > 0 ? dim(` + ${warnings} warning${warnings > 1 ? "s" : ""}`) : ""}`);
-    console.log(`  ${voice.say("suggest", { suggestion: issues > 2 ? "start with soma init" : "check the items above" })}`);
+    console.log(`  ${soma.say("suggest", { suggestion: issues > 2 ? "start with soma init" : "check the items above" })}`);
   }
   console.log("");
 }
-
-// ── Project Doctor ───────────────────────────────────────────────────
-// (large function — kept inline to avoid breaking the complex doctor logic)
-
 async function projectDoctor() {
   const doctorArgs = args.slice(1);
   const wantsScan = doctorArgs.includes("--scan");
   const wantsAll = doctorArgs.includes("--all");
-
   if ((wantsScan || wantsAll) && isInstalled()) {
     await delegateToCore();
     return;
   }
-
   printSigma();
   const agentV = getAgentVersion();
   const projectV = getProjectVersion();
   const installed = isInstalled();
-
-  console.log(`  ${bold("Soma")} — Doctor`);
+  console.log(`  ${bold("Soma")} \u2014 Doctor`);
   console.log("");
-
   if (!installed) {
-    console.log(`  ${red("✗")} Soma not installed. Run ${green("soma init")} first.`);
+    console.log(`  ${red("\u2717")} Soma not installed. Run ${green("soma init")} first.`);
     console.log("");
     return;
   }
-
   console.log(`  Agent:   ${cyan(`v${agentV || "unknown"}`)}`);
   if (projectV) {
     console.log(`  Project: ${cyan(`v${projectV}`)}`);
   }
   console.log(`  CLI:     ${dim(`v${VERSION}`)}`);
   console.log("");
-
-  const hasSomaDir = existsSync(join(process.cwd(), ".soma"));
-
+  const hasSomaDir = existsSync3(join3(process.cwd(), ".soma"));
   if (!hasSomaDir) {
-    console.log(`  ${yellow("⚠")} No .soma/ in current directory.`);
+    console.log(`  ${yellow("\u26A0")} No .soma/ in current directory.`);
     console.log(`  Run ${green("soma init")} to set up this project, or ${green("soma doctor --scan")} to find projects.`);
     console.log("");
     return;
   }
-
   if (!projectV) {
-    console.log(`  ${yellow("⚠")} Project .soma/ has no version (pre-versioning).`);
+    console.log(`  ${yellow("\u26A0")} Project .soma/ has no version (pre-versioning).`);
     console.log(`  This project was likely created before v0.6.3.`);
     console.log(`  Run ${green("soma init")} to bring it up to date.`);
     console.log("");
     return;
   }
-
-  if (agentV && projectV === agentV) {
-    console.log(`  ${green("✓")} Project is up to date.`);
+  if (agentV && semverCmp(projectV, agentV) === 0) {
+    console.log(`  ${green("\u2713")} Project is up to date.`);
     console.log("");
     await healthCheck();
     return;
   }
-  
-  if (agentV && projectV < agentV) {
-    console.log(`  ${yellow("⚠")} Project .soma/ is at ${cyan(`v${projectV}`)} , agent is at ${cyan(`v${agentV}`)} .`);
+  if (agentV && semverCmp(projectV, agentV) < 0) {
+    console.log(`  ${yellow("\u26A0")} Project .soma/ is at ${cyan(`v${projectV}`)} , agent is at ${cyan(`v${agentV}`)} .`);
     console.log("");
-  
     let fixes = 0;
-    const somaDir = join(process.cwd(), ".soma");
-  
-    const settingsPath = join(somaDir, "settings.json");
-    if (existsSync(settingsPath)) {
+    const somaDir = join3(process.cwd(), ".soma");
+    const settingsPath = join3(somaDir, "settings.json");
+    if (existsSync3(settingsPath)) {
       try {
-        const current = JSON.parse(readFileSync(settingsPath, "utf-8"));
+        const current = JSON.parse(readFileSync3(settingsPath, "utf-8"));
         let changed = false;
-        const add = (k, v) => { if (!(k in current)) { current[k] = v; changed = true; fixes++; } };
+        const add = (k, v) => {
+          if (!(k in current)) {
+            current[k] = v;
+            changed = true;
+            fixes++;
+          }
+        };
         add("doctor", { autoUpdate: true, declinedVersion: null });
         add("breathe", { auto: false, triggerAt: 50, rotateAt: 70, graceSeconds: 30 });
         add("context", { notifyAt: 50, warnAt: 70, urgentAt: 80, autoExhaleAt: 85 });
@@ -639,106 +1834,98 @@ async function projectDoctor() {
         add("scratch", { autoInject: false });
         add("guard", { coreFiles: "warn", bashCommands: "warn", gitIdentity: null });
         add("checkpoints", { enabled: true, intervalMinutes: 5, squashOnPush: true });
-        add("persona", { name: null, emoji: "σ" });
+        add("persona", { name: null, emoji: "\u03C3" });
         add("inherit", { identity: true, protocols: true, muscles: true, tools: true });
-        if (changed) writeFileSync(settingsPath, JSON.stringify(current, null, "\t") + "\n");
-      } catch {}
+        if (changed) writeFileSync2(settingsPath, JSON.stringify(current, null, "	") + "\n");
+      } catch {
+      }
     }
-  
-    const bodyDir = join(somaDir, "body");
+    const bodyDir = join3(somaDir, "body");
     let agentRoot = CORE_DIR;
     try {
-      const realCore = readlinkSync(join(CORE_DIR, "core"));
+      const realCore = readlinkSync2(join3(CORE_DIR, "core"));
       if (realCore) {
-        const devRoot = dirname(realCore);
-        if (existsSync(join(devRoot, "body", "_public"))) agentRoot = devRoot;
+        const devRoot = dirname3(realCore);
+        if (existsSync3(join3(devRoot, "templates", "default")) || existsSync3(join3(devRoot, "body", "_public"))) agentRoot = devRoot;
       }
-    } catch {}
-    if (!existsSync(join(agentRoot, "body", "_public"))) {
-      const parent = dirname(agentRoot);
-      if (existsSync(join(parent, "body", "_public"))) agentRoot = parent;
+    } catch {
     }
-    const bundledBody = join(agentRoot, "body", "_public");
-    if (existsSync(bundledBody)) {
+    const bundledBody = existsSync3(join3(agentRoot, "templates", "default")) ? join3(agentRoot, "templates", "default") : existsSync3(join3(agentRoot, "body", "_public")) ? join3(agentRoot, "body", "_public") : null;
+    if (bundledBody && existsSync3(bundledBody)) {
       try {
-        if (!existsSync(bodyDir)) mkdirSync(bodyDir, { recursive: true });
-        for (const f of readdirSync(bundledBody).filter(f => f.endsWith(".md"))) {
-          const dest = join(bodyDir, f);
-          if (!existsSync(dest)) { writeFileSync(dest, readFileSync(join(bundledBody, f), "utf-8")); fixes++; }
+        if (!existsSync3(bodyDir)) mkdirSync2(bodyDir, { recursive: true });
+        for (const f of readdirSync(bundledBody).filter((f2) => f2.endsWith(".md") && !f2.startsWith("_"))) {
+          const dest = join3(bodyDir, f);
+          if (!existsSync3(dest)) {
+            writeFileSync2(dest, readFileSync3(join3(bundledBody, f), "utf-8"));
+            fixes++;
+          }
         }
-      } catch {}
-    }
-  
-    const protoDir = join(somaDir, "amps", "protocols");
-    const bundledProtos = existsSync(join(CORE_DIR, "dist", "content", "protocols"))
-      ? join(CORE_DIR, "dist", "content", "protocols")
-      : existsSync(join(CORE_DIR, "content", "protocols"))
-        ? join(CORE_DIR, "content", "protocols") : null;
+      } catch {
+      }
+    }
+    const protoDir = join3(somaDir, "amps", "protocols");
+    const bundledProtos = existsSync3(join3(CORE_DIR, "dist", "content", "protocols")) ? join3(CORE_DIR, "dist", "content", "protocols") : existsSync3(join3(CORE_DIR, "content", "protocols")) ? join3(CORE_DIR, "content", "protocols") : null;
     if (bundledProtos) {
-      if (!existsSync(protoDir)) mkdirSync(protoDir, { recursive: true });
-      for (const f of readdirSync(bundledProtos).filter(f => f.endsWith(".md") && f !== "_template.md" && f !== "README.md")) {
-        const dest = join(protoDir, f);
-        if (!existsSync(dest)) { writeFileSync(dest, readFileSync(join(bundledProtos, f), "utf-8")); fixes++; }
+      if (!existsSync3(protoDir)) mkdirSync2(protoDir, { recursive: true });
+      for (const f of readdirSync(bundledProtos).filter((f2) => f2.endsWith(".md") && f2 !== "_template.md" && f2 !== "README.md")) {
+        const dest = join3(protoDir, f);
+        if (!existsSync3(dest)) {
+          writeFileSync2(dest, readFileSync3(join3(bundledProtos, f), "utf-8"));
+          fixes++;
+        }
       }
     }
-  
-    const scriptsDir = join(somaDir, "amps", "scripts");
-    const bundledScripts = existsSync(join(agentRoot, "dist", "content", "scripts"))
-      ? join(agentRoot, "dist", "content", "scripts")
-      : existsSync(join(agentRoot, "content", "scripts"))
-        ? join(agentRoot, "content", "scripts")
-        : existsSync(join(agentRoot, "scripts"))
-          ? join(agentRoot, "scripts") : null;
+    const scriptsDir = join3(somaDir, "amps", "scripts");
+    const bundledScripts = existsSync3(join3(agentRoot, "dist", "content", "scripts")) ? join3(agentRoot, "dist", "content", "scripts") : existsSync3(join3(agentRoot, "content", "scripts")) ? join3(agentRoot, "content", "scripts") : existsSync3(join3(agentRoot, "scripts")) ? join3(agentRoot, "scripts") : null;
     if (bundledScripts) {
-      if (!existsSync(scriptsDir)) mkdirSync(scriptsDir, { recursive: true });
-      for (const f of readdirSync(bundledScripts).filter(f => f.endsWith(".sh"))) {
-        const dest = join(scriptsDir, f);
-        if (!existsSync(dest)) {
-          writeFileSync(dest, readFileSync(join(bundledScripts, f), "utf-8"), { mode: 0o755 });
+      if (!existsSync3(scriptsDir)) mkdirSync2(scriptsDir, { recursive: true });
+      for (const f of readdirSync(bundledScripts).filter((f2) => f2.endsWith(".sh"))) {
+        const dest = join3(scriptsDir, f);
+        if (!existsSync3(dest)) {
+          writeFileSync2(dest, readFileSync3(join3(bundledScripts, f), "utf-8"), { mode: 493 });
           fixes++;
         }
       }
     }
-
     if (fixes > 0) {
       try {
-        const s = JSON.parse(readFileSync(settingsPath, "utf-8"));
+        const s = JSON.parse(readFileSync3(settingsPath, "utf-8"));
         s.version = agentV;
-        writeFileSync(settingsPath, JSON.stringify(s, null, "\t") + "\n");
-      } catch {}
-      console.log(`  ${green("✓")} Applied ${fixes} automatic fixes`);
-      const bc = existsSync(join(somaDir, "body")) ? readdirSync(join(somaDir, "body")).filter(f => f.endsWith(".md")).length : 0;
-      const pc = existsSync(protoDir) ? readdirSync(protoDir).filter(f => f.endsWith(".md")).length : 0;
+        writeFileSync2(settingsPath, JSON.stringify(s, null, "	") + "\n");
+      } catch {
+      }
+      console.log(`  ${green("\u2713")} Applied ${fixes} automatic fixes`);
+      const bc = existsSync3(join3(somaDir, "body")) ? readdirSync(join3(somaDir, "body")).filter((f) => f.endsWith(".md")).length : 0;
+      const pc = existsSync3(protoDir) ? readdirSync(protoDir).filter((f) => f.endsWith(".md")).length : 0;
       console.log(`    ${bc} body files, ${pc} protocols, settings updated`);
       console.log(`    Version bumped to ${cyan(`v${agentV}`)}`);
-
       let staleUpdated = 0;
       let staleSkipped = [];
-      if (bundledProtos && existsSync(protoDir)) {
-        for (const f of readdirSync(protoDir).filter(f => f.endsWith(".md") && f !== "_template.md" && f !== "README.md")) {
-          const bundledFile = join(bundledProtos, f);
-          if (!existsSync(bundledFile)) continue;
-          const projRaw = readFileSync(join(protoDir, f), "utf-8");
-          const bundledRaw = readFileSync(bundledFile, "utf-8");
-          const strip = s => s.replace(/^(heat|loads|runs|last-run|heat-default):.*\n?/gm, "").trim();
+      if (bundledProtos && existsSync3(protoDir)) {
+        for (const f of readdirSync(protoDir).filter((f2) => f2.endsWith(".md") && f2 !== "_template.md" && f2 !== "README.md")) {
+          const bundledFile = join3(bundledProtos, f);
+          if (!existsSync3(bundledFile)) continue;
+          const projRaw = readFileSync3(join3(protoDir, f), "utf-8");
+          const bundledRaw = readFileSync3(bundledFile, "utf-8");
+          const strip = (s) => s.replace(/^(heat|loads|runs|last-run|heat-default):.*\n?/gm, "").trim();
           if (strip(projRaw) === strip(bundledRaw)) continue;
           const heatLine = projRaw.match(/^heat:.*$/m);
           const loadsLine = projRaw.match(/^loads:.*$/m);
           let updated = bundledRaw;
           if (heatLine) updated = updated.replace(/^heat:.*$/m, heatLine[0]);
           if (loadsLine) updated = updated.replace(/^loads:.*$/m, loadsLine[0]);
-          writeFileSync(join(protoDir, f), updated);
+          writeFileSync2(join3(protoDir, f), updated);
           staleUpdated++;
         }
       }
-
       console.log("");
       if (staleUpdated > 0) {
-        console.log(`  ${green("✓")} ${staleUpdated} protocols updated to latest version`);
+        console.log(`  ${green("\u2713")} ${staleUpdated} protocols updated to latest version`);
         console.log(`  ${dim("Heat and load counts preserved. Content updated.")}`);
       }
       if (staleSkipped.length > 0) {
-        console.log(`  ${yellow("⚠")} ${staleSkipped.length} protocols skipped (may be customized)`);
+        console.log(`  ${yellow("\u26A0")} ${staleSkipped.length} protocols skipped (may be customized)`);
       }
       console.log("");
       const totalRemaining = staleSkipped.length;
@@ -747,88 +1934,82 @@ async function projectDoctor() {
         console.log(`  ${dim("Remaining: " + totalRemaining + " items need review.")}`);
         console.log(`  ${dim("For full migration:")} ${green("soma")} ${dim("then")} ${green("/soma doctor")}`);
       } else {
-        console.log(`  ${green("✓")} Full migration complete from CLI.`);
-        console.log(`  ${dim("No TUI session needed — all updates applied.")}`);
+        console.log(`  ${green("\u2713")} Full migration complete from CLI.`);
+        console.log(`  ${dim("No TUI session needed \u2014 all updates applied.")}`);
       }
-
-      // Write _doctor-pending.md
       try {
-        const pendingPath = join(somaDir, "body", "_doctor-pending.md");
+        const pendingPath = join3(somaDir, "body", "_doctor-pending.md");
         if (staleSkipped.length === 0) {
           const done = [
-            "---", "type: template", "name: doctor-pending", "status: complete",
-            `created: ${new Date().toISOString().split("T")[0]}`,
-            "description: CLI doctor completed full migration", "---", "",
-            "# Doctor Update — Complete", "",
-            `Migrated from v${projectV} to v${agentV} on ${new Date().toISOString().split("T")[0]}.`,
-            `Applied: ${fixes} file fixes + ${staleUpdated} protocol updates.`, "",
-            "Run `/soma doctor` to verify, then delete this file.",
+            "---",
+            "type: template",
+            "name: doctor-pending",
+            "status: complete",
+            `created: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
+            "description: CLI doctor completed full migration",
+            "---",
+            "",
+            "# Doctor Update \u2014 Complete",
+            "",
+            `Migrated from v${projectV} to v${agentV} on ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.`,
+            `Applied: ${fixes} file fixes + ${staleUpdated} protocol updates.`,
+            "",
+            "Run `/soma doctor` to verify, then delete this file."
           ];
-          writeFileSync(pendingPath, done.join("\n"));
+          writeFileSync2(pendingPath, done.join("\n"));
         }
-      } catch {}
+      } catch {
+      }
     } else {
-      console.log(`  ${green("✓")} Version bumped to ${cyan(`v${agentV}`)}`);
-      console.log(`  ${dim("No file changes needed — project structure is current.")}`);
+      console.log(`  ${green("\u2713")} Version bumped to ${cyan(`v${agentV}`)}`);
+      console.log(`  ${dim("No file changes needed \u2014 project structure is current.")}`);
     }
   } else {
-    console.log(`  ${green("✓")} Project version: ${cyan(`v${projectV}`)}`);
+    console.log(`  ${green("\u2713")} Project version: ${cyan(`v${projectV}`)}`);
   }
-  
   console.log("");
   await healthCheck();
 }
-
-// ── Delegation ───────────────────────────────────────────────────────
-
 async function delegateToCore() {
-  const piPkg = join(CORE_DIR, "node_modules", "@mariozechner", "pi-coding-agent");
-  if (!existsSync(piPkg)) {
-    console.log(`  ${red("✗")} Runtime dependencies missing.`);
+  const piPkg = join3(CORE_DIR, "node_modules", "@mariozechner", "pi-coding-agent");
+  if (!existsSync3(piPkg)) {
+    console.log(`  ${red("\u2717")} Runtime dependencies missing.`);
     console.log(`  ${dim("Run")} ${green("soma init")} ${dim("to repair the installation.")}`);
     console.log("");
     return;
   }
-  const cliEntry = existsSync(join(CORE_DIR, "dist", "cli.js")) 
-    ? join(CORE_DIR, "dist", "cli.js") 
-    : null;
-  const mainEntry = existsSync(join(CORE_DIR, "dist", "main.js"))
-    ? join(CORE_DIR, "dist", "main.js")
-    : null;
+  const cliEntry = existsSync3(join3(CORE_DIR, "dist", "cli.js")) ? join3(CORE_DIR, "dist", "cli.js") : null;
+  const mainEntry = existsSync3(join3(CORE_DIR, "dist", "main.js")) ? join3(CORE_DIR, "dist", "main.js") : null;
   if (!cliEntry && !mainEntry) {
-    console.log(`  ${red("✗")} Runtime entry point missing.`);
+    console.log(`  ${red("\u2717")} Runtime entry point missing.`);
     console.log(`  ${dim("Run")} ${green("soma init")} ${dim("to repair the installation.")}`);
     console.log("");
     return;
   }
-
   const passArgs = process.argv.slice(2);
-
   const cliLocations = [
-    { path: join(CORE_DIR, "dist", "cli.js"),              type: "node" },
-    { path: join(CORE_DIR, "node_modules", ".bin", "pi"),  type: "bin" },
+    { path: join3(CORE_DIR, "dist", "cli.js"), type: "node" },
+    { path: join3(CORE_DIR, "node_modules", ".bin", "pi"), type: "bin" }
   ];
-
   const userExtArgs = [];
-  const projectExtDir = join(process.cwd(), ".soma", "extensions");
-  if (existsSync(projectExtDir)) {
+  const projectExtDir = join3(process.cwd(), ".soma", "extensions");
+  if (existsSync3(projectExtDir)) {
     try {
-      const userExts = readdirSync(projectExtDir).filter(f => f.endsWith(".ts") || f.endsWith(".js"));
+      const userExts = readdirSync(projectExtDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
       for (const ext of userExts) {
-        userExtArgs.push("-e", join(projectExtDir, ext));
+        userExtArgs.push("-e", join3(projectExtDir, ext));
       }
-    } catch {}
+    } catch {
+    }
   }
-
   const env = {
     ...process.env,
     PI_CODING_AGENT_DIR: CORE_DIR,
     SOMA_CODING_AGENT_DIR: CORE_DIR,
-    PI_PACKAGE_DIR: CORE_DIR,
+    PI_PACKAGE_DIR: CORE_DIR
   };
-
   for (const cli of cliLocations) {
-    if (existsSync(cli.path)) {
+    if (existsSync3(cli.path)) {
       try {
         const allArgs = [...userExtArgs, ...passArgs];
         if (cli.type === "node") {
@@ -841,7 +2022,7 @@ async function delegateToCore() {
         if (err.status) process.exit(err.status);
         if (err.message && err.message.includes("MODULE_NOT_FOUND")) {
           console.log("");
-          console.log(`  ${red("✗")} Soma failed to start — missing dependencies.`);
+          console.log(`  ${red("\u2717")} Soma failed to start \u2014 missing dependencies.`);
           console.log(`  ${dim("Run")} ${green("soma init")} ${dim("to repair the installation.")}`);
           console.log("");
         }
@@ -849,21 +2030,25 @@ async function delegateToCore() {
       }
     }
   }
-
-  console.log(`  ${yellow("⚠")} Core is installed but the CLI entry point is missing.`);
-  console.log(`  ${dim("Expected:")} ${dim(cliLocations.map(c => c.path).join(" or "))}`);
+  console.log(`  ${yellow("\u26A0")} Core is installed but the CLI entry point is missing.`);
+  console.log(`  ${dim("Expected:")} ${dim(cliLocations.map((c) => c.path).join(" or "))}`);
   console.log(`  Run ${green("soma init")} to repair the installation.`);
   console.log("");
 }
-
-// ── Dispatch ─────────────────────────────────────────────────────────
-
-const args = process.argv.slice(2);
-const cmd = args[0];
-
-if (cmd === "--version" || cmd === "-v" || cmd === "-V") {
+var args = process.argv.slice(2);
+var cmd = args[0];
+try {
+  const config = readConfig();
+  const currentV = getAgentVersion();
+  if (currentV && config.coreVersion !== currentV) {
+    config.coreVersion = currentV;
+    writeConfig(config);
+  }
+} catch {
+}
+if (cmd === "--version" || cmd === "-v" || cmd === "-V" || cmd === "version") {
   showVersion();
-} else if (cmd === "--help" || cmd === "-h") {
+} else if (cmd === "--help" || cmd === "-h" || cmd === "help") {
   if (isInstalled()) {
     await delegateToCore();
   } else {
@@ -872,24 +2057,34 @@ if (cmd === "--version" || cmd === "-v" || cmd === "-V") {
 } else if (cmd === "about") {
   await showAbout();
 } else if (cmd === "init") {
-  const hasProjectArgs = args.includes("--template") || args.includes("--orphan") || args.includes("-o");
-  const runtimeInstalled = isInstalled();
-  const hasSomaDir = existsSync(join(process.cwd(), ".soma"));
-  
-  if (!runtimeInstalled) {
+  if (!isInstalled()) {
     await initSoma();
-  } else if (hasProjectArgs || !hasSomaDir) {
-    await delegateToCore();
   } else {
-    await checkAndUpdate();
+    await delegateToCore();
   }
 } else if (cmd === "update") {
+  await checkAndUpdate();
+} else if (cmd === "check-updates" || cmd === "updates") {
   checkForUpdates();
 } else if (cmd === "doctor") {
   await projectDoctor();
 } else if (cmd === "status" || cmd === "health") {
   await healthCheck();
+} else if (cmd && cmd.startsWith("--") && !isInstalled()) {
+  console.log(`  ${yellow("\u26A0")} Unknown option: ${cmd}`);
+  console.log(`  Run ${green("soma --help")} for usage.`);
+  console.log("");
 } else if (isInstalled()) {
+  try {
+    const cfg = readConfig();
+    if (cfg.updateAvailable) {
+      const latest = cfg.latestSummary ? ` \u2014 ${dim(cfg.latestSummary)}` : "";
+      console.log(`  ${yellow("\u2B06")} Update available${latest}`);
+      console.log(`    ${dim("Run:")} ${green("soma update")}`);
+      console.log("");
+    }
+  } catch {
+  }
   await delegateToCore();
 } else {
   const postInstallCmds = ["focus", "inhale", "content", "install", "list", "map", "--map", "--preload"];