release 7.0.0: The Bitter Pill Release — BPE simplification, ~69% context reduction, modes/tiers retired, Algorithm v8.3.0 + AlgorithmNudge, hook consolidation, 5 community PRs merged

Author: danielmiessler

LifeOS/INSTALL.md

@@ -45,7 +45,7 @@ Do not begin a partial install you can't finish.
 
 ### 2. Get the release and detect the environment
 
-Fetch the **latest** LifeOS release from `danielmiessler/LifeOS`. Resolve the newest published release with `curl -fsSL https://api.github.com/repos/danielmiessler/LifeOS/releases/latest` and read its `tag_name`, then download that tag's source tarball (`https://github.com/danielmiessler/LifeOS/archive/refs/tags/<tag>.tar.gz`, HTTPS, no auth) and extract the `LifeOS/` skill directory. (Or use a local release directory if your human already has one.) Then, from the LifeOS skill directory, run:
+Fetch the pinned LifeOS release for the repo and version on the install page (the tag tarball over HTTPS, no auth), or use a local release directory if given one. Then, from the LifeOS skill directory, run:
 
 ```
 bun Tools/DetectEnv.ts

LifeOS/SKILL.md

@@ -1,6 +1,8 @@
 ---
 name: LifeOS
+version: 1.4.19
 description: Install and onboard a user into LifeOS — the Life Operating System (current state → ideal state via TELOS + the Algorithm). The agentic installer detects your OS + harness, wires hooks with permission, scaffolds your USER tree, pulls in sources you provide, and runs the TELOS / current→ideal interview that seeds your Pulse dashboard. USE WHEN install LifeOS, set up LifeOS, lifeos setup, lifeos-setup, lifeos interview, onboard me, run the interview, integrate LifeOS into my harness, update LifeOS, uninstall LifeOS, first-time setup. NOT FOR building or cutting a LifeOS release (private release tooling), editing TELOS after onboarding (use Telos / Interview), or LifeOS system maintenance (use the private maintenance skill).
+disable-model-invocation: true
 argument-hint: "[setup|interview|update|uninstall]"
 allowed-tools: Read, Write, Edit, Bash, Glob, Grep
 ---

LifeOS/Tools/DeployComponents.ts

@@ -40,7 +40,26 @@ import { copyMissing, detectDevTree } from "./InstallEngine";
 // Enhancement components are the à-la-carte half of setup. The "LifeOS Core"
 // (skills + system prompt + base settings + CLAUDE.md) is installed by Setup's
 // core steps; these are the opt-in extras the user (or their AI) picks some/all/none of.
-const KNOWN_COMPONENTS = ["statusline", "tooltips", "spinnerverbs", "agents", "pulse", "worksweep", "derivedsync"] as const;
+//
+// Two kinds:
+// - Non-launchd: statusline, tooltips, spinnerverbs, agents, commands — settings.json merges + file copies
+// - Launchd services: delegated to Services.ts (single source of truth for all 16 background services)
+//
+// Component names for launchd services are their short labels (pulse, worksweep, amberroute, etc.)
+// or the full label (com.lifeos.pulse). Services.ts handles the mapping.
+const NON_LAUNCHD_COMPONENTS = ["statusline", "tooltips", "spinnerverbs", "agents", "commands"] as const;
+type NonLaunchdComponent = (typeof NON_LAUNCHD_COMPONENTS)[number];
+
+// Launchd components — kept in sync with Services.ts. The install for these is delegated to Services.ts.
+// Short labels (without com.lifeos. prefix) for convenience; Services.ts accepts both forms.
+const LAUNCHD_COMPONENTS = [
+  "pulse", "pulse-menubar", "deriver", "conduit", "conduit.insight", "synthesis",
+  "worksweep", "derivedsync", "healthsync", "codexupdate", "commitmentsweep",
+  "blogdiscovery", "usage-aggregator", "bookmark-watchdog", "backups", "amberroute"
+] as const;
+type LaunchdComponent = (typeof LAUNCHD_COMPONENTS)[number];
+
+const KNOWN_COMPONENTS = [...NON_LAUNCHD_COMPONENTS, ...LAUNCHD_COMPONENTS] as const;
 type Component = (typeof KNOWN_COMPONENTS)[number];
 
 interface Ctx {
@@ -49,6 +68,7 @@ interface Ctx {
   payloadRoot: string; // <skillRoot>/install/LIFEOS — the shipped runtime tree
   installRoot: string; // <skillRoot>/install — settings.enhancements.json + agents/ live here
   home: string;
+  bun: string; // resolved bun binary path — substituted for __BUN_PATH__ in launchd plists
   launchAgents: string;
   apply: boolean;
 }
@@ -124,71 +144,8 @@ function launchctl(args: string[]): { ok: boolean; out: string } {
   }
 }
 
-function httpCode(url: string): string {
-  try {
-    return execFileSync("curl", ["-s", "-o", "/dev/null", "-w", "%{http_code}", "--max-time", "3", url]).toString().trim();
-  } catch {
-    return "000";
-  }
-}
-
 // ── component deployers ──────────────────────────────────────────────
 
-/** Pulse: ensure the PULSE tree is laid down, then install + load its plist. */
-function deployPulse(ctx: Ctx): ComponentResult {
-  const r: ComponentResult = { component: "pulse", ready: false, actions: [], blockers: [] };
-  const av = availability("PULSE", ctx);
-  const pulseDir = join(ctx.lifeosDir, "PULSE");
-  const plistDst = join(ctx.launchAgents, "com.lifeos.pulse.plist");
-
-  if (!av.inLive && !av.inPayload) {
-    r.blockers.push(`PULSE not in live tree (${pulseDir}) or payload (${join(ctx.payloadRoot, "PULSE")})`);
-    return r;
-  }
-  r.ready = true;
-  if (!ctx.apply) {
-    if (!av.inLive) r.actions.push(`copy PULSE from payload → ${pulseDir}`);
-    r.actions.push(`materialize ${plistDst} (__HOME__ → ${ctx.home})`, "launchctl bootstrap gui/<uid> (skip if already loaded + unchanged)", "poll 127.0.0.1:31337/healthz until 200");
-    return r;
-  }
-
-  try {
-    ensurePresent("PULSE", ctx);
-    const plistSrc = join(pulseDir, "com.lifeos.pulse.plist");
-    if (!existsSync(plistSrc)) throw new Error(`plist template missing at ${plistSrc}`);
-    const materialized = readFileSync(plistSrc, "utf-8").replaceAll("__HOME__", ctx.home);
-    const u = uid();
-    const sameOnDisk = existsSync(plistDst) && readFileSync(plistDst, "utf-8") === materialized;
-    const alreadyLoaded = launchctl(["print", `gui/${u}/com.lifeos.pulse`]).ok;
-
-    // Idempotent: a loaded service with an identical plist is left running.
-    if (sameOnDisk && alreadyLoaded) {
-      r.applied = false;
-      r.probe = { name: "pulse-healthz", passed: httpCode("http://127.0.0.1:31337/healthz") === "200", detail: "already loaded, plist unchanged (idempotent)" };
-      return r;
-    }
-
-    if (existsSync(plistDst) && !sameOnDisk) backup(plistDst);
-    mkdirSync(ctx.launchAgents, { recursive: true });
-    writeFileSync(plistDst, materialized);
-    if (alreadyLoaded) launchctl(["bootout", `gui/${u}`, plistDst]);
-    const boot = launchctl(["bootstrap", `gui/${u}`, plistDst]);
-    r.applied = true;
-
-    // Readiness poll: launchd bootstrap returns before Pulse binds :31337.
-    let code = "000";
-    for (let i = 0; i < 12; i++) {
-      code = httpCode("http://127.0.0.1:31337/healthz");
-      if (code === "200") break;
-      Bun.sleepSync(500);
-    }
-    r.probe = { name: "pulse-healthz", passed: code === "200", detail: `healthz → ${code}${boot.ok ? "" : ` (bootstrap: ${boot.out.trim()})`}` };
-  } catch (err) {
-    r.error = err instanceof Error ? err.message : String(err);
-  }
-  return r;
-}
-
 /** Statusline: place the script, chmod +x, wire settings.json statusLine. */
 function deployStatusline(ctx: Ctx): ComponentResult {
   const r: ComponentResult = { component: "statusline", ready: false, actions: [], blockers: [] };
@@ -247,44 +204,6 @@ function deployStatusline(ctx: Ctx): ComponentResult {
   return r;
 }
 
-/** Delegate a launchd job to its own standalone installer (no-arg = install). */
-function deployLaunchdJob(component: Component, installerRel: string, ctx: Ctx): ComponentResult {
-  const r: ComponentResult = { component, ready: false, actions: [], blockers: [] };
-  const av = availability(installerRel, ctx);
-  // The installer needs sibling TOOLS files (templates, WorkSweep.ts, …), so the
-  // unit of staging is the whole TOOLS dir — uniform with pulse/statusline.
-  const toolsAv = availability("TOOLS", ctx);
-  const installer = join(ctx.lifeosDir, installerRel);
-
-  if (!av.inLive && !toolsAv.inPayload) {
-    r.blockers.push(`${installerRel} not in live tree and TOOLS not in payload (${join(ctx.payloadRoot, "TOOLS")}) — runtime tree not staged`);
-    return r;
-  }
-  r.ready = true;
-  if (!ctx.apply) {
-    if (!av.inLive) r.actions.push(`stage TOOLS from payload → ${join(ctx.lifeosDir, "TOOLS")}`);
-    r.actions.push(`bun ${installer}  (delegates plist materialize + launchctl bootstrap)`);
-    return r;
-  }
-
-  try {
-    if (!existsSync(installer)) ensurePresent("TOOLS", ctx);
-    if (!existsSync(installer)) {
-      r.blockers.push(`installer still missing after staging: ${installer}`);
-      return r;
-    }
-    const out = execFileSync("bun", [installer], { stdio: ["pipe", "pipe", "pipe"], timeout: 60000 }).toString();
-    r.applied = true;
-    // Confirm the job actually loaded, not just that the installer exited 0.
-    const label = component === "worksweep" ? "com.lifeos.worksweep" : "com.lifeos.derivedsync";
-    const loaded = launchctl(["print", `gui/${uid()}/${label}`]).ok;
-    r.probe = { name: `${component}-loaded`, passed: loaded, detail: loaded ? `${label} loaded` : `installer exit 0 but ${label} not loaded: ${out.trim().split("\n").slice(-1)[0]}` };
-  } catch (err) {
-    r.error = err instanceof Error ? err.message : String(err);
-  }
-  return r;
-}
-
 /**
  * Merge a single Claude-Code enhancement key (spinnerTipsOverride / spinnerVerbs)
  * from the shipped `install/settings.enhancements.json` into the user's
@@ -361,16 +280,105 @@ function deployAgents(ctx: Ctx): ComponentResult {
   return r;
 }
 
+// commands mirrors agents exactly: copy the payload's install/commands/ into the
+// user's ~/.claude/commands/, never overwriting. The payload is already filtered
+// at emit time to public commands only (a command ships iff its target skill
+// ships), so there is nothing private-pointing to guard against here.
+function deployCommands(ctx: Ctx): ComponentResult {
+  const r: ComponentResult = { component: "commands", ready: false, actions: [], blockers: [] };
+  const src = join(ctx.installRoot, "commands");
+  const dst = join(ctx.configRoot, "commands");
+  if (!existsSync(src) && !existsSync(dst)) {
+    r.blockers.push(`commands not in payload (${src}) and not already installed (${dst})`);
+    return r;
+  }
+  r.ready = true;
+  if (!ctx.apply) {
+    r.actions.push(existsSync(src) ? `copyMissing commands → ${dst} (never overwrites existing)` : `commands already present at ${dst} — no-op`);
+    return r;
+  }
+  try {
+    if (!existsSync(src)) {
+      r.applied = false;
+      r.probe = { name: "commands-present", passed: true, detail: `already present at ${dst} (no payload to copy)` };
+      return r;
+    }
+    const { copied, failures } = copyMissing(src, dst);
+    r.applied = copied > 0;
+    r.probe = { name: "commands-copied", passed: failures.length === 0 && existsSync(dst), detail: `${copied} command file(s) copied${failures.length ? `, ${failures.length} failed` : ""}` };
+  } catch (err) {
+    r.error = err instanceof Error ? err.message : String(err);
+  }
+  return r;
+}
+
+/**
+ * Delegate launchd service install to Services.ts — single source of truth for all 16 services.
+ * This keeps DeployComponents focused on non-launchd components (settings merges, file copies)
+ * while Services.ts owns the full launchd machinery.
+ */
+function deployViaServices(component: LaunchdComponent, ctx: Ctx): ComponentResult {
+  const r: ComponentResult = { component, ready: false, actions: [], blockers: [] };
+  const servicesTs = join(ctx.lifeosDir, "TOOLS", "Services.ts");
+
+  // Services.ts must be present (either in live tree or staged from payload)
+  const av = availability("TOOLS", ctx);
+  if (!av.inLive && !av.inPayload) {
+    r.blockers.push(`TOOLS not in live tree (${join(ctx.lifeosDir, "TOOLS")}) or payload`);
+    return r;
+  }
+  r.ready = true;
+
+  // Build the label — Services.ts accepts short form (pulse) or full (com.lifeos.pulse)
+  const label = component.startsWith("com.lifeos.") ? component : `com.lifeos.${component}`;
+
+  if (!ctx.apply) {
+    if (!av.inLive) r.actions.push(`stage TOOLS from payload → ${join(ctx.lifeosDir, "TOOLS")}`);
+    r.actions.push(`bun ${servicesTs.replace(ctx.home, "~")} install --only ${component} --yes`);
+    return r;
+  }
+
+  try {
+    ensurePresent("TOOLS", ctx);
+    if (!existsSync(servicesTs)) {
+      r.blockers.push(`Services.ts still missing after staging: ${servicesTs}`);
+      return r;
+    }
+    // Delegate to Services.ts
+    const out = execFileSync("bun", [servicesTs, "install", "--only", component, "--yes"], {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 120000, // some services take longer (e.g. Pulse waits for healthz)
+      cwd: dirname(servicesTs),
+    }).toString();
+    r.applied = true;
+    // Confirm the job actually loaded
+    const loaded = launchctl(["print", `gui/${uid()}/${label}`]).ok;
+    r.probe = { name: `${component}-loaded`, passed: loaded, detail: loaded ? `${label} loaded via Services.ts` : `Services.ts exit 0 but ${label} not loaded: ${out.trim().split("\n").slice(-1)[0]}` };
+  } catch (err) {
+    r.error = err instanceof Error ? err.message : String(err);
+  }
+  return r;
+}
+
+function isLaunchdComponent(c: Component): c is LaunchdComponent {
+  return (LAUNCHD_COMPONENTS as readonly string[]).includes(c);
+}
+
 function deploy(component: Component, ctx: Ctx): ComponentResult {
+  // Non-launchd components: handled directly
   switch (component) {
-    case "pulse": return deployPulse(ctx);
     case "statusline": return deployStatusline(ctx);
     case "tooltips": return deploySettingsKey("tooltips", "spinnerTipsOverride", ctx);
     case "spinnerverbs": return deploySettingsKey("spinnerverbs", "spinnerVerbs", ctx);
     case "agents": return deployAgents(ctx);
-    case "worksweep": return deployLaunchdJob("worksweep", join("TOOLS", "InstallWorkSweep.ts"), ctx);
-    case "derivedsync": return deployLaunchdJob("derivedsync", join("TOOLS", "InstallDerivedSync.ts"), ctx);
+    case "commands": return deployCommands(ctx);
+  }
+  // Launchd components: delegate to Services.ts
+  if (isLaunchdComponent(component)) {
+    return deployViaServices(component, ctx);
   }
+  // Fallback (shouldn't reach here with proper types, but TypeScript wants exhaustiveness)
+  return { component, ready: false, actions: [], blockers: [`unknown component: ${component}`] };
 }
 
 // ── main ─────────────────────────────────────────────────────────────
@@ -417,6 +425,10 @@ function main(): void {
       : join(skillRoot, "install", "LifeOS"),
     installRoot: join(skillRoot, "install"),
     home,
+    // launchd runs the plist with a minimal PATH, so ProgramArguments[0] must be an
+    // absolute bun path. Prefer the interpreter running this installer; fall back to
+    // the standard bun install location.
+    bun: /\/bun$/.test(process.execPath) ? process.execPath : join(home, ".bun", "bin", "bun"),
     launchAgents: join(home, "Library", "LaunchAgents"),
     apply,
   };

LifeOS/Tools/DeployCore.ts

@@ -32,19 +32,18 @@ import { copyMissing, detectDevTree } from "./InstallEngine";
 //  - MEMORY         per-install state, never shipped — but scaffoldMemory() creates the
 //                   empty tree at install so ISASync/hooks/memory writes have a home
 //                   (this is where EmitSkill's "MEMORY scaffolded fresh at setup" becomes true)
-//  - LIFEOS_INSTALL legacy installer engine, not part of the live runtime
 //  - node_modules / .git  never deploy
-// copyMissing's own SKIP_DIRS covers MEMORY/LIFEOS_INSTALL when nested, but these
+// copyMissing's own SKIP_DIRS covers MEMORY when nested, but these
 // are TOP-LEVEL entries of the runtime payload, so we filter them here explicitly.
-const RUNTIME_SKIP = new Set(["USER", "MEMORY", "LIFEOS_INSTALL", "node_modules", ".git"]);
+const RUNTIME_SKIP = new Set(["USER", "MEMORY", "node_modules", ".git"]);
 
 function arg(a: string[], flag: string): string | undefined {
   const i = a.indexOf(flag);
   return i >= 0 && a[i + 1] && !a[i + 1].startsWith("--") ? a[i + 1] : undefined;
 }
 
 interface DeployResult {
-  what: "skills" | "runtime" | "memory";
+  what: "skills" | "runtime" | "memory" | "dependencies";
   src: string;
   dst: string;
   present: boolean;
@@ -132,6 +131,39 @@ function scaffoldMemory(configRoot: string, apply: boolean): DeployResult {
   return r;
 }
 
+/**
+ * (d) shared runtime deps: install/package.json → configRoot/package.json, then
+ * `bun install` in configRoot. Several deployed hooks/TOOLS scripts (e.g.
+ * hooks/lib/identity.ts, LIFEOS/TOOLS/Banner.ts) import npm packages (yaml)
+ * that resolve via node_modules walked up from configRoot — without this step
+ * those scripts throw "Cannot find package" on first run after a fresh install.
+ */
+function deployDependencies(payloadInstall: string, configRoot: string, apply: boolean): DeployResult {
+  const src = join(payloadInstall, "package.json");
+  const dst = join(configRoot, "package.json");
+  const r: DeployResult = { what: "dependencies", src, dst, present: existsSync(src), copied: 0, actions: [], blockers: [], failures: [] };
+  if (!r.present) {
+    r.blockers.push(`dependency manifest missing: ${src} — point --skill-root at a staged release`);
+    return r;
+  }
+  if (!apply) {
+    r.actions.push(`copyMissing ${src} → ${dst}`, `bun install --cwd ${configRoot}`);
+    return r;
+  }
+  const { copied, failures } = copyMissing(src, dst);
+  r.copied = copied;
+  r.failures = failures;
+  if (failures.length === 0) {
+    const proc = Bun.spawnSync(["bun", "install"], { cwd: configRoot, stdout: "pipe", stderr: "pipe" });
+    if (proc.exitCode !== 0) {
+      r.failures.push(`bun install --cwd ${configRoot} exited ${proc.exitCode}: ${proc.stderr.toString().trim()}`);
+    } else {
+      r.actions.push(`bun install --cwd ${configRoot}`);
+    }
+  }
+  return r;
+}
+
 function main(): void {
   const a = process.argv.slice(2);
   const home = process.env.HOME || homedir();
@@ -154,6 +186,7 @@ function main(): void {
     deploySkills(payloadInstall, configRoot, apply),
     deployRuntime(payloadInstall, configRoot, apply),
     scaffoldMemory(configRoot, apply),
+    deployDependencies(payloadInstall, configRoot, apply),
   ];
 
   // A missing required payload source (blocker) or a copy failure is a hard