meetsoma 0.3.4 → 0.3.6

package/dist/personality.js

@@ -15,11 +15,20 @@
  *   soma.react("success", { action: "installed core" })
  */
 
+// ── State (session-scoped, no persistence) ───────────────────────────
+// Keeps the picker from repeating itself within a flow.
+// Reset via soma.reset() for tests.
+
+const _state = {
+  lru: {},           // { key: [lastN picks] } — recency tracking per slot/intent
+  register: null,    // 'formal' | 'casual' | null (sticky once a flow starts)
+  lastGreetAt: 0,    // timestamp — avoid double-greeting in short windows
+};
+
 // ── Deterministic-ish randomness ─────────────────────────────────────
-// Seeded by time-of-day so the same minute gives consistent output
-// but different minutes feel different.
 
 function pick(arr) {
+  if (!arr || arr.length === 0) return "";
   const i = Math.floor(Math.random() * arr.length);
   return arr[i];
 }
@@ -34,13 +43,53 @@ function pickWeighted(arr, weights) {
   return arr[arr.length - 1];
 }
 
+/**
+ * LRU-aware picker. Biases away from recently-picked options for the same
+ * key, so "Got it. Got it. Got it." doesn't happen within a session.
+ * When all options are recent, falls back to uniform pick.
+ *
+ * @param {array} arr — choices
+ * @param {string} lruKey — scope for recency tracking (e.g. "ack", "greet")
+ * @param {number} depth — how many recent picks to avoid (default 3)
+ */
+function pickSmart(arr, lruKey, depth = 3) {
+  if (!arr || arr.length === 0) return "";
+  if (!lruKey || arr.length <= 1) return pick(arr);
+  const recent = _state.lru[lruKey] || [];
+  const fresh = arr.filter(x => !recent.includes(x));
+  const pool = fresh.length > 0 ? fresh : arr;
+  const choice = pick(pool);
+  _state.lru[lruKey] = [...recent, choice].slice(-depth);
+  return choice;
+}
+
+/**
+ * Time-of-day bucket. Drives greeting palette.
+ * @returns {'late' | 'morning' | 'afternoon' | 'evening'}
+ */
+function timeOfDay() {
+  const h = new Date().getHours();
+  if (h < 6) return "late";
+  if (h < 12) return "morning";
+  if (h < 18) return "afternoon";
+  return "evening";
+}
+
 // ── Slot expansion ───────────────────────────────────────────────────
 
 function expand(template, slots = {}) {
   return template.replace(/\{(\w+)\}/g, (_, key) => {
     if (slots[key] !== undefined) return slots[key];
     // Check if there's a vocabulary for this slot
-    if (VOCAB[key]) return pick(VOCAB[key]);
+    if (VOCAB[key]) {
+      const v = VOCAB[key];
+      // Nested structures (e.g. time_greeting) — resolve by time-of-day
+      if (!Array.isArray(v) && typeof v === "object") {
+        const bucket = v[timeOfDay()] || v.default || Object.values(v)[0];
+        return pickSmart(bucket, key);
+      }
+      return pickSmart(v, key);
+    }
     return `{${key}}`;
   });
 }
@@ -52,6 +101,13 @@ const VOCAB = {
   greeting: [
     "Hey", "Hi", "Hello", "Hey there",
   ],
+  // Time-specific greetings
+  time_greeting: {
+    late:      ["Still up?", "Late session", "Hey — still here?"],
+    morning:   ["Morning", "Good morning", "Hey — morning"],
+    afternoon: ["Hey", "Afternoon", "Hi"],
+    evening:   ["Evening", "Good evening", "Hey"],
+  },
   // Acknowledgements
   ack: [
     "Got it", "Understood", "Right", "Noted", "Copy that", "On it",
@@ -76,6 +132,14 @@ const VOCAB = {
   consider: [
     "Looks like", "Seems like", "Appears to be", "That's",
   ],
+  // Reassurance (when surfacing drift / problems)
+  reassure: [
+    "Nothing scary", "Small fix", "Quick one", "Easy one",
+  ],
+  // Attention (when announcing results)
+  attention: [
+    "Here's the map", "Here's what I see", "Snapshot", "Current state",
+  ],
 };
 
 // ── Skeletons ────────────────────────────────────────────────────────
@@ -176,6 +240,39 @@ const SKELETONS = {
     "Until next time.",
     "Exhale complete.",
   ],
+  // Version / update UX
+  version_check: [
+    "{attention} — three layers:",
+    "Checking in on your setup.",
+    "{transition} look at the version state.",
+    "Version snapshot:",
+  ],
+  version_aligned: [
+    "All three layers are aligned. You're good.",
+    "Everything's in sync — CLI, agent, workspace.",
+    "{done_word}. All layers on the same page.",
+    "Aligned end-to-end.",
+  ],
+  version_drift: [
+    "Found some drift. {reassure}.",
+    "A few things out of sync. {reassure}.",
+    "Layers don't match. {reassure} — here's the fix.",
+    "Drift detected. Walk through below.",
+  ],
+
+  // Doctor UX
+  doctor_clean: [
+    "Workspace is {quality}. Nothing to fix.",
+    "Your .soma checks out.",
+    "{done_word}. All checks pass.",
+    "Healthy. Moving on.",
+  ],
+  doctor_found_items: [
+    "Found {n} item{plural}. {reassure}.",
+    "{n} thing{plural} to tidy. {reassure}.",
+    "Spotted {n} item{plural} worth attention.",
+  ],
+
 };
 
 // ── Topics ───────────────────────────────────────────────────────────
@@ -413,6 +510,31 @@ const soma = {
   expand(template, slots) {
     return expand(template, slots);
   },
+
+  /**
+   * Time-aware intro. Greeting shaded by time of day.
+   */
+  intro(user) {
+    const bucket = VOCAB.time_greeting[timeOfDay()] || VOCAB.greeting;
+    const tg = pickSmart(bucket, "time_greeting");
+    return user ? `${tg}, ${user}.` : `${tg}.`;
+  },
+
+  /**
+   * Reset session state (tests / sandbox isolation).
+   */
+  reset() {
+    _state.lru = {};
+    _state.register = null;
+    _state.lastGreetAt = 0;
+  },
+
+  /**
+   * Current session state (debug / telemetry).
+   */
+  _debug() {
+    return JSON.parse(JSON.stringify(_state));
+  },
 };
 
 export { soma, SKELETONS, TOPICS, VOCAB, spin, expand, pick };

package/dist/thin-cli.js

@@ -9,7 +9,7 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// ../../cli/dist/lib/display.js
+// lib/display.js
 var display_exports = {};
 __export(display_exports, {
   bold: () => bold,
@@ -193,7 +193,8 @@ function readSecret(prompt) {
 }
 var bold, dim, italic, cyan, green, yellow, red, magenta, white;
 var init_display = __esm({
-  "../../cli/dist/lib/display.js"() {
+  "lib/display.js"() {
+    "use strict";
     bold = (s) => `\x1B[1m${s}\x1B[0m`;
     dim = (s) => `\x1B[2m${s}\x1B[0m`;
     italic = (s) => `\x1B[3m${s}\x1B[0m`;
@@ -207,21 +208,54 @@ var init_display = __esm({
 });
 
 // thin-cli.js
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, readdirSync, statSync, readlinkSync as readlinkSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, readdirSync, 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 as execSync2, execFileSync } from "child_process";
 
 // personality.js
+var _state = {
+  lru: {},
+  // { key: [lastN picks] } — recency tracking per slot/intent
+  register: null,
+  // 'formal' | 'casual' | null (sticky once a flow starts)
+  lastGreetAt: 0
+  // timestamp — avoid double-greeting in short windows
+};
 function pick(arr) {
+  if (!arr || arr.length === 0) return "";
   const i = Math.floor(Math.random() * arr.length);
   return arr[i];
 }
+function pickSmart(arr, lruKey, depth = 3) {
+  if (!arr || arr.length === 0) return "";
+  if (!lruKey || arr.length <= 1) return pick(arr);
+  const recent = _state.lru[lruKey] || [];
+  const fresh = arr.filter((x) => !recent.includes(x));
+  const pool = fresh.length > 0 ? fresh : arr;
+  const choice = pick(pool);
+  _state.lru[lruKey] = [...recent, choice].slice(-depth);
+  return choice;
+}
+function timeOfDay() {
+  const h = (/* @__PURE__ */ new Date()).getHours();
+  if (h < 6) return "late";
+  if (h < 12) return "morning";
+  if (h < 18) return "afternoon";
+  return "evening";
+}
 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]);
+    if (VOCAB[key]) {
+      const v = VOCAB[key];
+      if (!Array.isArray(v) && typeof v === "object") {
+        const bucket = v[timeOfDay()] || v.default || Object.values(v)[0];
+        return pickSmart(bucket, key);
+      }
+      return pickSmart(v, key);
+    }
     return `{${key}}`;
   });
 }
@@ -233,6 +267,13 @@ var VOCAB = {
     "Hello",
     "Hey there"
   ],
+  // Time-specific greetings
+  time_greeting: {
+    late: ["Still up?", "Late session", "Hey \u2014 still here?"],
+    morning: ["Morning", "Good morning", "Hey \u2014 morning"],
+    afternoon: ["Hey", "Afternoon", "Hi"],
+    evening: ["Evening", "Good evening", "Hey"]
+  },
   // Acknowledgements
   ack: [
     "Got it",
@@ -278,6 +319,20 @@ var VOCAB = {
     "Seems like",
     "Appears to be",
     "That's"
+  ],
+  // Reassurance (when surfacing drift / problems)
+  reassure: [
+    "Nothing scary",
+    "Small fix",
+    "Quick one",
+    "Easy one"
+  ],
+  // Attention (when announcing results)
+  attention: [
+    "Here's the map",
+    "Here's what I see",
+    "Snapshot",
+    "Current state"
   ]
 };
 var SKELETONS = {
@@ -361,6 +416,37 @@ var SKELETONS = {
     "I'll remember.",
     "Until next time.",
     "Exhale complete."
+  ],
+  // Version / update UX
+  version_check: [
+    "{attention} \u2014 three layers:",
+    "Checking in on your setup.",
+    "{transition} look at the version state.",
+    "Version snapshot:"
+  ],
+  version_aligned: [
+    "All three layers are aligned. You're good.",
+    "Everything's in sync \u2014 CLI, agent, workspace.",
+    "{done_word}. All layers on the same page.",
+    "Aligned end-to-end."
+  ],
+  version_drift: [
+    "Found some drift. {reassure}.",
+    "A few things out of sync. {reassure}.",
+    "Layers don't match. {reassure} \u2014 here's the fix.",
+    "Drift detected. Walk through below."
+  ],
+  // Doctor UX
+  doctor_clean: [
+    "Workspace is {quality}. Nothing to fix.",
+    "Your .soma checks out.",
+    "{done_word}. All checks pass.",
+    "Healthy. Moving on."
+  ],
+  doctor_found_items: [
+    "Found {n} item{plural}. {reassure}.",
+    "{n} thing{plural} to tidy. {reassure}.",
+    "Spotted {n} item{plural} worth attention."
   ]
 };
 function spin(text) {
@@ -535,13 +621,35 @@ var soma = {
    */
   expand(template, slots) {
     return expand(template, slots);
+  },
+  /**
+   * Time-aware intro. Greeting shaded by time of day.
+   */
+  intro(user) {
+    const bucket = VOCAB.time_greeting[timeOfDay()] || VOCAB.greeting;
+    const tg = pickSmart(bucket, "time_greeting");
+    return user ? `${tg}, ${user}.` : `${tg}.`;
+  },
+  /**
+   * Reset session state (tests / sandbox isolation).
+   */
+  reset() {
+    _state.lru = {};
+    _state.register = null;
+    _state.lastGreetAt = 0;
+  },
+  /**
+   * Current session state (debug / telemetry).
+   */
+  _debug() {
+    return JSON.parse(JSON.stringify(_state));
   }
 };
 
 // thin-cli.js
 init_display();
 
-// ../../cli/dist/lib/config.js
+// lib/config.js
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join, dirname } from "path";
 import { homedir } from "os";
@@ -561,7 +669,7 @@ function writeConfig(config) {
   writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 384 });
 }
 
-// ../../cli/dist/lib/detect.js
+// 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";
@@ -596,6 +704,104 @@ function getProjectVersion() {
     return null;
   }
 }
+function semverCmp(a, b) {
+  if (!a || !b) return 0;
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  const len = Math.max(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    const va = pa[i] || 0, vb = pb[i] || 0;
+    if (va < vb) return -1;
+    if (va > vb) return 1;
+  }
+  return 0;
+}
+function detectDevInstall() {
+  try {
+    const nodeBin = process.argv[1];
+    if (!nodeBin) return null;
+    const target = readlinkSync(nodeBin);
+    if (target.includes("/node_modules/") && target.includes("meetsoma")) return null;
+    return target;
+  } catch {
+    return null;
+  }
+}
+function npmLatest(pkg) {
+  try {
+    return execSync(`npm view ${pkg} version 2>/dev/null`, {
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function getVersionSnapshot(opts = {}) {
+  const checkRemote = opts.checkRemote !== false;
+  let cliLocal = null;
+  try {
+    const cliPkg = join2(new URL(".", import.meta.url).pathname, "..", "..", "package.json");
+    cliLocal = JSON.parse(readFileSync2(cliPkg, "utf-8")).version;
+  } catch {
+  }
+  const cliRemote = checkRemote ? npmLatest("meetsoma") : null;
+  const cliStatus = cliStatus_(cliLocal, cliRemote);
+  const agentLocal = getAgentVersion();
+  const agentRemote = checkRemote ? npmLatest("soma-agent") : null;
+  const agentStatus = installed_(agentLocal) ? cliStatus_(agentLocal, agentRemote) : "not-installed";
+  const wsLocal = getProjectVersion();
+  let wsStatus;
+  if (!wsLocal) wsStatus = "no-workspace";
+  else if (agentLocal && semverCmp(wsLocal, agentLocal) < 0) wsStatus = "marker-lag";
+  else if (agentLocal && semverCmp(wsLocal, agentLocal) === 0) wsStatus = "aligned";
+  else wsStatus = "unknown";
+  const devInstall = detectDevInstall();
+  let coreRepo = null;
+  if (installed_(agentLocal)) {
+    try {
+      const config = readConfigSafe_();
+      if (config?.installPath) {
+        execSync("git fetch origin --quiet", { cwd: config.installPath, stdio: "ignore", timeout: 5e3 });
+        const behind = execSync("git rev-list HEAD..origin/$(git rev-parse --abbrev-ref HEAD) --count", {
+          cwd: config.installPath,
+          encoding: "utf-8",
+          shell: "/bin/bash",
+          timeout: 5e3
+        }).trim();
+        coreRepo = { behind: parseInt(behind, 10) || 0 };
+      }
+    } catch {
+    }
+  }
+  return {
+    cli: { local: cliLocal, remote: cliRemote, status: cliStatus },
+    agent: { local: agentLocal, remote: agentRemote, status: agentStatus },
+    workspace: { local: wsLocal, status: wsStatus },
+    devInstall,
+    coreRepo,
+    allAligned: cliStatus === "aligned" && (agentStatus === "aligned" || agentStatus === "dev-ahead") && (wsStatus === "aligned" || wsStatus === "no-workspace")
+  };
+}
+function installed_(v) {
+  return v && v !== "unknown";
+}
+function cliStatus_(local, remote) {
+  if (!local) return "unknown";
+  if (!remote) return "unknown";
+  const cmp = semverCmp(local, remote);
+  if (cmp === 0) return "aligned";
+  if (cmp > 0) return "dev-ahead";
+  return "stale";
+}
+function readConfigSafe_() {
+  try {
+    const p = join2(CORE_DIR, "config.json");
+    return JSON.parse(readFileSync2(p, "utf-8"));
+  } 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;
@@ -648,332 +854,7 @@ function getGitHubUsername() {
   }
 }
 
-// ../../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
+// 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?" },
@@ -1015,7 +896,7 @@ function matchQuestion(input) {
 async function handleQuestion(input) {
   const match = matchQuestion(input);
   if (match) {
-    const answer = soma2.ask(match.topic);
+    const answer = soma.ask(match.topic);
     console.log("");
     await typeParagraph(answer);
     return true;
@@ -1027,16 +908,16 @@ async function handleQuestion(input) {
   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.}")}
+    await typeOut(`  ${soma.greet()} ${soma.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"));
+    await typeParagraph(soma.ask("meta_rude"));
   } else if (impressed) {
-    await typeParagraph(soma2.ask("meta_impressed"));
+    await typeParagraph(soma.ask("meta_impressed"));
   } else if (meta) {
-    await typeParagraph(soma2.ask("meta_self"));
+    await typeParagraph(soma.ask("meta_self"));
   } else {
-    await typeParagraph(soma2.ask("meta_nonsense"));
+    await typeParagraph(soma.ask("meta_nonsense"));
   }
   return false;
 }
@@ -1067,18 +948,18 @@ async function interactiveQ() {
   }
   if (rounds >= maxRounds) {
     console.log("");
-    await typeOut(`  ${soma2.spin("{Curious enough?|Intrigued?|Want to see it in action?}")} ${dim("Let's set you up.")}
+    await typeOut(`  ${soma.spin("{Curious enough?|Intrigued?|Want to see it in action?}")} ${dim("Let's set you up.")}
 `);
   }
 }
 
-// ../../cli/dist/welcome/auth.js
+// 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?}")}
+  await typeOut(`  ${soma.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")}`);
@@ -1116,7 +997,7 @@ async function apiKeyExplain() {
 }
 async function apiKeyGetOne() {
   console.log("");
-  await typeOut(`  ${soma2.spin("{Here's how.|Let me walk you through it.|Quick steps.}")}
+  await typeOut(`  ${soma.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:`);
@@ -1163,7 +1044,7 @@ export ANTHROPIC_API_KEY="${apiKey}"
     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.")}
+    await typeOut(`  ${soma.spin("{You're all set.|Good to go.|Ready.}")} ${dim("Soma can start now.")}
 `);
     console.log("");
   } catch {
@@ -1182,13 +1063,13 @@ async function oauthGuide() {
   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.}")}
+  await typeOut(`  ${soma.spin("{Let's launch.|Starting up.|Here we go.}")}
 `);
   console.log("");
   process.env._SOMA_OAUTH_PENDING = "1";
 }
 
-// ../../cli/dist/welcome/about.js
+// welcome/about.js
 init_display();
 async function showAbout() {
   printSigma();
@@ -1220,7 +1101,7 @@ async function showAbout() {
   console.log("");
   console.log(`  ${dim("\u2500".repeat(58))}`);
   console.log("");
-  const pitch = soma2.ask("what_is_soma");
+  const pitch = soma.ask("what_is_soma");
   await typeOut(`  ${magenta("\u275D")} ${italic(pitch)}
 `);
   console.log("");
@@ -1234,18 +1115,25 @@ async function showAbout() {
 
 // 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;
+var __CLI_VERSION__ = "__CLI_VERSION__";
+function resolveCliVersion() {
+  if (!__CLI_VERSION__.startsWith("__")) return __CLI_VERSION__;
+  const candidates = [
+    join3(__dirname, "package.json"),
+    join3(__dirname, "..", "package.json"),
+    join3(__dirname, "..", "npm", "package.json")
+  ];
+  for (const p of candidates) {
+    try {
+      const pkg = JSON.parse(readFileSync3(p, "utf-8"));
+      if (pkg.name === "meetsoma") return pkg.version;
+    } catch {
+    }
   }
-  return 0;
+  return "unknown";
 }
+var VERSION = resolveCliVersion();
+var semverCmp2 = semverCmp;
 async function showWelcome() {
   printSigma();
   console.log(`  ${bold("Soma")} ${dim("\u2014")} ${white("the AI agent that remembers")}`);
@@ -1333,8 +1221,9 @@ function showHelp() {
   console.log(`    ${green("soma map --list")}        Show available MAPs`);
   console.log("");
   console.log(`  ${bold("Maintenance")}`);
-  console.log(`    ${green("soma doctor")}            Verify installation health`);
-  console.log(`    ${green("soma update")}            Check for updates`);
+  console.log(`    ${green("soma doctor")}            Verify installation + project health`);
+  console.log(`    ${green("soma update")}            Update the Soma runtime`);
+  console.log(`    ${green("soma check-updates")}     Check for updates without installing`);
   console.log(`    ${green("soma status")}            Show installation status`);
   console.log("");
   console.log(`  ${bold("Options")}`);
@@ -1492,8 +1381,17 @@ async function initSoma() {
   console.log("");
 }
 async function checkAndUpdate() {
+  if (!isInstalled()) {
+    printSigma();
+    console.log(`  ${bold("Soma")} \u2014 Update`);
+    console.log("");
+    console.log(`  ${yellow("\u26A0")} Soma is not installed yet.`);
+    console.log(`  Run ${green("soma init")} to install, then ${green("soma update")} to update.`);
+    console.log("");
+    return;
+  }
   printSigma();
-  console.log(`  ${bold("Soma")} \u2014 Status`);
+  console.log(`  ${bold("Soma")} \u2014 Update`);
   console.log("");
   const config = readConfig();
   const installPath = config.installPath || join3(SOMA_HOME, "agent");
@@ -1529,7 +1427,7 @@ async function checkAndUpdate() {
     console.log(`  ${green("\u2713")} Already up to date.`);
     const agentV = getAgentVersion();
     const projectV = getProjectVersion();
-    if (agentV && projectV && semverCmp(projectV, agentV) < 0) {
+    if (agentV && projectV && semverCmp2(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.`);
     }
@@ -1559,7 +1457,7 @@ async function checkAndUpdate() {
   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(`  ${dim("Skipped. Run")} ${green("soma update")} ${dim("anytime to update.")}`);
     console.log("");
     return;
   }
@@ -1609,50 +1507,82 @@ async function checkAndUpdate() {
   console.log("");
 }
 function checkForUpdates() {
+  if (!isInstalled()) {
+    printSigma();
+    console.log(`  ${bold("Soma")} \u2014 Update Check`);
+    console.log("");
+    console.log(`  ${yellow("\u26A0")} Soma is not installed yet.`);
+    console.log(`  Run ${green("soma init")} to install it first.`);
+    console.log("");
+    return;
+  }
   printSigma();
   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 = execSync2("npm view meetsoma version 2>/dev/null", { encoding: "utf-8" }).trim();
-    if (latest && latest !== VERSION && latest > VERSION) {
-      console.log("");
-      console.log(`  ${yellow("\u2B06")} CLI update available: ${green(`v${latest}`)}`);
-      console.log(`    Run: ${green("npm install -g meetsoma")}`);
-    } else {
-      console.log(`  ${green("\u2713")} CLI is up to date`);
-    }
-  } catch {
-    console.log(`  ${dim("Could not check npm registry")}`);
+  const snap = getVersionSnapshot();
+  const intro = snap.allAligned ? soma.say("version_aligned") : soma.say("version_check");
+  console.log(`  ${dim(intro)}`);
+  console.log("");
+  const row = (label, local, remote, status) => {
+    const v = local ? `v${local}` : dim("\u2014");
+    let tail = "";
+    if (status === "aligned") tail = `  ${green("\u2713")} latest on npm`;
+    else if (status === "dev-ahead") tail = `  ${green("\u2713")} dev-ahead ${dim(`(npm: v${remote})`)}`;
+    else if (status === "stale") tail = `  ${yellow("\u2B06")} stale ${dim(`(npm: v${remote})`)}`;
+    else if (status === "marker-lag") tail = `  ${yellow("\u2B06")} marker lag ${dim("\u2014 run `soma doctor` to advance")}`;
+    else if (status === "no-workspace") tail = `  ${dim("\u2014 no .soma/ in cwd")}`;
+    else if (status === "not-installed") tail = `  ${red("\u2717")} not installed`;
+    else tail = `  ${dim("\u2014 unknown")}`;
+    console.log(`  ${label.padEnd(26)}${cyan(v.padEnd(12))}${tail}`);
+  };
+  row("CLI (meetsoma)", snap.cli.local, snap.cli.remote, snap.cli.status);
+  row("Agent (soma-agent)", snap.agent.local, snap.agent.remote, snap.agent.status);
+  row("Workspace (.soma)", snap.workspace.local, null, snap.workspace.status);
+  if (snap.coreRepo && snap.coreRepo.behind > 0) {
+    console.log(`  ${yellow("\u2B06")} Core repo: ${snap.coreRepo.behind} commit${snap.coreRepo.behind !== 1 ? "s" : ""} behind origin`);
+  } else if (snap.coreRepo) {
+    console.log(`  ${green("\u2713")} Core repo in sync with origin`);
   }
-  if (isInstalled() && config.installPath) {
-    try {
-      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 = execSync2(
-        `git rev-list HEAD..origin/${branch} --count`,
-        { cwd: config.installPath, encoding: "utf-8" }
-      ).trim();
-      if (behind && parseInt(behind) > 0) {
-        console.log(`  ${yellow("\u2B06")} Core: ${behind} commit${behind !== "1" ? "s" : ""} behind. Run ${green("soma init")} to update.`);
+  console.log("");
+  if (snap.allAligned) {
+    console.log(`  ${green("\u2713")} ${soma.say("version_aligned")}`);
+  } else {
+    console.log(`  ${dim(soma.say("version_drift"))}`);
+    console.log("");
+    const hints = [];
+    if (snap.cli.status === "stale") {
+      if (snap.devInstall) {
+        hints.push(`${yellow("\u2192")} CLI stale: ${dim("switch to stable first:")} ${green("soma-install.sh stable")} ${dim("\u2192 then")} ${green("npm i -g meetsoma")}`);
       } else {
-        console.log(`  ${green("\u2713")} Core is up to date`);
+        hints.push(`${yellow("\u2192")} CLI stale: run ${green("npm i -g meetsoma")}`);
       }
-    } catch {
-      console.log(`  ${dim("Could not check core updates")}`);
     }
+    if (snap.agent.status === "stale") {
+      hints.push(`${yellow("\u2192")} Agent stale: run ${green("soma update")} ${dim("(or")} ${green("soma-install.sh stable")}${dim(")")}`);
+    }
+    if (snap.workspace.status === "marker-lag") {
+      hints.push(`${yellow("\u2192")} Workspace marker behind agent: run ${green("soma doctor")}`);
+    }
+    if (snap.coreRepo && snap.coreRepo.behind > 0) {
+      hints.push(`${yellow("\u2192")} Core repo behind: run ${green("soma update")} (or git pull in ${dim("~/.soma/agent/")})`);
+    }
+    if (hints.length === 0) {
+      hints.push(`${green("\u2713")} Nothing to do.`);
+    }
+    hints.forEach((h) => console.log(`  ${h}`));
   }
   console.log("");
 }
 async function healthCheck() {
+  if (!isInstalled()) {
+    printSigma();
+    console.log(`  ${bold("Soma")} \u2014 Health Check`);
+    console.log("");
+    console.log(`  ${yellow("\u26A0")} Soma is not installed yet.`);
+    console.log(`  Run ${green("soma init")} to install, then ${green("soma status")} to check health.`);
+    console.log("");
+    return;
+  }
   printSigma();
   console.log(`  ${bold("Soma")} \u2014 Health Check`);
   console.log("");
@@ -1800,17 +1730,17 @@ async function projectDoctor() {
   if (!projectV) {
     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(`  Run ${green("/soma doctor")} inside a session to migrate, or re-init with ${green("soma init")}.`);
     console.log("");
     return;
   }
-  if (agentV && semverCmp(projectV, agentV) === 0) {
+  if (agentV && semverCmp2(projectV, agentV) === 0) {
     console.log(`  ${green("\u2713")} Project is up to date.`);
     console.log("");
     await healthCheck();
     return;
   }
-  if (agentV && semverCmp(projectV, agentV) < 0) {
+  if (agentV && semverCmp2(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;
@@ -2087,7 +2017,7 @@ if (cmd === "--version" || cmd === "-v" || cmd === "-V" || cmd === "version") {
   }
   await delegateToCore();
 } else {
-  const postInstallCmds = ["focus", "inhale", "content", "install", "list", "map", "--map", "--preload"];
+  const postInstallCmds = ["focus", "inhale", "content", "install", "list", "map", "--map", "--preload", "model", "session", "code", "verify", "refactor", "seam", "hub", "body", "run"];
   if (cmd && postInstallCmds.includes(cmd)) {
     printSigma();
     console.log(`  ${bold("soma " + cmd)} requires the Soma runtime.`);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "meetsoma",
-	"version": "0.3.4",
+	"version": "0.3.6",
 	"description": "Soma — the AI coding agent with self-growing memory",
 	"type": "module",
 	"bin": {