dreamcontext 0.8.7 → 0.8.8

package/dist/index.js

@@ -22775,6 +22775,19 @@ async function installCoreForPlatform(platform2, projectRoot, manifest) {
   const coreSkillRel = `${skillRootRel}/dreamcontext/SKILL.md`;
   recordIfManifest2(manifest, coreSkillRel, "core");
   installed.push(platformPrefixed(platform2, coreSkillRel));
+  const refsSourceDir = join9(dirname6(skillSource), "references");
+  if (existsSync9(refsSourceDir)) {
+    const refsDestDir = join9(skillDestDir, "references");
+    cpSync2(refsSourceDir, refsDestDir, { recursive: true });
+    const refFiles = readdirSync4(refsSourceDir).filter((f) => f.endsWith(".md"));
+    for (const rf of refFiles) {
+      const refRel = `${skillRootRel}/dreamcontext/references/${rf}`;
+      recordIfManifest2(manifest, refRel, "core");
+    }
+    if (refFiles.length > 0) {
+      installed.push(platformPrefixed(platform2, `${skillRootRel}/dreamcontext/references/ ${source_default.dim(`(${refFiles.length} reference${refFiles.length === 1 ? "" : "s"})`)}`));
+    }
+  }
   const agentsSourceDir = findPackageDir("agents");
   if (agentsSourceDir) {
     const agentFiles = readdirSync4(agentsSourceDir).filter((f) => f.endsWith(".md"));
@@ -29289,6 +29302,548 @@ var init_tech_stack = __esm({
   }
 });
 
+// src/lib/version-check.ts
+import { existsSync as existsSync13, readFileSync as readFileSync14, mkdirSync as mkdirSync8, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname8, join as join13 } from "path";
+import { execFileSync, spawn as spawn2 } from "child_process";
+function cachePath(root) {
+  return join13(root, CACHE_REL_PATH);
+}
+function readVersionCache(root) {
+  const path2 = cachePath(root);
+  if (!existsSync13(path2)) return null;
+  try {
+    const raw = readFileSync14(path2, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    if (typeof parsed.checkedAt !== "number") return null;
+    return {
+      checkedAt: parsed.checkedAt,
+      latestCli: typeof parsed.latestCli === "string" ? parsed.latestCli : null,
+      availablePacks: Array.isArray(parsed.availablePacks) ? parsed.availablePacks.filter((p) => typeof p === "string") : [],
+      ttlHours: typeof parsed.ttlHours === "number" ? parsed.ttlHours : DEFAULT_TTL_HOURS
+    };
+  } catch {
+    return null;
+  }
+}
+function writeVersionCache(root, cache) {
+  const path2 = cachePath(root);
+  try {
+    mkdirSync8(dirname8(path2), { recursive: true });
+    writeFileSync12(path2, JSON.stringify(cache, null, 2) + "\n", "utf-8");
+  } catch {
+  }
+}
+function isCacheFresh(cache, nowMs) {
+  if (!cache) return false;
+  try {
+    if (typeof cache.checkedAt !== "number" || !isFinite(cache.checkedAt)) return false;
+    const ttlHours = typeof cache.ttlHours === "number" && isFinite(cache.ttlHours) && cache.ttlHours > 0 ? cache.ttlHours : DEFAULT_TTL_HOURS;
+    const ttlMs = ttlHours * 60 * 60 * 1e3;
+    const now = nowMs ?? Date.now();
+    return now - cache.checkedAt < ttlMs;
+  } catch {
+    return false;
+  }
+}
+function compareVersions(a, b) {
+  const clean = (v) => v.replace(/[-+].*$/, "").trim();
+  const parseSegments = (v) => clean(v).split(".").map((s) => {
+    const n = parseInt(s, 10);
+    return isFinite(n) ? n : 0;
+  });
+  const segA = parseSegments(a);
+  const segB = parseSegments(b);
+  const len = Math.max(segA.length, segB.length);
+  for (let i = 0; i < len; i++) {
+    const sa = segA[i] ?? 0;
+    const sb = segB[i] ?? 0;
+    if (sa < sb) return -1;
+    if (sa > sb) return 1;
+  }
+  return 0;
+}
+function buildNudge(installedCli, cache, installedPacks, catalogPackNames, opts = {}) {
+  if (!cache || cache.latestCli === null) return null;
+  const cliOutdated = compareVersions(installedCli, cache.latestCli) < 0;
+  const showCliNudge = cliOutdated && !opts.suppressCliNudge;
+  const newPacks = catalogPackNames.filter((p) => !installedPacks.includes(p));
+  const hasNewPacks = newPacks.length > 0;
+  if (!showCliNudge && !hasNewPacks) return null;
+  const lines = ["## Update Available\n"];
+  if (showCliNudge) {
+    lines.push(`- **New version available: v${installedCli} \u2192 v${cache.latestCli}.** A new release can add, update, or remove hooks, prompts, sub-agents, and skills. Run \`dreamcontext upgrade\` to get it, then \`dreamcontext update\` to apply those changes to this project.`);
+  }
+  if (hasNewPacks) {
+    lines.push(`- New skill pack${newPacks.length > 1 ? "s" : ""} available: ${newPacks.join(", ")} \u2014 run \`dreamcontext install-skill --packs\``);
+  }
+  return lines.join("\n");
+}
+function refreshVersionCache(root, opts) {
+  const runner = opts?.runner ?? ((args) => execFileSync("npm", args, {
+    timeout: NPM_TIMEOUT_MS,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  }));
+  const catalogPackNames = opts?.catalogPackNames ?? [];
+  let latestCli = null;
+  try {
+    const raw = runner(["view", "dreamcontext", "version"]);
+    const trimmed = (typeof raw === "string" ? raw : "").trim();
+    if (/^\d+\.\d+/.test(trimmed)) {
+      latestCli = trimmed;
+    }
+  } catch {
+    latestCli = null;
+  }
+  const cache = {
+    checkedAt: Date.now(),
+    latestCli,
+    availablePacks: catalogPackNames,
+    ttlHours: DEFAULT_TTL_HOURS
+  };
+  writeVersionCache(root, cache);
+}
+function markerPath(root) {
+  return join13(root, AUTO_UPGRADE_MARKER_REL_PATH);
+}
+function readAutoUpgradeMarker(root) {
+  const path2 = markerPath(root);
+  if (!existsSync13(path2)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync14(path2, "utf-8"));
+    if (!parsed || typeof parsed !== "object") return null;
+    if (typeof parsed.attemptedFor !== "string" || typeof parsed.at !== "number") return null;
+    return { attemptedFor: parsed.attemptedFor, at: parsed.at };
+  } catch {
+    return null;
+  }
+}
+function writeAutoUpgradeMarker(root, marker) {
+  const path2 = markerPath(root);
+  try {
+    mkdirSync8(dirname8(path2), { recursive: true });
+    writeFileSync12(path2, JSON.stringify(marker, null, 2) + "\n", "utf-8");
+  } catch {
+  }
+}
+function autoUpgradeEnabled(env2 = process.env) {
+  if (env2.DREAMCONTEXT_VERSION_CHECK === "0") return false;
+  return env2.DREAMCONTEXT_AUTO_UPGRADE !== "0";
+}
+function shouldAutoUpgrade(installedCli, cache, env2 = process.env) {
+  if (!autoUpgradeEnabled(env2)) return null;
+  if (!cache || cache.latestCli === null) return null;
+  if (compareVersions(installedCli, cache.latestCli) >= 0) return null;
+  return cache.latestCli;
+}
+function shouldSuppressCliNudge(target, marker, env2 = process.env, now = Date.now()) {
+  if (!autoUpgradeEnabled(env2)) return false;
+  if (!target || !marker) return false;
+  if (marker.attemptedFor !== target) return false;
+  return now - marker.at < AUTO_UPGRADE_INFLIGHT_MS;
+}
+function defaultSpawner(cmd, args) {
+  const child = spawn2(cmd, args, { detached: true, stdio: "ignore" });
+  child.unref();
+}
+function maybeAutoUpgrade(root, installedCli, cache, env2 = process.env, deps = {}) {
+  try {
+    const target = shouldAutoUpgrade(installedCli, cache, env2);
+    if (!target) return null;
+    const now = deps.now ?? Date.now();
+    const readMarker = deps.readMarker ?? readAutoUpgradeMarker;
+    const writeMarker = deps.writeMarker ?? writeAutoUpgradeMarker;
+    const marker = readMarker(root);
+    const recentlyAttempted = marker !== null && marker.attemptedFor === target && now - marker.at < AUTO_UPGRADE_RETRY_MS;
+    if (recentlyAttempted) return null;
+    writeMarker(root, { attemptedFor: target, at: now });
+    const spawner = deps.spawner ?? defaultSpawner;
+    spawner("npm", ["install", "-g", "dreamcontext@latest"]);
+    return `\u2B06 Auto-upgrading dreamcontext v${installedCli} \u2192 v${target} in the background (takes effect next session).`;
+  } catch {
+    return null;
+  }
+}
+var CACHE_REL_PATH, AUTO_UPGRADE_MARKER_REL_PATH, DEFAULT_TTL_HOURS, NPM_TIMEOUT_MS, AUTO_UPGRADE_RETRY_MS, AUTO_UPGRADE_INFLIGHT_MS;
+var init_version_check = __esm({
+  "src/lib/version-check.ts"() {
+    "use strict";
+    CACHE_REL_PATH = "_dream_context/state/.version-check.json";
+    AUTO_UPGRADE_MARKER_REL_PATH = "_dream_context/state/.auto-upgrade.json";
+    DEFAULT_TTL_HOURS = 24;
+    NPM_TIMEOUT_MS = 5e3;
+    AUTO_UPGRADE_RETRY_MS = 24 * 60 * 60 * 1e3;
+    AUTO_UPGRADE_INFLIGHT_MS = 60 * 60 * 1e3;
+  }
+});
+
+// src/cli/commands/app.ts
+import { execFileSync as execFileSync2, spawn as spawnProcess } from "child_process";
+import {
+  existsSync as existsSync14,
+  mkdirSync as mkdirSync9,
+  mkdtempSync,
+  readFileSync as readFileSync15,
+  writeFileSync as writeFileSync13,
+  rmSync as rmSync2,
+  renameSync,
+  readdirSync as readdirSync5
+} from "fs";
+import { homedir, tmpdir } from "os";
+import { join as join14, resolve as resolve3, dirname as dirname9 } from "path";
+import { createHash } from "crypto";
+function detectPlatform(platform2 = process.platform, arch2 = process.arch) {
+  const os3 = platform2 === "darwin" ? "darwin" : platform2 === "win32" ? "win32" : platform2 === "linux" ? "linux" : "other";
+  const a = arch2 === "arm64" ? "aarch64" : arch2 === "x64" ? "x86_64" : "other";
+  return { os: os3, arch: a };
+}
+function pickAssetForArch(assetNames, arch2) {
+  const appAssets = assetNames.filter((n) => n.endsWith(".app.tar.gz"));
+  const exact = appAssets.find((n) => n.includes(`_${arch2}.`));
+  return exact ?? null;
+}
+function defaultInstallDir(home = homedir()) {
+  return join14(home, "Applications");
+}
+function appManifestPath(home = homedir()) {
+  return join14(home, ".dreamcontext", "app.json");
+}
+function readAppManifest(home = homedir()) {
+  const p = appManifestPath(home);
+  if (!existsSync14(p)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync15(p, "utf-8"));
+    if (!parsed || typeof parsed.version !== "string" || typeof parsed.path !== "string") return null;
+    return {
+      version: parsed.version,
+      path: parsed.path,
+      installedAt: typeof parsed.installedAt === "number" ? parsed.installedAt : 0,
+      source: typeof parsed.source === "string" ? parsed.source : "unknown"
+    };
+  } catch {
+    return null;
+  }
+}
+function writeAppManifest(manifest, home = homedir()) {
+  const p = appManifestPath(home);
+  mkdirSync9(dirname9(p), { recursive: true });
+  writeFileSync13(p, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+}
+function run(cmd, args) {
+  execFileSync2(cmd, args, { stdio: ["ignore", "ignore", "pipe"] });
+}
+function runCapture(cmd, args) {
+  return execFileSync2(cmd, args, { encoding: "utf-8" }).toString().trim();
+}
+function validateAppBundle(appDir) {
+  if (!appDir.endsWith(".app") || !existsSync14(appDir)) {
+    throw new Error(`Not a .app bundle: ${appDir}`);
+  }
+  const macos = join14(appDir, "Contents", "MacOS");
+  const plist = join14(appDir, "Contents", "Info.plist");
+  if (!existsSync14(macos) || !existsSync14(plist)) {
+    throw new Error(`Malformed .app (missing Contents/MacOS or Info.plist): ${appDir}`);
+  }
+}
+function readBundleVersion(appDir) {
+  const plist = join14(appDir, "Contents", "Info.plist");
+  try {
+    return runCapture("plutil", ["-extract", "CFBundleShortVersionString", "raw", "-o", "-", plist]) || null;
+  } catch {
+    return null;
+  }
+}
+function findAppInDir(dir) {
+  const entries = readdirSync5(dir).filter((e) => e.endsWith(".app"));
+  return entries.length > 0 ? join14(dir, entries[0]) : null;
+}
+function materializeAppBundle(source, workDir) {
+  const src = resolve3(source);
+  if (!existsSync14(src)) throw new Error(`Source not found: ${src}`);
+  if (src.endsWith(".app")) {
+    return src;
+  }
+  if (src.endsWith(".tar.gz") || src.endsWith(".tgz")) {
+    run("tar", ["-xzf", src, "-C", workDir]);
+  } else if (src.endsWith(".zip")) {
+    run("ditto", ["-x", "-k", src, workDir]);
+  } else {
+    throw new Error(`Unsupported source (expect .app, .tar.gz, or .zip): ${src}`);
+  }
+  const app = findAppInDir(workDir);
+  if (!app) throw new Error(`No .app found inside archive: ${src}`);
+  return app;
+}
+function verifyCodesign(appDir) {
+  try {
+    execFileSync2("codesign", ["--verify", "--deep", appDir], { stdio: ["ignore", "ignore", "ignore"] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isAppRunning() {
+  try {
+    const out = execFileSync2("pgrep", ["-f", `${APP_BUNDLE_NAME}/Contents/MacOS/`], { encoding: "utf-8" }).toString().trim();
+    return out.length > 0;
+  } catch {
+    return false;
+  }
+}
+function installAppBundle(source, opts = {}) {
+  if (detectPlatform().os !== "darwin") {
+    throw new Error("Desktop app install is currently macOS-only.");
+  }
+  const home = opts.home ?? homedir();
+  const installDir = opts.installDir ?? defaultInstallDir(home);
+  mkdirSync9(installDir, { recursive: true });
+  const workDir = mkdtempSync(join14(tmpdir(), "dc-app-"));
+  try {
+    const appDir = materializeAppBundle(source, workDir);
+    validateAppBundle(appDir);
+    const target = join14(installDir, APP_BUNDLE_NAME);
+    const staging = join14(installDir, `.${APP_BUNDLE_NAME}.new-${process.pid}`);
+    const backup = join14(installDir, `.${APP_BUNDLE_NAME}.old-${process.pid}`);
+    rmSync2(staging, { recursive: true, force: true });
+    rmSync2(backup, { recursive: true, force: true });
+    let wasRunning;
+    let replaced;
+    try {
+      run("ditto", [appDir, staging]);
+      try {
+        run("xattr", ["-dr", "com.apple.quarantine", staging]);
+      } catch {
+      }
+      wasRunning = isAppRunning();
+      replaced = existsSync14(target);
+      if (replaced) renameSync(target, backup);
+      renameSync(staging, target);
+    } catch (e) {
+      if (existsSync14(target) === false && existsSync14(backup)) {
+        try {
+          renameSync(backup, target);
+        } catch {
+        }
+      }
+      rmSync2(staging, { recursive: true, force: true });
+      throw e;
+    }
+    rmSync2(backup, { recursive: true, force: true });
+    const version = readBundleVersion(target);
+    writeAppManifest(
+      {
+        version: version ?? "unknown",
+        path: target,
+        installedAt: Date.now(),
+        source: opts.sourceLabel ?? "local"
+      },
+      home
+    );
+    const signatureValid = verifyCodesign(target);
+    return { version, path: target, replaced, wasRunning, signatureValid };
+  } finally {
+    rmSync2(workDir, { recursive: true, force: true });
+  }
+}
+function versionFromTag(tag) {
+  return tag.replace(/^v/, "");
+}
+async function fetchLatestRelease(repo = APP_RELEASE_REPO, fetchImpl = fetch) {
+  try {
+    const res = await fetchImpl(`https://api.github.com/repos/${repo}/releases/latest`, {
+      headers: { Accept: "application/vnd.github+json", "User-Agent": "dreamcontext-cli" }
+    });
+    if (!res.ok) return null;
+    const json = await res.json();
+    if (!json || typeof json.tag_name !== "string" || !Array.isArray(json.assets)) return null;
+    return json;
+  } catch {
+    return null;
+  }
+}
+async function downloadTo(url, destFile, fetchImpl = fetch) {
+  const res = await fetchImpl(url, { headers: { "User-Agent": "dreamcontext-cli" } });
+  if (!res.ok) throw new Error(`Download failed (${res.status}): ${url}`);
+  const buf = Buffer.from(await res.arrayBuffer());
+  writeFileSync13(destFile, buf);
+}
+function sha256File(file) {
+  return createHash("sha256").update(readFileSync15(file)).digest("hex");
+}
+async function downloadLatestArtifact(repo = APP_RELEASE_REPO, fetchImpl = fetch) {
+  const plat = detectPlatform();
+  if (plat.os !== "darwin") return null;
+  const release2 = await fetchLatestRelease(repo, fetchImpl);
+  if (!release2) return null;
+  const assetName = pickAssetForArch(release2.assets.map((a) => a.name), plat.arch);
+  if (!assetName) return null;
+  const asset = release2.assets.find((a) => a.name === assetName);
+  const sumAsset = release2.assets.find((a) => a.name === `${assetName}.sha256`);
+  if (!sumAsset) {
+    throw new Error(
+      `Release ${release2.tag_name} is missing ${assetName}.sha256 \u2014 refusing to install an unverified binary.`
+    );
+  }
+  const workDir = mkdtempSync(join14(tmpdir(), "dc-app-dl-"));
+  try {
+    const archivePath = join14(workDir, assetName);
+    await downloadTo(asset.browser_download_url, archivePath, fetchImpl);
+    const sumFile = join14(workDir, `${assetName}.sha256`);
+    await downloadTo(sumAsset.browser_download_url, sumFile, fetchImpl);
+    const expected = readFileSync15(sumFile, "utf-8").trim().split(/\s+/)[0].toLowerCase();
+    const actual = sha256File(archivePath).toLowerCase();
+    if (!expected || expected !== actual) {
+      throw new Error(`Checksum mismatch for ${assetName}: expected ${expected || "(empty)"}, got ${actual}`);
+    }
+    return { archivePath, version: versionFromTag(release2.tag_name) };
+  } catch (e) {
+    rmSync2(workDir, { recursive: true, force: true });
+    throw e;
+  }
+}
+function appAutoUpdateEnabled(env2 = process.env) {
+  if (env2.DREAMCONTEXT_VERSION_CHECK === "0") return false;
+  return env2.DREAMCONTEXT_APP_AUTO_UPDATE !== "0";
+}
+function defaultAppUpdateSpawner() {
+  const child = spawnProcess(process.execPath, [process.argv[1], "app", "update"], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+}
+function maybeTriggerAppUpdate(env2 = process.env, deps = {}) {
+  try {
+    if (detectPlatform().os !== "darwin") return false;
+    if (!appAutoUpdateEnabled(env2)) return false;
+    const installed = deps.manifest !== void 0 ? deps.manifest : readAppManifest();
+    if (!installed) return false;
+    (deps.spawner ?? defaultAppUpdateSpawner)();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function doInstall(from, dir) {
+  const plat = detectPlatform();
+  if (plat.os !== "darwin") {
+    console.log(source_default.yellow("The desktop app is currently macOS-only. Windows/Linux support is planned."));
+    return;
+  }
+  let tempToClean = null;
+  let source = from;
+  let sourceLabel = "local";
+  if (!source) {
+    console.log(source_default.cyan("Fetching the latest desktop app from GitHub Releases\u2026"));
+    let dl = null;
+    try {
+      dl = await downloadLatestArtifact();
+    } catch (e) {
+      console.log(source_default.red(`Install aborted: ${e.message}`));
+      return;
+    }
+    if (!dl) {
+      console.log(
+        source_default.yellow(
+          "No published desktop release found yet.\nBuild one locally and install it with:  dreamcontext app install --from <path-to.app|.tar.gz>"
+        )
+      );
+      return;
+    }
+    source = dl.archivePath;
+    sourceLabel = "github";
+    tempToClean = dirname9(dl.archivePath);
+  }
+  try {
+    const res = installAppBundle(source, { installDir: dir, sourceLabel });
+    console.log(source_default.green(`\u2713 Installed dreamcontext-beta ${res.version ?? ""}`.trim()) + source_default.dim(` \u2192 ${res.path}`));
+    if (res.signatureValid === false) {
+      console.log(
+        source_default.yellow(
+          "Warning: the installed app failed code-signature verification. It may still launch (ad-hoc),\nbut the published artifact should be properly ad-hoc deep-signed at build time."
+        )
+      );
+    }
+    if (res.wasRunning) {
+      console.log(source_default.yellow("The app is currently running \u2014 restart it to apply the update."));
+    } else {
+      console.log(source_default.dim(`Launch it:  open "${res.path}"`));
+    }
+  } finally {
+    if (tempToClean) rmSync2(tempToClean, { recursive: true, force: true });
+  }
+}
+async function doUpdate(from, dir) {
+  const installed = readAppManifest();
+  if (!installed) {
+    console.log(source_default.dim("No installed app recorded \u2014 running a fresh install."));
+    await doInstall(from, dir);
+    return;
+  }
+  if (from) {
+    await doInstall(from, dir);
+    return;
+  }
+  let dl = null;
+  try {
+    dl = await downloadLatestArtifact();
+  } catch (e) {
+    console.log(source_default.red(`Update aborted: ${e.message}`));
+    return;
+  }
+  if (!dl) {
+    console.log(source_default.yellow("No published desktop release available to update to."));
+    return;
+  }
+  try {
+    if (compareVersions(installed.version, dl.version) >= 0) {
+      console.log(source_default.green(`Desktop app is up to date (${installed.version}).`));
+      return;
+    }
+    const res = installAppBundle(dl.archivePath, { installDir: dir, sourceLabel: "github" });
+    console.log(source_default.green(`\u2713 Updated dreamcontext-beta ${installed.version} \u2192 ${res.version ?? dl.version}`));
+    if (res.wasRunning) console.log(source_default.yellow("Restart the app to apply the update."));
+  } finally {
+    rmSync2(dirname9(dl.archivePath), { recursive: true, force: true });
+  }
+}
+function doStatus() {
+  const installed = readAppManifest();
+  if (!installed) {
+    console.log("Desktop app: not installed (run `dreamcontext app install`).");
+    return;
+  }
+  const onDisk = existsSync14(installed.path);
+  console.log(`Desktop app: ${installed.version}`);
+  console.log(`  path:      ${installed.path}${onDisk ? "" : source_default.red("  (missing!)")}`);
+  console.log(`  source:    ${installed.source}`);
+  console.log(`  running:   ${isAppRunning() ? "yes" : "no"}`);
+}
+function registerAppCommand(program2) {
+  const app = program2.command("app").description("Manage the dreamcontext desktop app (install / update / status)");
+  app.command("install").description("Install the desktop app to ~/Applications (no quarantine, no admin)").option("--from <path>", "Install from a local .app, .tar.gz, or .zip instead of GitHub Releases").option("--dir <dir>", "Install directory (default: ~/Applications)").action(async (opts) => {
+    await doInstall(opts.from, opts.dir);
+  });
+  app.command("update").description("Update the installed desktop app to the latest version").option("--from <path>", "Update from a local artifact instead of GitHub Releases").option("--dir <dir>", "Install directory (default: ~/Applications)").action(async (opts) => {
+    await doUpdate(opts.from, opts.dir);
+  });
+  app.command("status").description("Show the installed desktop app version and state").action(() => {
+    doStatus();
+  });
+}
+var APP_BUNDLE_NAME, APP_RELEASE_REPO;
+var init_app = __esm({
+  "src/cli/commands/app.ts"() {
+    "use strict";
+    init_source();
+    init_version_check();
+    APP_BUNDLE_NAME = "dreamcontext-beta.app";
+    APP_RELEASE_REPO = "meanllbrl/dreamcontext";
+  }
+});
+
 // src/cli/commands/setup.ts
 var setup_exports = {};
 __export(setup_exports, {
@@ -29296,7 +29851,8 @@ __export(setup_exports, {
   registerSetupCommand: () => registerSetupCommand,
   runSetup: () => runSetup
 });
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync15 } from "fs";
+import { execFileSync as execFileSync3 } from "child_process";
 function parsePlatformsOption3(raw) {
   if (!raw) return [];
   const parsed = parsePlatformList(raw);
@@ -29355,6 +29911,38 @@ async function installPlatformIntegration(projectRoot, opts) {
   });
   return { installed, notes, fileCount: Object.keys(manifest.files).length };
 }
+async function maybeInstallApp(opts) {
+  if (opts.skipApp) return;
+  if (process.env.DREAMCONTEXT_INSTALL_NO_APP === "1") return;
+  try {
+    if (detectPlatform().os !== "darwin") return;
+  } catch {
+    return;
+  }
+  const installed = (opts.appInstalledCheck ?? (() => readAppManifest() !== null))();
+  if (installed) {
+    info(source_default.dim("Desktop app already installed \u2014 skipping."));
+    return;
+  }
+  const interactive = process.stdin.isTTY === true && !opts.defaults;
+  let proceed = opts.installApp === true || !!opts.yes && interactive;
+  if (!proceed && interactive) {
+    proceed = await esm_default4({
+      message: "Install the macOS desktop app too? (manage all your vaults in one window)",
+      default: true
+    });
+  }
+  if (!proceed) {
+    info(source_default.dim("Desktop app not installed \u2014 add it anytime with `dreamcontext app install`."));
+    return;
+  }
+  info("Installing the desktop app...");
+  try {
+    (opts.appInstaller ?? (() => execFileSync3("npx", ["dreamcontext", "app", "install"], { stdio: "inherit" })))();
+  } catch (e) {
+    info(source_default.yellow(`Desktop app install skipped: ${e.message}`));
+  }
+}
 async function runSetup(opts) {
   const projectRoot = process.cwd();
   const useDefaults = !!opts.defaults;
@@ -29418,7 +30006,7 @@ async function runSetup(opts) {
       }
     }
     const contextDir = getInitPath();
-    if (!existsSync13(contextDir)) {
+    if (!existsSync15(contextDir)) {
       info("Running init...");
       const { registerInitCommand: registerInitCommand2 } = await Promise.resolve().then(() => (init_init(), init_exports));
       const tempProgram = new Command();
@@ -29438,6 +30026,7 @@ async function runSetup(opts) {
       multiProduct,
       disableNativeMemory
     });
+    await maybeInstallApp(opts);
     const manifestPath2 = "_dream_context/state/.install-manifest.json";
     console.log();
     console.log(miniBox([
@@ -29464,7 +30053,7 @@ async function runSetup(opts) {
   }
 }
 function registerSetupCommand(program2) {
-  program2.command("setup").description("One-shot setup: init + install-skill + install-instructions").option("--defaults", "Skip prompts; use claude platform, no packs, single-product").option("-y, --yes", "Accept all confirmation prompts").option("--platforms <list>", `Comma-separated platforms: ${formatSupportedPlatforms()}`).option("--packs <list>", "Comma-separated pack names to install").option("--multi-product <list>", "Comma-separated product names for multi-product setup").option("--keep-native-memory", "Keep Claude Code's native auto-memory (default: disabled so dreamcontext owns memory)").action(async (opts) => {
+  program2.command("setup").description("One-shot setup: init + install-skill + install-instructions").option("--defaults", "Skip prompts; use claude platform, no packs, single-product").option("-y, --yes", "Accept all confirmation prompts").option("--platforms <list>", `Comma-separated platforms: ${formatSupportedPlatforms()}`).option("--packs <list>", "Comma-separated pack names to install").option("--multi-product <list>", "Comma-separated product names for multi-product setup").option("--keep-native-memory", "Keep Claude Code's native auto-memory (default: disabled so dreamcontext owns memory)").option("--install-app", "Also install the macOS desktop app (non-interactive)").option("--skip-app", "Do not install the desktop app").action(async (opts) => {
     try {
       await runSetup(opts);
     } catch (err) {
@@ -29485,6 +30074,7 @@ var init_setup = __esm({
     init_source();
     init_esm16();
     init_format();
+    init_app();
     init_context_path();
     init_platforms();
     init_install_skill();
@@ -29501,27 +30091,27 @@ var init_exports = {};
 __export(init_exports, {
   registerInitCommand: () => registerInitCommand
 });
-import { existsSync as existsSync14, mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync12, copyFileSync as copyFileSync2, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync10, readFileSync as readFileSync16, writeFileSync as writeFileSync14, copyFileSync as copyFileSync2, readdirSync as readdirSync6, statSync as statSync2 } from "fs";
+import { join as join15 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 function getTemplateDir(subdir = "init") {
   const candidates = [
-    join13(__dirname5, "..", "..", "templates", subdir),
-    join13(__dirname5, "..", "templates", subdir),
-    join13(__dirname5, "templates", subdir)
+    join15(__dirname5, "..", "..", "templates", subdir),
+    join15(__dirname5, "..", "templates", subdir),
+    join15(__dirname5, "templates", subdir)
   ];
   for (const dir of candidates) {
-    if (existsSync14(dir)) return dir;
+    if (existsSync16(dir)) return dir;
   }
-  return join13(__dirname5, "..", "..", "templates", subdir);
+  return join15(__dirname5, "..", "..", "templates", subdir);
 }
 function copyObsidianConfig(destDir) {
   const src = getTemplateDir("obsidian");
-  if (!existsSync14(src)) return false;
-  mkdirSync8(destDir, { recursive: true });
-  for (const entry of readdirSync5(src)) {
-    const from = join13(src, entry);
-    const to = join13(destDir, entry);
+  if (!existsSync16(src)) return false;
+  mkdirSync10(destDir, { recursive: true });
+  for (const entry of readdirSync6(src)) {
+    const from = join15(src, entry);
+    const to = join15(destDir, entry);
     if (statSync2(from).isFile()) {
       copyFileSync2(from, to);
     }
@@ -29538,7 +30128,7 @@ function replaceTokens(content, tokens) {
 function registerInitCommand(program2) {
   program2.command("init").description("Initialize _dream_context/ in the current directory").option("-y, --yes", "Skip prompts and use defaults").option("--name <name>", "Project name").option("--description <desc>", "Project description").option("--user <user>", "Target user").option("--stack <stack>", "Tech stack").option("--priority <priority>", "Current priority").option("--platforms <list>", `Comma-separated platforms: ${formatSupportedPlatforms()}`).option("--multi-product <list>", "Comma-separated product names for monorepos (lowercase kebab-case). Skips the interactive prompt.").action(async (opts) => {
     const contextDir = getInitPath();
-    if (existsSync14(contextDir)) {
+    if (existsSync16(contextDir)) {
       error("_dream_context/ already exists in this directory.");
       return;
     }
@@ -29643,13 +30233,13 @@ function registerInitCommand(program2) {
       PRIORITY: priority,
       DATE: dateStr
     };
-    mkdirSync8(join13(contextDir, "core", "features"), { recursive: true });
-    mkdirSync8(join13(contextDir, "knowledge"), { recursive: true });
-    mkdirSync8(join13(contextDir, "knowledge", "data-structures"), { recursive: true });
-    mkdirSync8(join13(contextDir, "knowledge", "products"), { recursive: true });
-    mkdirSync8(join13(contextDir, "state"), { recursive: true });
-    mkdirSync8(join13(contextDir, "inbox"), { recursive: true });
-    const obsidianInstalled = copyObsidianConfig(join13(contextDir, ".obsidian"));
+    mkdirSync10(join15(contextDir, "core", "features"), { recursive: true });
+    mkdirSync10(join15(contextDir, "knowledge"), { recursive: true });
+    mkdirSync10(join15(contextDir, "knowledge", "data-structures"), { recursive: true });
+    mkdirSync10(join15(contextDir, "knowledge", "products"), { recursive: true });
+    mkdirSync10(join15(contextDir, "state"), { recursive: true });
+    mkdirSync10(join15(contextDir, "inbox"), { recursive: true });
+    const obsidianInstalled = copyObsidianConfig(join15(contextDir, ".obsidian"));
     const templateDir = getTemplateDir();
     const templateFiles = [
       "0.soul.md",
@@ -29659,26 +30249,26 @@ function registerInitCommand(program2) {
       "4.tech_stack.md"
     ];
     for (const file of templateFiles) {
-      const templatePath = join13(templateDir, file);
-      const destPath = join13(contextDir, "core", file);
-      if (existsSync14(templatePath)) {
-        const content = readFileSync14(templatePath, "utf-8");
-        writeFileSync12(destPath, replaceTokens(content, tokens), "utf-8");
+      const templatePath = join15(templateDir, file);
+      const destPath = join15(contextDir, "core", file);
+      if (existsSync16(templatePath)) {
+        const content = readFileSync16(templatePath, "utf-8");
+        writeFileSync14(destPath, replaceTokens(content, tokens), "utf-8");
       } else {
-        writeFileSync12(destPath, `# ${file}
+        writeFileSync14(destPath, `# ${file}
 
 Created: ${dateStr}
 `, "utf-8");
       }
     }
-    const dataStructuresTemplate = join13(templateDir, "data-structures", "default.md");
+    const dataStructuresTemplate = join15(templateDir, "data-structures", "default.md");
     const dataStructuresFallback = "---\nname: {{PRODUCT_NAME}}\ndescription: Data structures for {{PRODUCT_NAME}}\ntype: data-structures\nproduct: {{PRODUCT_NAME}}\ntags:\n  - data-structures\n  - database\n  - schema\nupdated: {{DATE}}\n---\n\n# Data Structures \u2014 {{PRODUCT_NAME}}\n\nDocument schemas, models, and API contracts here.\n";
-    const dsTemplateContent = existsSync14(dataStructuresTemplate) ? readFileSync14(dataStructuresTemplate, "utf-8") : dataStructuresFallback;
+    const dsTemplateContent = existsSync16(dataStructuresTemplate) ? readFileSync16(dataStructuresTemplate, "utf-8") : dataStructuresFallback;
     const productList = multiProduct === false ? ["default"] : multiProduct;
     for (const product of productList) {
       const productTokens = { ...tokens, PRODUCT_NAME: product };
-      const destPath = join13(contextDir, "knowledge", "data-structures", `${product}.md`);
-      writeFileSync12(destPath, replaceTokens(dsTemplateContent, productTokens), "utf-8");
+      const destPath = join15(contextDir, "knowledge", "data-structures", `${product}.md`);
+      writeFileSync14(destPath, replaceTokens(dsTemplateContent, productTokens), "utf-8");
     }
     if (multiProduct !== false) {
       for (const product of multiProduct) {
@@ -29695,12 +30285,12 @@ tags:
 
 Product-scoped knowledge. Cross-cutting findings still go to top-level \`knowledge/\`.
 `;
-        writeFileSync12(join13(contextDir, "knowledge", "products", `${product}.md`), knowledgeStub, "utf-8");
+        writeFileSync14(join15(contextDir, "knowledge", "products", `${product}.md`), knowledgeStub, "utf-8");
       }
     }
     const jsonFiles = ["CHANGELOG.json", "RELEASES.json"];
     for (const file of jsonFiles) {
-      writeFileSync12(join13(contextDir, "core", file), "[]\n", "utf-8");
+      writeFileSync14(join15(contextDir, "core", file), "[]\n", "utf-8");
     }
     ensureTaxonomyFile(contextDir);
     updateSetupConfig(process.cwd(), {
@@ -29709,7 +30299,7 @@ Product-scoped knowledge. Cross-cutting findings still go to top-level \`knowled
       setupVersion: dreamcontextVersion()
     });
     writeProjectPlatformDefaults(process.cwd(), selectedPlatforms);
-    insertToJsonArray(join13(contextDir, "core", "CHANGELOG.json"), {
+    insertToJsonArray(join15(contextDir, "core", "CHANGELOG.json"), {
       date: dateStr,
       type: "chore",
       scope: "project",
@@ -29760,7 +30350,7 @@ Product-scoped knowledge. Cross-cutting findings still go to top-level \`knowled
     }
     const viaSetup = process.env[SETUP_INTERNAL_ENV] === "1";
     const integrationPresent = selectedPlatforms.every(
-      (p) => existsSync14(join13(platformSkillRoot(process.cwd(), p), "dreamcontext", "SKILL.md"))
+      (p) => existsSync16(join15(platformSkillRoot(process.cwd(), p), "dreamcontext", "SKILL.md"))
     );
     let integrationInstalled = false;
     if (!viaSetup && !integrationPresent && !useDefaults && process.stdin.isTTY) {
@@ -29841,14 +30431,14 @@ var init_init = __esm({
 });
 
 // src/lib/release-discovery.ts
-import { join as join14, basename as basename4 } from "path";
-import { existsSync as existsSync15 } from "fs";
+import { join as join16, basename as basename4 } from "path";
+import { existsSync as existsSync17 } from "fs";
 function changelogFingerprint(entry) {
   return `${entry.date}|${entry.type}|${entry.scope}|${entry.description}`;
 }
 function getExistingReleases(root) {
-  const releasesPath = join14(root, "core", "RELEASES.json");
-  if (!existsSync15(releasesPath)) return [];
+  const releasesPath = join16(root, "core", "RELEASES.json");
+  if (!existsSync17(releasesPath)) return [];
   try {
     const entries = readJsonArray(releasesPath);
     for (const entry of entries) {
@@ -29862,8 +30452,8 @@ function getExistingReleases(root) {
 function findUnreleasedTasks(root) {
   const releases = getExistingReleases(root);
   const releasedTaskIds = new Set(releases.flatMap((r) => r.tasks ?? []));
-  const stateDir = join14(root, "state");
-  if (!existsSync15(stateDir)) return [];
+  const stateDir = join16(root, "state");
+  if (!existsSync17(stateDir)) return [];
   const files = import_fast_glob2.default.sync("*.md", { cwd: stateDir, absolute: true });
   const result = [];
   for (const file of files) {
@@ -29884,8 +30474,8 @@ function findUnreleasedTasks(root) {
   return result;
 }
 function findUnreleasedFeatures(root) {
-  const featuresDir = join14(root, "core", "features");
-  if (!existsSync15(featuresDir)) return [];
+  const featuresDir = join16(root, "core", "features");
+  if (!existsSync17(featuresDir)) return [];
   const files = import_fast_glob2.default.sync("*.md", { cwd: featuresDir, absolute: true });
   const result = [];
   for (const file of files) {
@@ -29910,8 +30500,8 @@ function findUnreleasedChangelog(root) {
       releasedFingerprints.add(changelogFingerprint(entry));
     }
   }
-  const changelogPath = join14(root, "core", "CHANGELOG.json");
-  if (!existsSync15(changelogPath)) return [];
+  const changelogPath = join16(root, "core", "CHANGELOG.json");
+  if (!existsSync17(changelogPath)) return [];
   try {
     const entries = readJsonArray(changelogPath);
     const result = [];
@@ -29937,11 +30527,11 @@ var init_release_discovery = __esm({
 });
 
 // src/lib/release-backpopulate.ts
-import { join as join15 } from "path";
-import { existsSync as existsSync16 } from "fs";
+import { join as join17 } from "path";
+import { existsSync as existsSync18 } from "fs";
 function backPopulateFeatures(root, featureIds, version) {
-  const featuresDir = join15(root, "core", "features");
-  if (!existsSync16(featuresDir)) return;
+  const featuresDir = join17(root, "core", "features");
+  if (!existsSync18(featuresDir)) return;
   const files = import_fast_glob3.default.sync("*.md", { cwd: featuresDir, absolute: true });
   const idSet = new Set(featureIds);
   for (const file of files) {
@@ -29969,14 +30559,14 @@ var init_release_backpopulate = __esm({
 });
 
 // src/lib/active-version.ts
-import { existsSync as existsSync17 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync19 } from "fs";
+import { join as join18 } from "path";
 function statePath() {
-  return join16(ensureContextRoot(), "state", ".active-version.json");
+  return join18(ensureContextRoot(), "state", ".active-version.json");
 }
 function getActivePlanningVersion() {
   const path2 = statePath();
-  if (!existsSync17(path2)) return null;
+  if (!existsSync19(path2)) return null;
   let stored;
   try {
     const data = readJsonObject(path2);
@@ -30018,13 +30608,13 @@ var init_active_version = __esm({
 });
 
 // src/cli/commands/core.ts
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 function registerCoreCommand(program2) {
   const core = program2.command("core").description("Add changelog and release entries");
   const changelog = core.command("changelog").description("Manage CHANGELOG.json");
   changelog.command("add").description("Add a changelog entry").option("--type <type>", "Type (feat|fix|refactor|chore|docs|perf|test|change)").option("--scope <scope>", "Scope (e.g., auth, ui, api)").option("--description <desc>", "Description (long-form, full body)").option("--summary <summary>", "Optional \u2264200-char one-liner for snapshot display").option("--references <refs>", "Optional comma-separated references (commit:<sha>, file:<path>, knowledge:<slug>, feature:<slug>, task:<slug>, url:<href>)").option("--authors <list>", 'Optional comma-separated people involved (e.g. "mehmet,ada")').option("--supersedes <key>", 'Optional pointer to prior entry this supersedes (e.g., "2026-05-09|sleep")').option("--breaking", "Mark as a breaking change", false).action(async (opts) => {
     const root = ensureContextRoot();
-    const filePath = join17(root, "core", "CHANGELOG.json");
+    const filePath = join19(root, "core", "CHANGELOG.json");
     const type = opts.type ?? await esm_default11({
       message: "Type:",
       choices: [
@@ -30078,7 +30668,7 @@ function registerCoreCommand(program2) {
   const releases = core.command("releases").description("Manage RELEASES.json");
   releases.command("add").description("Create a release with auto-discovered tasks, features, and changelog entries").option("-V, --ver <version>", "Version string (e.g., 1.2.0)").option("-s, --summary <summary>", "Release summary").option("--status <status>", "Release status: planning or released (default: released)").option("-y, --yes", "Skip interactive selection, include all discovered items").action(async (opts) => {
     const root = ensureContextRoot();
-    const releasesPath = join17(root, "core", "RELEASES.json");
+    const releasesPath = join19(root, "core", "RELEASES.json");
     const auto = !!opts.yes;
     const releaseStatus = opts.status === "planning" ? "planning" : "released";
     const version = opts.ver ?? (auto ? "" : await esm_default5({ message: "Version (e.g., 1.2.0):" }));
@@ -30283,7 +30873,7 @@ var init_core = __esm({
 });
 
 // src/lib/markdown.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync13 } from "fs";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync15 } from "fs";
 function parseSections(content) {
   const lines = content.split("\n");
   const sections = [];
@@ -30311,13 +30901,13 @@ function findSection(sections, sectionName) {
   return sections.find((s) => normalizeName(s.name) === normalized) ?? null;
 }
 function listSections(filePath) {
-  const raw = readFileSync15(filePath, "utf-8");
+  const raw = readFileSync17(filePath, "utf-8");
   const parsed = (0, import_gray_matter3.default)(raw);
   const sections = parseSections(parsed.content);
   return sections.map((s) => s.name);
 }
 function readSection(filePath, sectionName) {
-  const raw = readFileSync15(filePath, "utf-8");
+  const raw = readFileSync17(filePath, "utf-8");
   const parsed = (0, import_gray_matter3.default)(raw);
   const sections = parseSections(parsed.content);
   const section2 = findSection(sections, sectionName);
@@ -30373,7 +30963,7 @@ function stripPlaceholderBody(lines, section2) {
   return originalCount - kept.length;
 }
 function insertToSection(filePath, sectionName, newContent, position = "top", createIfMissing = false, replacePlaceholders = false) {
-  const raw = readFileSync15(filePath, "utf-8");
+  const raw = readFileSync17(filePath, "utf-8");
   const parsed = (0, import_gray_matter3.default)(raw);
   let lines = parsed.content.split("\n");
   let section2 = findSection(parseSections(lines.join("\n")), sectionName);
@@ -30405,7 +30995,7 @@ function insertToSection(filePath, sectionName, newContent, position = "top", cr
     lines.splice(insertAt, 0, ...block);
   }
   const output = import_gray_matter3.default.stringify(lines.join("\n"), parsed.data);
-  writeFileSync13(filePath, output, "utf-8");
+  writeFileSync15(filePath, output, "utf-8");
 }
 function extractMermaidNodes(content) {
   const fence = content.match(/```mermaid\s+([\s\S]*?)```/);
@@ -30609,20 +31199,20 @@ var init_feature_freshness = __esm({
 });
 
 // src/cli/commands/features.ts
-import { existsSync as existsSync18, readFileSync as readFileSync16, writeFileSync as writeFileSync14 } from "fs";
-import { join as join18, basename as basename5 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync18, writeFileSync as writeFileSync16 } from "fs";
+import { join as join20, basename as basename5 } from "path";
 function parseCsv(value) {
   return value.split(",").map((s) => s.trim()).filter(Boolean);
 }
 function getFeaturesDir() {
   const root = ensureContextRoot();
-  return join18(root, "core", "features");
+  return join20(root, "core", "features");
 }
 function findFeatureFile(name) {
   const dir = getFeaturesDir();
   const slug = slugify(name);
-  const exact = join18(dir, `${slug}.md`);
-  if (existsSync18(exact)) return exact;
+  const exact = join20(dir, `${slug}.md`);
+  if (existsSync20(exact)) return exact;
   const files = import_fast_glob4.default.sync("*.md", { cwd: dir, absolute: true });
   const exactGlob = files.find((f) => basename5(f, ".md") === slug);
   if (exactGlob) return exactGlob;
@@ -30642,12 +31232,12 @@ function findFeatureFile(name) {
 }
 function getFeatureTemplate() {
   const candidates = [
-    join18(new URL(".", import.meta.url).pathname, "..", "..", "templates", "feature.md"),
-    join18(new URL(".", import.meta.url).pathname, "..", "templates", "feature.md")
+    join20(new URL(".", import.meta.url).pathname, "..", "..", "templates", "feature.md"),
+    join20(new URL(".", import.meta.url).pathname, "..", "templates", "feature.md")
   ];
   for (const path2 of candidates) {
-    if (existsSync18(path2)) {
-      return readFileSync16(path2, "utf-8");
+    if (existsSync20(path2)) {
+      return readFileSync18(path2, "utf-8");
     }
   }
   return `---
@@ -30695,8 +31285,8 @@ function registerFeaturesCommand(program2) {
   features.command("create").argument("<name>").option("-w, --why <why>", "Why are we building this?").option("-t, --tags <tags>", "Comma-separated tags").option("-s, --status <status>", `Status (${VALID_FEATURE_STATUSES.join(", ")})`).option("--related-tasks <slugs>", "Comma-separated related task slugs").description("Create a new feature document").action(async (name, opts) => {
     const dir = getFeaturesDir();
     const slug = slugify(name);
-    const filePath = join18(dir, `${slug}.md`);
-    if (existsSync18(filePath)) {
+    const filePath = join20(dir, `${slug}.md`);
+    if (existsSync20(filePath)) {
       error(`Feature already exists: ${slug}.md`);
       return;
     }
@@ -30707,7 +31297,7 @@ function registerFeaturesCommand(program2) {
     const why = opts.why || await promptInput({ message: "Why are we building this?" });
     const template = getFeatureTemplate();
     const content = template.replaceAll("{{ID}}", generateId("feat")).replaceAll("{{DATE}}", today()).replaceAll("{{WHY}}", why || "(To be defined)");
-    writeFileSync14(filePath, content, "utf-8");
+    writeFileSync16(filePath, content, "utf-8");
     const fields = {};
     if (opts.tags) fields.tags = parseCsv(opts.tags);
     if (opts.status) fields.status = opts.status;
@@ -30773,8 +31363,8 @@ function registerFeaturesCommand(program2) {
   features.command("doctor").description("Check feature PRDs for staleness, orphans, and dangling task references (read-only)").action(() => {
     const root = ensureContextRoot();
     const featuresDir = getFeaturesDir();
-    const stateDir = join18(root, "state");
-    const featureFiles = existsSync18(featuresDir) ? import_fast_glob4.default.sync("*.md", { cwd: featuresDir, absolute: true }) : [];
+    const stateDir = join20(root, "state");
+    const featureFiles = existsSync20(featuresDir) ? import_fast_glob4.default.sync("*.md", { cwd: featuresDir, absolute: true }) : [];
     const featureRefs = [];
     for (const file of featureFiles) {
       try {
@@ -30789,7 +31379,7 @@ function registerFeaturesCommand(program2) {
       } catch {
       }
     }
-    const taskFiles = existsSync18(stateDir) ? import_fast_glob4.default.sync("*.md", { cwd: stateDir, absolute: true }) : [];
+    const taskFiles = existsSync20(stateDir) ? import_fast_glob4.default.sync("*.md", { cwd: stateDir, absolute: true }) : [];
     const taskRefs = [];
     for (const file of taskFiles) {
       const taskSlug = basename5(file, ".md");
@@ -31067,13 +31657,13 @@ var init_types = __esm({
 });
 
 // src/lib/task-backend/local.ts
-import { existsSync as existsSync19, readFileSync as readFileSync17, rmSync as rmSync2, writeFileSync as writeFileSync15 } from "fs";
-import { basename as basename6, join as join19, resolve as resolve3, sep as sep2 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync19, rmSync as rmSync3, writeFileSync as writeFileSync17 } from "fs";
+import { basename as basename6, join as join21, resolve as resolve4, sep as sep2 } from "path";
 function isSafeTaskSlug(slug) {
   if (!slug || slug.includes("\0")) return false;
-  const base = resolve3(sep2, "dc-slug-check");
-  const target = resolve3(base, `${slug}.md`);
-  return target === join19(base, `${slug}.md`) && target.startsWith(base + sep2);
+  const base = resolve4(sep2, "dc-slug-check");
+  const target = resolve4(base, `${slug}.md`);
+  return target === join21(base, `${slug}.md`) && target.startsWith(base + sep2);
 }
 function hasBacklogTag(tags) {
   return Array.isArray(tags) && tags.some((t) => String(t).toLowerCase() === BACKLOG_TAG);
@@ -31094,12 +31684,12 @@ function normalizeBacklogFields(prev, patch) {
 }
 function getTaskTemplate() {
   const candidates = [
-    join19(new URL(".", import.meta.url).pathname, "..", "..", "templates", "task.md"),
-    join19(new URL(".", import.meta.url).pathname, "..", "templates", "task.md")
+    join21(new URL(".", import.meta.url).pathname, "..", "..", "templates", "task.md"),
+    join21(new URL(".", import.meta.url).pathname, "..", "templates", "task.md")
   ];
   for (const path2 of candidates) {
-    if (existsSync19(path2)) {
-      return readFileSync17(path2, "utf-8");
+    if (existsSync21(path2)) {
+      return readFileSync19(path2, "utf-8");
     }
   }
   return `---
@@ -31233,20 +31823,20 @@ var init_local = __esm({
       }
       name = "local";
       taskPath(slug) {
-        return join19(this.stateDir, `${slug}.md`);
+        return join21(this.stateDir, `${slug}.md`);
       }
       requirePath(slug) {
         if (!isSafeTaskSlug(slug)) {
           throw new TaskBackendError("invalid_input", `Invalid task slug: ${slug}`);
         }
         const path2 = this.taskPath(slug);
-        if (!existsSync19(path2)) {
+        if (!existsSync21(path2)) {
           throw new TaskBackendError("not_found", `Task not found: ${slug}`);
         }
         return path2;
       }
       taskFiles() {
-        if (!existsSync19(this.stateDir)) return [];
+        if (!existsSync21(this.stateDir)) return [];
         return import_fast_glob5.default.sync("*.md", { cwd: this.stateDir, absolute: true });
       }
       async list(filter) {
@@ -31263,7 +31853,7 @@ var init_local = __esm({
       async get(slug) {
         if (!isSafeTaskSlug(slug)) return null;
         const path2 = this.taskPath(slug);
-        if (!existsSync19(path2)) return null;
+        if (!existsSync21(path2)) return null;
         return readTaskFile(path2);
       }
       async create(input2) {
@@ -31275,13 +31865,13 @@ var init_local = __esm({
           throw new TaskBackendError("invalid_input", `Invalid task name: ${input2.name}`);
         }
         const filePath = this.taskPath(slug);
-        if (existsSync19(filePath)) {
+        if (existsSync21(filePath)) {
           throw new TaskBackendError("already_exists", `Task already exists: ${slug}`);
         }
         if (input2.variant === "cli") {
           const template = getTaskTemplate();
           const content = template.replaceAll("{{ID}}", generateId("task")).replaceAll("{{NAME}}", input2.name).replaceAll("{{DESCRIPTION}}", input2.description ?? input2.name).replaceAll("{{PRIORITY}}", input2.priority ?? "medium").replaceAll("{{URGENCY}}", input2.urgency ?? "medium").replaceAll("{{STATUS}}", input2.status ?? "todo").replaceAll("{{TAGS}}", JSON.stringify(input2.tags ?? [])).replaceAll("{{DATE}}", today()).replaceAll("{{WHY}}", input2.why || "(To be defined)").replaceAll("{{VERSION}}", input2.version ? `"${input2.version}"` : "null");
-          writeFileSync15(filePath, content, "utf-8");
+          writeFileSync17(filePath, content, "utf-8");
           if (input2.rice) {
             updateFrontmatterFields(filePath, { rice: input2.rice });
           }
@@ -31345,7 +31935,7 @@ ${input2.why || "(To be defined)"}
 ### ${dateStr} - Created
 - Task created.
 `;
-          writeFileSync15(filePath, content, "utf-8");
+          writeFileSync17(filePath, content, "utf-8");
           if (input2.due_date) {
             updateFrontmatterFields(filePath, { due_date: input2.due_date });
           }
@@ -31376,8 +31966,8 @@ ${input2.why || "(To be defined)"}
           insertToSection(path2, "Changelog", entry, "top");
         } catch (err) {
           if (!opts?.fallbackAppend) throw err;
-          const existing = readFileSync17(path2, "utf-8");
-          writeFileSync15(path2, existing.trimEnd() + "\n\n" + entry + "\n", "utf-8");
+          const existing = readFileSync19(path2, "utf-8");
+          writeFileSync17(path2, existing.trimEnd() + "\n\n" + entry + "\n", "utf-8");
         }
       }
       async complete(slug, summary) {
@@ -31391,11 +31981,11 @@ ${input2.why || "(To be defined)"}
       }
       async delete(slug) {
         const path2 = this.requirePath(slug);
-        rmSync2(path2);
+        rmSync3(path2);
       }
       async resolveSlug(name) {
         const slug = slugify(name);
-        if (existsSync19(this.taskPath(slug))) return { kind: "match", slug };
+        if (existsSync21(this.taskPath(slug))) return { kind: "match", slug };
         const slugs = this.taskFiles().map((f) => basename6(f, ".md"));
         const exact = slugs.find((s) => s === slug);
         if (exact) return { kind: "match", slug: exact };
@@ -31902,14 +32492,14 @@ var init_change_tracker = __esm({
 });
 
 // src/lib/gitignore.ts
-import { existsSync as existsSync20, lstatSync, readFileSync as readFileSync18, writeFileSync as writeFileSync16 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync22, lstatSync, readFileSync as readFileSync20, writeFileSync as writeFileSync18 } from "fs";
+import { join as join22 } from "path";
 function ensureGitignoreEntries(projectRoot, entries, opts) {
-  const path2 = join20(projectRoot, ".gitignore");
-  if (existsSync20(path2) && !lstatSync(path2).isFile()) {
+  const path2 = join22(projectRoot, ".gitignore");
+  if (existsSync22(path2) && !lstatSync(path2).isFile()) {
     throw new Error(`.gitignore at ${path2} is not a regular file`);
   }
-  const current = existsSync20(path2) ? readFileSync18(path2, "utf-8") : "";
+  const current = existsSync22(path2) ? readFileSync20(path2, "utf-8") : "";
   const have = new Set(
     current.split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"))
   );
@@ -31919,7 +32509,7 @@ function ensureGitignoreEntries(projectRoot, entries, opts) {
   if (current.length > 0 && !current.endsWith("\n")) lines.push("");
   if (opts?.comment) lines.push("", `# ${opts.comment}`);
   lines.push(...missing);
-  writeFileSync16(path2, current + lines.join("\n") + "\n", "utf-8");
+  writeFileSync18(path2, current + lines.join("\n") + "\n", "utf-8");
   return missing;
 }
 var init_gitignore = __esm({
@@ -31929,16 +32519,16 @@ var init_gitignore = __esm({
 });
 
 // src/lib/task-backend/secrets.ts
-import { chmodSync, existsSync as existsSync21, mkdirSync as mkdirSync9, readFileSync as readFileSync19, writeFileSync as writeFileSync17 } from "fs";
-import { dirname as dirname8, join as join21 } from "path";
+import { chmodSync, existsSync as existsSync23, mkdirSync as mkdirSync11, readFileSync as readFileSync21, writeFileSync as writeFileSync19 } from "fs";
+import { dirname as dirname10, join as join23 } from "path";
 function secretsPath(projectRoot) {
-  return join21(projectRoot, SECRETS_REL_PATH);
+  return join23(projectRoot, SECRETS_REL_PATH);
 }
 function readSecretsFile(projectRoot) {
   const path2 = secretsPath(projectRoot);
-  if (!existsSync21(path2)) return {};
+  if (!existsSync23(path2)) return {};
   try {
-    const parsed = JSON.parse(readFileSync19(path2, "utf-8"));
+    const parsed = JSON.parse(readFileSync21(path2, "utf-8"));
     if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return {};
     return parsed;
   } catch {
@@ -31959,7 +32549,7 @@ function writeClickUpToken(projectRoot, token, user) {
     );
   }
   const path2 = secretsPath(projectRoot);
-  mkdirSync9(dirname8(path2), { recursive: true });
+  mkdirSync11(dirname10(path2), { recursive: true });
   const secrets = readSecretsFile(projectRoot);
   secrets.clickup = secrets.clickup ?? {};
   if (user && user.trim()) {
@@ -31967,7 +32557,7 @@ function writeClickUpToken(projectRoot, token, user) {
   } else {
     secrets.clickup.token = token.trim();
   }
-  writeFileSync17(path2, JSON.stringify(secrets, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  writeFileSync19(path2, JSON.stringify(secrets, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
   try {
     chmodSync(path2, 384);
   } catch {
@@ -31992,7 +32582,7 @@ function resolveClickUpToken(projectRoot, opts) {
   return null;
 }
 function hasSecretsFile(projectRoot) {
-  return existsSync21(secretsPath(projectRoot));
+  return existsSync23(secretsPath(projectRoot));
 }
 function maskToken(token) {
   const t = token.trim();
@@ -32010,14 +32600,14 @@ var init_secrets = __esm({
 });
 
 // src/lib/task-backend/identity.ts
-import { existsSync as existsSync22, readFileSync as readFileSync20 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync22 } from "fs";
+import { join as join24 } from "path";
 function seedRolesFromTeamOwners(contextRoot) {
-  const path2 = join22(contextRoot, "knowledge", "team_owners.md");
-  if (!existsSync22(path2)) return {};
+  const path2 = join24(contextRoot, "knowledge", "team_owners.md");
+  if (!existsSync24(path2)) return {};
   const roles = {};
   try {
-    const lines = readFileSync20(path2, "utf-8").split("\n");
+    const lines = readFileSync22(path2, "utf-8").split("\n");
     for (const line of lines) {
       const bullet = line.match(/^\s*[-*]\s*([^:|]+):\s*(.+)\s*$/);
       if (bullet) {
@@ -32235,23 +32825,23 @@ var init_paths = __esm({
 });
 
 // src/lib/task-backend/sync-state.ts
-import { createHash } from "crypto";
-import { existsSync as existsSync23, mkdirSync as mkdirSync10, readFileSync as readFileSync21, rmSync as rmSync3, statSync as statSync3, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname9, join as join23 } from "path";
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync25, mkdirSync as mkdirSync12, readFileSync as readFileSync23, rmSync as rmSync4, statSync as statSync3, writeFileSync as writeFileSync20 } from "fs";
+import { dirname as dirname11, join as join25 } from "path";
 function readJson(path2, fallback) {
-  if (!existsSync23(path2)) return fallback;
+  if (!existsSync25(path2)) return fallback;
   try {
-    return JSON.parse(readFileSync21(path2, "utf-8"));
+    return JSON.parse(readFileSync23(path2, "utf-8"));
   } catch {
     return fallback;
   }
 }
 function writeJson(path2, data) {
-  mkdirSync10(dirname9(path2), { recursive: true });
-  writeFileSync18(path2, JSON.stringify(data, null, 2) + "\n", "utf-8");
+  mkdirSync12(dirname11(path2), { recursive: true });
+  writeFileSync20(path2, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
 function hashContent(content) {
-  return createHash("sha256").update(content, "utf-8").digest("hex");
+  return createHash2("sha256").update(content, "utf-8").digest("hex");
 }
 var SyncLedger;
 var init_sync_state = __esm({
@@ -32263,16 +32853,16 @@ var init_sync_state = __esm({
         this.contextRoot = contextRoot;
       }
       get mapPath() {
-        return join23(this.contextRoot, TASKS_MAP_REL);
+        return join25(this.contextRoot, TASKS_MAP_REL);
       }
       get syncPath() {
-        return join23(this.contextRoot, TASKS_SYNC_REL);
+        return join25(this.contextRoot, TASKS_SYNC_REL);
       }
       get queuePath() {
-        return join23(this.contextRoot, TASKS_QUEUE_REL);
+        return join25(this.contextRoot, TASKS_QUEUE_REL);
       }
       conflictsDir() {
-        return join23(this.contextRoot, CONFLICTS_DIR_REL);
+        return join25(this.contextRoot, CONFLICTS_DIR_REL);
       }
       // ── id-map (committed) ──
       readMap() {
@@ -32384,17 +32974,17 @@ var init_sync_state = __esm({
        */
       reset() {
         let backupPath2 = null;
-        if (existsSync23(this.mapPath)) {
+        if (existsSync25(this.mapPath)) {
           backupPath2 = this.mapPath.replace(/\.json$/, `.backup-${Date.now()}.json`);
-          writeFileSync18(backupPath2, readFileSync21(this.mapPath));
-          rmSync3(this.mapPath);
+          writeFileSync20(backupPath2, readFileSync23(this.mapPath));
+          rmSync4(this.mapPath);
         }
-        if (existsSync23(this.syncPath)) rmSync3(this.syncPath);
-        if (existsSync23(this.queuePath)) rmSync3(this.queuePath);
+        if (existsSync25(this.syncPath)) rmSync4(this.syncPath);
+        if (existsSync25(this.queuePath)) rmSync4(this.queuePath);
         return { backupPath: backupPath2 };
       }
       get lockPath() {
-        return join23(this.contextRoot, TASKS_LOCK_REL);
+        return join25(this.contextRoot, TASKS_LOCK_REL);
       }
       /**
        * SYNC LOCK — at most one sync engine per project at a time. Sync fires
@@ -32406,10 +32996,10 @@ var init_sync_state = __esm({
        * (JSON timestamp first, file mtime as the fallback for garbage content).
        */
       acquireSyncLock(nowMs, staleMs) {
-        mkdirSync10(dirname9(this.lockPath), { recursive: true });
+        mkdirSync12(dirname11(this.lockPath), { recursive: true });
         const tryCreate = () => {
           try {
-            writeFileSync18(this.lockPath, JSON.stringify({ pid: process.pid, at: nowMs }) + "\n", { flag: "wx" });
+            writeFileSync20(this.lockPath, JSON.stringify({ pid: process.pid, at: nowMs }) + "\n", { flag: "wx" });
             return true;
           } catch {
             return false;
@@ -32418,7 +33008,7 @@ var init_sync_state = __esm({
         if (tryCreate()) return true;
         let heldSince = null;
         try {
-          const info2 = JSON.parse(readFileSync21(this.lockPath, "utf-8"));
+          const info2 = JSON.parse(readFileSync23(this.lockPath, "utf-8"));
           if (typeof info2.at === "number") heldSince = info2.at;
         } catch {
         }
@@ -32431,14 +33021,14 @@ var init_sync_state = __esm({
         }
         if (nowMs - heldSince <= staleMs) return false;
         try {
-          rmSync3(this.lockPath, { force: true });
+          rmSync4(this.lockPath, { force: true });
         } catch {
         }
         return tryCreate();
       }
       releaseSyncLock() {
         try {
-          rmSync3(this.lockPath, { force: true });
+          rmSync4(this.lockPath, { force: true });
         } catch {
         }
       }
@@ -32450,8 +33040,8 @@ var init_sync_state = __esm({
 });
 
 // src/lib/task-backend/clickup.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync11, readFileSync as readFileSync22, writeFileSync as writeFileSync19 } from "fs";
-import { basename as basename7, dirname as dirname10, join as join24 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync13, readFileSync as readFileSync24, writeFileSync as writeFileSync21 } from "fs";
+import { basename as basename7, dirname as dirname12, join as join26 } from "path";
 function stripPersonTags(tags) {
   return tags.filter((t) => !t.startsWith(PERSON_TAG_PREFIX));
 }
@@ -32556,7 +33146,7 @@ var init_clickup = __esm({
     CLICKUP_MAX_RETRIES = 5;
     ClickUpTaskBackend = class _ClickUpTaskBackend extends LocalTaskBackend {
       constructor(contextRoot, config, deps = {}) {
-        super(join24(contextRoot, "state"));
+        super(join26(contextRoot, "state"));
         this.contextRoot = contextRoot;
         this.config = config;
         this.deps = deps;
@@ -32571,7 +33161,7 @@ var init_clickup = __esm({
         return (this.deps.now ?? Date.now)();
       }
       get projectRoot() {
-        return dirname10(this.contextRoot);
+        return dirname12(this.contextRoot);
       }
       getAdapter() {
         if (this.deps.adapter) return this.deps.adapter;
@@ -32905,7 +33495,7 @@ var init_clickup = __esm({
         for (const file of this.taskFiles()) {
           const slug = basename7(file, ".md");
           const entry = state.tasks[slug];
-          const hash = hashContent(readFileSync22(file, "utf-8"));
+          const hash = hashContent(readFileSync24(file, "utf-8"));
           if (!entry?.localHash || entry.localHash !== hash) candidates.add(slug);
         }
         for (const slug of [...candidates].sort()) {
@@ -32919,7 +33509,7 @@ var init_clickup = __esm({
       }
       async pushTask(slug, adapter, listId, report) {
         const path2 = this.taskPath(slug);
-        if (!existsSync24(path2)) return;
+        if (!existsSync26(path2)) return;
         const task = await super.get(slug);
         const enqueueCutoff = this.nowMs();
         const entry = this.ledger.taskSync(slug);
@@ -33024,7 +33614,7 @@ var init_clickup = __esm({
           serverTime = serverTimeMs(comment.date) ?? serverTime;
           report.commentsAdded++;
         }
-        const raw = readFileSync22(path2, "utf-8");
+        const raw = readFileSync24(path2, "utf-8");
         this.ledger.updateTaskSync(slug, {
           last_synced_at: serverTime ?? entry?.last_synced_at ?? 0,
           base_snapshot: { hash: hashContent(raw), body: raw },
@@ -33112,8 +33702,8 @@ var init_clickup = __esm({
           if (pendingDeletes.has(entry.remoteId)) continue;
           const path2 = this.taskPath(entry.slug);
           try {
-            if (existsSync24(path2)) {
-              const raw = readFileSync22(path2, "utf-8");
+            if (existsSync26(path2)) {
+              const raw = readFileSync24(path2, "utf-8");
               const syncEntry = this.ledger.taskSync(entry.slug);
               const localChanged = !syncEntry?.localHash || hashContent(raw) !== syncEntry.localHash;
               if (localChanged) {
@@ -33165,7 +33755,7 @@ var init_clickup = __esm({
           )
         ].sort();
         let slug = this.ledger.slugForRemoteId(remote.id);
-        if (!slug || !existsSync24(this.taskPath(slug))) {
+        if (!slug || !existsSync26(this.taskPath(slug))) {
           slug = slug ?? this.uniqueSlugFor(remote.name);
           const fm2 = {
             id: generateId("task"),
@@ -33208,7 +33798,7 @@ var init_clickup = __esm({
         }
         const path2 = this.taskPath(slug);
         const entry = this.ledger.taskSync(slug);
-        const localRaw = readFileSync22(path2, "utf-8");
+        const localRaw = readFileSync24(path2, "utf-8");
         const local = await this.getLocal(slug);
         const localChanged = entry?.localHash ? hashContent(localRaw) !== entry.localHash : true;
         const localChangedAt = entry?.lastLocalChangeAt ?? null;
@@ -33420,7 +34010,7 @@ var init_clickup = __esm({
         const baseSlug = slugify(name) || "task";
         let candidate = baseSlug;
         let n = 1;
-        while (existsSync24(this.taskPath(candidate))) {
+        while (existsSync26(this.taskPath(candidate))) {
           n++;
           candidate = `${baseSlug}-${n}`;
         }
@@ -33442,7 +34032,7 @@ ${changelog}` : ""}`;
         const content = this.renderMirror(fm, desc, changelogEntries);
         this.applyingRemote = true;
         try {
-          writeFileSync19(this.taskPath(slug), content, "utf-8");
+          writeFileSync21(this.taskPath(slug), content, "utf-8");
         } finally {
           this.applyingRemote = false;
         }
@@ -33451,15 +34041,15 @@ ${changelog}` : ""}`;
       /** Preserve a losing local copy under state/.conflicts/ — never silent loss. */
       saveConflictCopy(slug, localRaw, remoteTime) {
         const dir = this.ledger.conflictsDir();
-        mkdirSync11(dir, { recursive: true });
+        mkdirSync13(dir, { recursive: true });
         const stamp = remoteTime ?? this.nowMs();
-        let path2 = join24(dir, `${slug}-${stamp}.md`);
+        let path2 = join26(dir, `${slug}-${stamp}.md`);
         let n = 1;
-        while (existsSync24(path2)) {
+        while (existsSync26(path2)) {
           n++;
-          path2 = join24(dir, `${slug}-${stamp}-${n}.md`);
+          path2 = join26(dir, `${slug}-${stamp}-${n}.md`);
         }
-        writeFileSync19(path2, localRaw, "utf-8");
+        writeFileSync21(path2, localRaw, "utf-8");
         return path2;
       }
     };
@@ -33467,8 +34057,8 @@ ${changelog}` : ""}`;
 });
 
 // src/lib/task-backend/git-hooks.ts
-import { chmodSync as chmodSync2, existsSync as existsSync25, readFileSync as readFileSync23, rmSync as rmSync4, writeFileSync as writeFileSync20 } from "fs";
-import { join as join25 } from "path";
+import { chmodSync as chmodSync2, existsSync as existsSync27, readFileSync as readFileSync25, rmSync as rmSync5, writeFileSync as writeFileSync22 } from "fs";
+import { join as join27 } from "path";
 function taskSyncHookScript(cliInvocation) {
   return `#!/bin/sh
 ${MARKER}
@@ -33489,23 +34079,23 @@ function defaultCliInvocation() {
   return `${quote(process.execPath)} ${quote(entry)}`;
 }
 function installTaskSyncHooks(projectRoot, opts = {}) {
-  const hooksDir = join25(projectRoot, ".git", "hooks");
-  if (!existsSync25(join25(projectRoot, ".git"))) {
+  const hooksDir = join27(projectRoot, ".git", "hooks");
+  if (!existsSync27(join27(projectRoot, ".git"))) {
     return { installed: [], skipped: [], noGit: true };
   }
   const script = taskSyncHookScript(opts.cliInvocation ?? defaultCliInvocation());
   const installed = [];
   const skipped = [];
   for (const hook of TASK_SYNC_HOOKS) {
-    const path2 = join25(hooksDir, hook);
-    if (existsSync25(path2)) {
-      const existing = readFileSync23(path2, "utf-8");
+    const path2 = join27(hooksDir, hook);
+    if (existsSync27(path2)) {
+      const existing = readFileSync25(path2, "utf-8");
       if (!existing.includes(MARKER)) {
         skipped.push(hook);
         continue;
       }
     }
-    writeFileSync20(path2, script, "utf-8");
+    writeFileSync22(path2, script, "utf-8");
     try {
       chmodSync2(path2, 493);
     } catch {
@@ -33515,12 +34105,12 @@ function installTaskSyncHooks(projectRoot, opts = {}) {
   return { installed, skipped, noGit: false };
 }
 function uninstallTaskSyncHooks(projectRoot) {
-  const hooksDir = join25(projectRoot, ".git", "hooks");
+  const hooksDir = join27(projectRoot, ".git", "hooks");
   const removed = [];
   for (const hook of TASK_SYNC_HOOKS) {
-    const path2 = join25(hooksDir, hook);
-    if (existsSync25(path2) && readFileSync23(path2, "utf-8").includes(MARKER)) {
-      rmSync4(path2);
+    const path2 = join27(hooksDir, hook);
+    if (existsSync27(path2) && readFileSync25(path2, "utf-8").includes(MARKER)) {
+      rmSync5(path2);
       removed.push(hook);
     }
   }
@@ -33530,8 +34120,8 @@ function hasManagedTaskSyncHooks(projectRoot) {
   return TASK_SYNC_HOOKS.some((hook) => isManagedTaskSyncHook(projectRoot, hook));
 }
 function isManagedTaskSyncHook(projectRoot, hook) {
-  const path2 = join25(projectRoot, ".git", "hooks", hook);
-  return existsSync25(path2) && readFileSync23(path2, "utf-8").includes(MARKER);
+  const path2 = join27(projectRoot, ".git", "hooks", hook);
+  return existsSync27(path2) && readFileSync25(path2, "utf-8").includes(MARKER);
 }
 var MARKER, TASK_SYNC_HOOKS;
 var init_git_hooks = __esm({
@@ -33543,18 +34133,18 @@ var init_git_hooks = __esm({
 });
 
 // src/lib/task-backend/index.ts
-import { existsSync as existsSync26, readdirSync as readdirSync6 } from "fs";
-import { dirname as dirname11, join as join26 } from "path";
+import { existsSync as existsSync28, readdirSync as readdirSync7 } from "fs";
+import { dirname as dirname13, join as join28 } from "path";
 function getTaskBackend(contextRoot, config, deps) {
   const root = contextRoot ?? ensureContextRoot();
-  const cfg = config !== void 0 ? config : readSetupConfig(dirname11(root));
+  const cfg = config !== void 0 ? config : readSetupConfig(dirname13(root));
   if (cfg?.taskBackend === "clickup") {
     return createClickUpBackend(root, cfg ?? null, deps);
   }
-  return new LocalTaskBackend(join26(root, "state"));
+  return new LocalTaskBackend(join28(root, "state"));
 }
 function getTaskSyncStatus(contextRoot, config) {
-  const cfg = config !== void 0 ? config : readSetupConfig(dirname11(contextRoot));
+  const cfg = config !== void 0 ? config : readSetupConfig(dirname13(contextRoot));
   const ledger = new SyncLedger(contextRoot);
   const state = ledger.readSyncState();
   const conflictsDir = ledger.conflictsDir();
@@ -33562,7 +34152,7 @@ function getTaskSyncStatus(contextRoot, config) {
     backend: cfg?.taskBackend ?? "local",
     pendingPush: Object.values(state.tasks).filter((t) => t.pendingPush).length,
     queuedOps: ledger.readQueue().length,
-    conflicts: existsSync26(conflictsDir) ? readdirSync6(conflictsDir).filter((f) => f.endsWith(".md")).length : 0,
+    conflicts: existsSync28(conflictsDir) ? readdirSync7(conflictsDir).filter((f) => f.endsWith(".md")).length : 0,
     watermark: state.watermark
   };
 }
@@ -33583,186 +34173,9 @@ var init_task_backend = __esm({
   }
 });
 
-// src/lib/version-check.ts
-import { existsSync as existsSync27, readFileSync as readFileSync24, mkdirSync as mkdirSync12, writeFileSync as writeFileSync21 } from "fs";
-import { dirname as dirname12, join as join27 } from "path";
-import { execFileSync, spawn as spawn2 } from "child_process";
-function cachePath(root) {
-  return join27(root, CACHE_REL_PATH);
-}
-function readVersionCache(root) {
-  const path2 = cachePath(root);
-  if (!existsSync27(path2)) return null;
-  try {
-    const raw = readFileSync24(path2, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object") return null;
-    if (typeof parsed.checkedAt !== "number") return null;
-    return {
-      checkedAt: parsed.checkedAt,
-      latestCli: typeof parsed.latestCli === "string" ? parsed.latestCli : null,
-      availablePacks: Array.isArray(parsed.availablePacks) ? parsed.availablePacks.filter((p) => typeof p === "string") : [],
-      ttlHours: typeof parsed.ttlHours === "number" ? parsed.ttlHours : DEFAULT_TTL_HOURS
-    };
-  } catch {
-    return null;
-  }
-}
-function writeVersionCache(root, cache) {
-  const path2 = cachePath(root);
-  try {
-    mkdirSync12(dirname12(path2), { recursive: true });
-    writeFileSync21(path2, JSON.stringify(cache, null, 2) + "\n", "utf-8");
-  } catch {
-  }
-}
-function isCacheFresh(cache, nowMs) {
-  if (!cache) return false;
-  try {
-    if (typeof cache.checkedAt !== "number" || !isFinite(cache.checkedAt)) return false;
-    const ttlHours = typeof cache.ttlHours === "number" && isFinite(cache.ttlHours) && cache.ttlHours > 0 ? cache.ttlHours : DEFAULT_TTL_HOURS;
-    const ttlMs = ttlHours * 60 * 60 * 1e3;
-    const now = nowMs ?? Date.now();
-    return now - cache.checkedAt < ttlMs;
-  } catch {
-    return false;
-  }
-}
-function compareVersions(a, b) {
-  const clean = (v) => v.replace(/[-+].*$/, "").trim();
-  const parseSegments = (v) => clean(v).split(".").map((s) => {
-    const n = parseInt(s, 10);
-    return isFinite(n) ? n : 0;
-  });
-  const segA = parseSegments(a);
-  const segB = parseSegments(b);
-  const len = Math.max(segA.length, segB.length);
-  for (let i = 0; i < len; i++) {
-    const sa = segA[i] ?? 0;
-    const sb = segB[i] ?? 0;
-    if (sa < sb) return -1;
-    if (sa > sb) return 1;
-  }
-  return 0;
-}
-function buildNudge(installedCli, cache, installedPacks, catalogPackNames, opts = {}) {
-  if (!cache || cache.latestCli === null) return null;
-  const cliOutdated = compareVersions(installedCli, cache.latestCli) < 0;
-  const showCliNudge = cliOutdated && !opts.suppressCliNudge;
-  const newPacks = catalogPackNames.filter((p) => !installedPacks.includes(p));
-  const hasNewPacks = newPacks.length > 0;
-  if (!showCliNudge && !hasNewPacks) return null;
-  const lines = ["## Update Available\n"];
-  if (showCliNudge) {
-    lines.push(`- **New version available: v${installedCli} \u2192 v${cache.latestCli}.** A new release can add, update, or remove hooks, prompts, sub-agents, and skills. Run \`dreamcontext upgrade\` to get it, then \`dreamcontext update\` to apply those changes to this project.`);
-  }
-  if (hasNewPacks) {
-    lines.push(`- New skill pack${newPacks.length > 1 ? "s" : ""} available: ${newPacks.join(", ")} \u2014 run \`dreamcontext install-skill --packs\``);
-  }
-  return lines.join("\n");
-}
-function refreshVersionCache(root, opts) {
-  const runner = opts?.runner ?? ((args) => execFileSync("npm", args, {
-    timeout: NPM_TIMEOUT_MS,
-    encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
-  }));
-  const catalogPackNames = opts?.catalogPackNames ?? [];
-  let latestCli = null;
-  try {
-    const raw = runner(["view", "dreamcontext", "version"]);
-    const trimmed = (typeof raw === "string" ? raw : "").trim();
-    if (/^\d+\.\d+/.test(trimmed)) {
-      latestCli = trimmed;
-    }
-  } catch {
-    latestCli = null;
-  }
-  const cache = {
-    checkedAt: Date.now(),
-    latestCli,
-    availablePacks: catalogPackNames,
-    ttlHours: DEFAULT_TTL_HOURS
-  };
-  writeVersionCache(root, cache);
-}
-function markerPath(root) {
-  return join27(root, AUTO_UPGRADE_MARKER_REL_PATH);
-}
-function readAutoUpgradeMarker(root) {
-  const path2 = markerPath(root);
-  if (!existsSync27(path2)) return null;
-  try {
-    const parsed = JSON.parse(readFileSync24(path2, "utf-8"));
-    if (!parsed || typeof parsed !== "object") return null;
-    if (typeof parsed.attemptedFor !== "string" || typeof parsed.at !== "number") return null;
-    return { attemptedFor: parsed.attemptedFor, at: parsed.at };
-  } catch {
-    return null;
-  }
-}
-function writeAutoUpgradeMarker(root, marker) {
-  const path2 = markerPath(root);
-  try {
-    mkdirSync12(dirname12(path2), { recursive: true });
-    writeFileSync21(path2, JSON.stringify(marker, null, 2) + "\n", "utf-8");
-  } catch {
-  }
-}
-function autoUpgradeEnabled(env2 = process.env) {
-  if (env2.DREAMCONTEXT_VERSION_CHECK === "0") return false;
-  return env2.DREAMCONTEXT_AUTO_UPGRADE !== "0";
-}
-function shouldAutoUpgrade(installedCli, cache, env2 = process.env) {
-  if (!autoUpgradeEnabled(env2)) return null;
-  if (!cache || cache.latestCli === null) return null;
-  if (compareVersions(installedCli, cache.latestCli) >= 0) return null;
-  return cache.latestCli;
-}
-function shouldSuppressCliNudge(target, marker, env2 = process.env, now = Date.now()) {
-  if (!autoUpgradeEnabled(env2)) return false;
-  if (!target || !marker) return false;
-  if (marker.attemptedFor !== target) return false;
-  return now - marker.at < AUTO_UPGRADE_INFLIGHT_MS;
-}
-function defaultSpawner(cmd, args) {
-  const child = spawn2(cmd, args, { detached: true, stdio: "ignore" });
-  child.unref();
-}
-function maybeAutoUpgrade(root, installedCli, cache, env2 = process.env, deps = {}) {
-  try {
-    const target = shouldAutoUpgrade(installedCli, cache, env2);
-    if (!target) return null;
-    const now = deps.now ?? Date.now();
-    const readMarker = deps.readMarker ?? readAutoUpgradeMarker;
-    const writeMarker = deps.writeMarker ?? writeAutoUpgradeMarker;
-    const marker = readMarker(root);
-    const recentlyAttempted = marker !== null && marker.attemptedFor === target && now - marker.at < AUTO_UPGRADE_RETRY_MS;
-    if (recentlyAttempted) return null;
-    writeMarker(root, { attemptedFor: target, at: now });
-    const spawner = deps.spawner ?? defaultSpawner;
-    spawner("npm", ["install", "-g", "dreamcontext@latest"]);
-    return `\u2B06 Auto-upgrading dreamcontext v${installedCli} \u2192 v${target} in the background (takes effect next session).`;
-  } catch {
-    return null;
-  }
-}
-var CACHE_REL_PATH, AUTO_UPGRADE_MARKER_REL_PATH, DEFAULT_TTL_HOURS, NPM_TIMEOUT_MS, AUTO_UPGRADE_RETRY_MS, AUTO_UPGRADE_INFLIGHT_MS;
-var init_version_check = __esm({
-  "src/lib/version-check.ts"() {
-    "use strict";
-    CACHE_REL_PATH = "_dream_context/state/.version-check.json";
-    AUTO_UPGRADE_MARKER_REL_PATH = "_dream_context/state/.auto-upgrade.json";
-    DEFAULT_TTL_HOURS = 24;
-    NPM_TIMEOUT_MS = 5e3;
-    AUTO_UPGRADE_RETRY_MS = 24 * 60 * 60 * 1e3;
-    AUTO_UPGRADE_INFLIGHT_MS = 60 * 60 * 1e3;
-  }
-});
-
 // src/lib/data-structures-migration.ts
-import { existsSync as existsSync28, mkdirSync as mkdirSync13 } from "fs";
-import { join as join28, basename as basename8 } from "path";
+import { existsSync as existsSync29, mkdirSync as mkdirSync14 } from "fs";
+import { join as join29, basename as basename8 } from "path";
 function enrichDataStructuresFrontmatter(data, product) {
   const existingTags = Array.isArray(data.tags) ? data.tags.map(String) : [];
   const tags = [...existingTags];
@@ -33784,16 +34197,16 @@ function ensureSqlFence(body) {
 }
 function migrateDataStructures(contextRoot) {
   const result = { migrated: [], skipped: [] };
-  const oldDir = join28(contextRoot, OLD_DATA_STRUCTURES_DIR);
-  if (!existsSync28(oldDir)) return result;
+  const oldDir = join29(contextRoot, OLD_DATA_STRUCTURES_DIR);
+  if (!existsSync29(oldDir)) return result;
   const files = import_fast_glob6.default.sync("*.md", { cwd: oldDir, absolute: true });
   if (files.length === 0) return result;
-  const newDir = join28(contextRoot, NEW_DATA_STRUCTURES_DIR);
-  mkdirSync13(newDir, { recursive: true });
+  const newDir = join29(contextRoot, NEW_DATA_STRUCTURES_DIR);
+  mkdirSync14(newDir, { recursive: true });
   for (const oldFile of files) {
     const product = basename8(oldFile, ".md");
-    const newFile = join28(newDir, `${product}.md`);
-    if (existsSync28(newFile)) {
+    const newFile = join29(newDir, `${product}.md`);
+    if (existsSync29(newFile)) {
       result.skipped.push(product);
       continue;
     }
@@ -33804,8 +34217,8 @@ function migrateDataStructures(contextRoot) {
   return result;
 }
 function listUnfencedDataStructures(contextRoot) {
-  const dir = join28(contextRoot, NEW_DATA_STRUCTURES_DIR);
-  if (!existsSync28(dir)) return [];
+  const dir = join29(contextRoot, NEW_DATA_STRUCTURES_DIR);
+  if (!existsSync29(dir)) return [];
   const out = [];
   for (const file of import_fast_glob6.default.sync("*.md", { cwd: dir, absolute: true })) {
     try {
@@ -33817,8 +34230,8 @@ function listUnfencedDataStructures(contextRoot) {
   return out.sort();
 }
 function fenceExistingDataStructures(contextRoot) {
-  const dir = join28(contextRoot, NEW_DATA_STRUCTURES_DIR);
-  if (!existsSync28(dir)) return [];
+  const dir = join29(contextRoot, NEW_DATA_STRUCTURES_DIR);
+  if (!existsSync29(dir)) return [];
   const fenced = [];
   for (const file of import_fast_glob6.default.sync("*.md", { cwd: dir, absolute: true })) {
     try {
@@ -33839,8 +34252,8 @@ var init_data_structures_migration = __esm({
     "use strict";
     import_fast_glob6 = __toESM(require_out4(), 1);
     init_frontmatter();
-    OLD_DATA_STRUCTURES_DIR = join28("core", "data-structures");
-    NEW_DATA_STRUCTURES_DIR = join28("knowledge", "data-structures");
+    OLD_DATA_STRUCTURES_DIR = join29("core", "data-structures");
+    NEW_DATA_STRUCTURES_DIR = join29("knowledge", "data-structures");
     DATA_STRUCTURES_TAGS = ["data-structures", "database", "schema"];
   }
 });
@@ -33892,13 +34305,13 @@ var init__ = __esm({
 
 // src/lib/wikilink-rewrite.ts
 import {
-  existsSync as existsSync29,
-  readFileSync as readFileSync25,
-  writeFileSync as writeFileSync22,
-  renameSync,
-  mkdirSync as mkdirSync14
+  existsSync as existsSync30,
+  readFileSync as readFileSync26,
+  writeFileSync as writeFileSync23,
+  renameSync as renameSync2,
+  mkdirSync as mkdirSync15
 } from "fs";
-import { dirname as dirname13 } from "path";
+import { dirname as dirname14 } from "path";
 function rewriteWikilinks(contextRoot, remaps) {
   if (remaps.length === 0) return [];
   const remapMap = new Map(remaps.map((r) => [r.from, r.to]));
@@ -33911,7 +34324,7 @@ function rewriteWikilinks(contextRoot, remaps) {
   for (const file of files) {
     let content;
     try {
-      content = readFileSync25(file, "utf-8");
+      content = readFileSync26(file, "utf-8");
     } catch {
       continue;
     }
@@ -33919,14 +34332,14 @@ function rewriteWikilinks(contextRoot, remaps) {
     if (rewritten === content) continue;
     const tmp = file + ".wl-tmp";
     try {
-      mkdirSync14(dirname13(tmp), { recursive: true });
-      writeFileSync22(tmp, rewritten, "utf-8");
-      renameSync(tmp, file);
+      mkdirSync15(dirname14(tmp), { recursive: true });
+      writeFileSync23(tmp, rewritten, "utf-8");
+      renameSync2(tmp, file);
       changed.push(file);
     } catch {
       try {
-        if (existsSync29(tmp)) {
-          writeFileSync22(tmp, "");
+        if (existsSync30(tmp)) {
+          writeFileSync23(tmp, "");
         }
       } catch {
       }
@@ -34002,13 +34415,13 @@ var init_wikilink_rewrite = __esm({
 
 // src/lib/diagrams-migration.ts
 import {
-  existsSync as existsSync30,
-  mkdirSync as mkdirSync15,
-  renameSync as renameSync2,
-  readdirSync as readdirSync7,
+  existsSync as existsSync31,
+  mkdirSync as mkdirSync16,
+  renameSync as renameSync3,
+  readdirSync as readdirSync8,
   statSync as statSync4
 } from "fs";
-import { join as join30, resolve as resolve4, sep as sep3 } from "path";
+import { join as join31, resolve as resolve5, sep as sep3 } from "path";
 function isSameBasenameSibling(filename, boardBase) {
   for (const ext of GENERATOR_EXTS) {
     if (filename === `${boardBase}${ext}`) return true;
@@ -34016,9 +34429,9 @@ function isSameBasenameSibling(filename, boardBase) {
   return false;
 }
 function migrateDiagramsToFolders(contextRoot) {
-  const diagramsDir = join30(contextRoot, "knowledge", "diagrams");
+  const diagramsDir = join31(contextRoot, "knowledge", "diagrams");
   const result = { moved: [], skipped: [], ambiguous: [] };
-  if (!existsSync30(diagramsDir)) return result;
+  if (!existsSync31(diagramsDir)) return result;
   const flatFiles = import_fast_glob8.default.sync("*.excalidraw.md", {
     cwd: diagramsDir,
     absolute: false
@@ -34030,13 +34443,13 @@ function migrateDiagramsToFolders(contextRoot) {
   for (const nested of nestedFiles) {
     result.skipped.push(nested.replace(EXCALIDRAW_SUFFIX, ""));
   }
-  const diagramsDirResolved = resolve4(diagramsDir);
+  const diagramsDirResolved = resolve5(diagramsDir);
   for (const filename of flatFiles) {
     const boardBase = filename.slice(0, -EXCALIDRAW_SUFFIX.length);
-    const srcBoard = join30(diagramsDir, filename);
-    const destDir = join30(diagramsDir, boardBase);
-    const destBoard = join30(destDir, filename);
-    if (boardBase === "" || boardBase === "." || boardBase === ".." || boardBase.includes("/") || boardBase.includes("\\") || resolve4(destDir) !== join30(diagramsDirResolved, boardBase) || !resolve4(destDir).startsWith(diagramsDirResolved + sep3)) {
+    const srcBoard = join31(diagramsDir, filename);
+    const destDir = join31(diagramsDir, boardBase);
+    const destBoard = join31(destDir, filename);
+    if (boardBase === "" || boardBase === "." || boardBase === ".." || boardBase.includes("/") || boardBase.includes("\\") || resolve5(destDir) !== join31(diagramsDirResolved, boardBase) || !resolve5(destDir).startsWith(diagramsDirResolved + sep3)) {
       result.ambiguous.push(boardBase);
       continue;
     }
@@ -34044,8 +34457,8 @@ function migrateDiagramsToFolders(contextRoot) {
     const newSlug = `diagrams/${boardBase}/${boardBase}.excalidraw`;
     let siblings = [];
     try {
-      const allInDir = readdirSync7(diagramsDir).filter(
-        (f) => statSync4(join30(diagramsDir, f)).isFile()
+      const allInDir = readdirSync8(diagramsDir).filter(
+        (f) => statSync4(join31(diagramsDir, f)).isFile()
       );
       siblings = allInDir.filter(
         (f) => f !== filename && isSameBasenameSibling(f, boardBase)
@@ -34055,7 +34468,7 @@ function migrateDiagramsToFolders(contextRoot) {
       continue;
     }
     try {
-      mkdirSync15(destDir, { recursive: true });
+      mkdirSync16(destDir, { recursive: true });
     } catch {
       result.ambiguous.push(boardBase);
       continue;
@@ -34063,14 +34476,14 @@ function migrateDiagramsToFolders(contextRoot) {
     const remaps = [{ from: oldSlug, to: newSlug }];
     rewriteWikilinks(contextRoot, remaps);
     try {
-      renameSync2(srcBoard, destBoard);
+      renameSync3(srcBoard, destBoard);
     } catch {
       result.ambiguous.push(boardBase);
       continue;
     }
     for (const sib of siblings) {
       try {
-        renameSync2(join30(diagramsDir, sib), join30(destDir, sib));
+        renameSync3(join31(diagramsDir, sib), join31(destDir, sib));
       } catch {
         result.ambiguous.push(`${boardBase} (sibling: ${sib})`);
       }
@@ -34080,8 +34493,8 @@ function migrateDiagramsToFolders(contextRoot) {
   return result;
 }
 function detectFlatDiagramBoards(contextRoot) {
-  const diagramsDir = join30(contextRoot, "knowledge", "diagrams");
-  if (!existsSync30(diagramsDir)) return [];
+  const diagramsDir = join31(contextRoot, "knowledge", "diagrams");
+  if (!existsSync31(diagramsDir)) return [];
   const flatFiles = import_fast_glob8.default.sync("*.excalidraw.md", {
     cwd: diagramsDir,
     absolute: false
@@ -34131,17 +34544,17 @@ var init__2 = __esm({
 });
 
 // src/lib/vaults.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync16, readFileSync as readFileSync26, writeFileSync as writeFileSync23 } from "fs";
-import { dirname as dirname14, join as join31, resolve as resolve5 } from "path";
-import { homedir } from "os";
-function vaultsFilePath(home = homedir()) {
-  return join31(home, ".dreamcontext", "vaults.json");
+import { existsSync as existsSync32, mkdirSync as mkdirSync17, readFileSync as readFileSync27, writeFileSync as writeFileSync24 } from "fs";
+import { dirname as dirname15, join as join32, resolve as resolve6 } from "path";
+import { homedir as homedir2 } from "os";
+function vaultsFilePath(home = homedir2()) {
+  return join32(home, ".dreamcontext", "vaults.json");
 }
 function listVaults(home) {
   const filePath = vaultsFilePath(home);
-  if (!existsSync31(filePath)) return [];
+  if (!existsSync32(filePath)) return [];
   try {
-    const raw = readFileSync26(filePath, "utf-8");
+    const raw = readFileSync27(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.vaults)) {
       return [];
@@ -34155,15 +34568,15 @@ function listVaults(home) {
   }
 }
 function writeRegistry(filePath, registry) {
-  mkdirSync16(dirname14(filePath), { recursive: true });
-  writeFileSync23(filePath, JSON.stringify(registry, null, 2) + "\n", "utf-8");
+  mkdirSync17(dirname15(filePath), { recursive: true });
+  writeFileSync24(filePath, JSON.stringify(registry, null, 2) + "\n", "utf-8");
 }
 function addVault(name, dirPath, home) {
-  const resolved = resolve5(dirPath);
-  if (!existsSync31(resolved)) {
+  const resolved = resolve6(dirPath);
+  if (!existsSync32(resolved)) {
     throw new VaultError(`Path does not exist: ${resolved}`);
   }
-  if (!existsSync31(join31(resolved, "_dream_context"))) {
+  if (!existsSync32(join32(resolved, "_dream_context"))) {
     throw new VaultError(
       `Path is not a dreamcontext project (no _dream_context/ directory): ${resolved}`
     );
@@ -34173,7 +34586,7 @@ function addVault(name, dirPath, home) {
   if (existing.some((v) => v.name === name)) {
     throw new VaultError(`A vault named "${name}" is already registered.`);
   }
-  if (existing.some((v) => resolve5(v.path) === resolved)) {
+  if (existing.some((v) => resolve6(v.path) === resolved)) {
     throw new VaultError(`Path is already registered: ${resolved}`);
   }
   const vault = { name, path: resolved };
@@ -34181,19 +34594,19 @@ function addVault(name, dirPath, home) {
   writeRegistry(filePath, registry);
   return vault;
 }
-function resolveVaultContextRoot(arg, home = homedir()) {
+function resolveVaultContextRoot(arg, home = homedir2()) {
   const vaults = listVaults(home);
   const named = vaults.find((v) => v.name === arg);
-  const resolved = named ? named.path : resolve5(arg);
-  if (!existsSync31(resolved)) {
+  const resolved = named ? named.path : resolve6(arg);
+  if (!existsSync32(resolved)) {
     throw new VaultError(`Vault path does not exist: ${resolved}`);
   }
-  if (!existsSync31(join31(resolved, "_dream_context"))) {
+  if (!existsSync32(join32(resolved, "_dream_context"))) {
     throw new VaultError(
       `Path is not a dreamcontext project (no _dream_context/ directory): ${resolved}`
     );
   }
-  return join31(resolved, "_dream_context");
+  return join32(resolved, "_dream_context");
 }
 function removeVault(name, home) {
   const existing = listVaults(home);
@@ -34218,11 +34631,11 @@ var init_vaults = __esm({
 });
 
 // src/lib/connections.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync17, readFileSync as readFileSync27, renameSync as renameSync3, writeFileSync as writeFileSync24 } from "fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync18, readFileSync as readFileSync28, renameSync as renameSync4, writeFileSync as writeFileSync25 } from "fs";
 import { randomBytes } from "crypto";
-import { dirname as dirname15, join as join32, resolve as resolve6 } from "path";
+import { dirname as dirname16, join as join33, resolve as resolve7 } from "path";
 function connectionsPath(contextRoot) {
-  return join32(contextRoot, CONNECTIONS_REL_PATH);
+  return join33(contextRoot, CONNECTIONS_REL_PATH);
 }
 function emptyFile() {
   return { version: 1, connections: [] };
@@ -34242,9 +34655,9 @@ function sanitizeConnection(raw) {
 }
 function readConnections(contextRoot) {
   const path2 = connectionsPath(contextRoot);
-  if (!existsSync32(path2)) return emptyFile();
+  if (!existsSync33(path2)) return emptyFile();
   try {
-    const parsed = JSON.parse(readFileSync27(path2, "utf-8"));
+    const parsed = JSON.parse(readFileSync28(path2, "utf-8"));
     if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.connections)) {
       return emptyFile();
     }
@@ -34257,10 +34670,10 @@ function readConnections(contextRoot) {
 }
 function writeConnections(contextRoot, file) {
   const path2 = connectionsPath(contextRoot);
-  mkdirSync17(dirname15(path2), { recursive: true });
+  mkdirSync18(dirname16(path2), { recursive: true });
   const tmp = `${path2}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
-  writeFileSync24(tmp, JSON.stringify(file, null, 2) + "\n", "utf-8");
-  renameSync3(tmp, path2);
+  writeFileSync25(tmp, JSON.stringify(file, null, 2) + "\n", "utf-8");
+  renameSync4(tmp, path2);
 }
 function listConnections(contextRoot) {
   return readConnections(contextRoot).connections;
@@ -34280,7 +34693,7 @@ function addConnection(contextRoot, currentVaultName3, peer, direction, topics,
     throw new VaultError(`Unknown vault "${peer}" \u2014 register it first with \`dreamcontext vaults add\`.`);
   }
   const peerRoot = resolveVaultContextRoot(peer, home);
-  if (resolve6(peerRoot) === resolve6(contextRoot)) {
+  if (resolve7(peerRoot) === resolve7(contextRoot)) {
     throw new VaultError("A vault cannot connect to itself.");
   }
   const file = readConnections(contextRoot);
@@ -34320,11 +34733,11 @@ var init_connections = __esm({
 });
 
 // src/server/safe-path.ts
-import { resolve as resolve7, sep as sep4 } from "path";
+import { resolve as resolve8, sep as sep4 } from "path";
 function safeChildPath2(baseDir, child) {
   if (!child || child.includes("\0")) return null;
-  const base = resolve7(baseDir);
-  const target = resolve7(base, child);
+  const base = resolve8(baseDir);
+  const target = resolve8(base, child);
   if (target !== base && !target.startsWith(base + sep4)) return null;
   return target;
 }
@@ -34336,22 +34749,22 @@ var init_safe_path = __esm({
 
 // src/lib/federation-inbox.ts
 import {
-  existsSync as existsSync33,
-  mkdirSync as mkdirSync18,
-  readFileSync as readFileSync28,
-  readdirSync as readdirSync8,
-  renameSync as renameSync4,
-  writeFileSync as writeFileSync25
+  existsSync as existsSync34,
+  mkdirSync as mkdirSync19,
+  readFileSync as readFileSync29,
+  readdirSync as readdirSync9,
+  renameSync as renameSync5,
+  writeFileSync as writeFileSync26
 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 function inboxDir(contextRoot) {
-  return join33(contextRoot, INBOX_REL);
+  return join34(contextRoot, INBOX_REL);
 }
 function consumedDir(contextRoot) {
-  return join33(inboxDir(contextRoot), CONSUMED_DIRNAME);
+  return join34(inboxDir(contextRoot), CONSUMED_DIRNAME);
 }
 function ensureInbox(contextRoot) {
-  mkdirSync18(consumedDir(contextRoot), { recursive: true });
+  mkdirSync19(consumedDir(contextRoot), { recursive: true });
 }
 function majorOf(version) {
   return Math.floor(Number.isFinite(version) ? version : 0);
@@ -34364,19 +34777,19 @@ function isDigestEntry(raw) {
 function drainInbox(contextRoot) {
   const dir = inboxDir(contextRoot);
   const result = { entries: [], quarantined: [] };
-  if (!existsSync33(dir)) return result;
+  if (!existsSync34(dir)) return result;
   let files;
   try {
-    files = readdirSync8(dir).filter((f) => f.endsWith(".json"));
+    files = readdirSync9(dir).filter((f) => f.endsWith(".json"));
   } catch (err) {
     console.error(`[dreamcontext] federation: cannot read inbox at ${dir}: ${String(err)}`);
     return result;
   }
   for (const file of files) {
-    const path2 = join33(dir, file);
+    const path2 = join34(dir, file);
     let entry;
     try {
-      const parsed = JSON.parse(readFileSync28(path2, "utf-8"));
+      const parsed = JSON.parse(readFileSync29(path2, "utf-8"));
       if (!isDigestEntry(parsed)) {
         console.error(`[dreamcontext] federation: skipping malformed inbox entry "${file}".`);
         continue;
@@ -34401,9 +34814,9 @@ function drainInbox(contextRoot) {
 }
 function pendingInboxCount(contextRoot) {
   const dir = inboxDir(contextRoot);
-  if (!existsSync33(dir)) return 0;
+  if (!existsSync34(dir)) return 0;
   try {
-    return readdirSync8(dir, { withFileTypes: true }).filter(
+    return readdirSync9(dir, { withFileTypes: true }).filter(
       (d) => d.isFile() && d.name.endsWith(".json")
     ).length;
   } catch {
@@ -34412,17 +34825,17 @@ function pendingInboxCount(contextRoot) {
 }
 function listConsumedEntries(contextRoot) {
   const dir = consumedDir(contextRoot);
-  if (!existsSync33(dir)) return [];
+  if (!existsSync34(dir)) return [];
   let files;
   try {
-    files = readdirSync8(dir).filter((f) => f.endsWith(".json"));
+    files = readdirSync9(dir).filter((f) => f.endsWith(".json"));
   } catch {
     return [];
   }
   const out = [];
   for (const file of files) {
     try {
-      const parsed = JSON.parse(readFileSync28(join33(dir, file), "utf-8"));
+      const parsed = JSON.parse(readFileSync29(join34(dir, file), "utf-8"));
       if (isDigestEntry(parsed)) out.push(parsed);
     } catch {
     }
@@ -34435,14 +34848,14 @@ var init_federation_inbox = __esm({
     "use strict";
     init_safe_path();
     DIGEST_SCHEMA_VERSION = 1;
-    INBOX_REL = join33("state", ".federation-inbox");
+    INBOX_REL = join34("state", ".federation-inbox");
     CONSUMED_DIRNAME = "consumed";
   }
 });
 
 // src/migrations/0.8.0.ts
-import { existsSync as existsSync34 } from "fs";
-import { dirname as dirname16, join as join34 } from "path";
+import { existsSync as existsSync35 } from "fs";
+import { dirname as dirname17, join as join35 } from "path";
 var migration080;
 var init__3 = __esm({
   "src/migrations/0.8.0.ts"() {
@@ -34454,16 +34867,16 @@ var init__3 = __esm({
       version: "0.8.0",
       steps: [
         (root) => {
-          const projectRoot = dirname16(root);
+          const projectRoot = dirname17(root);
           const filesTouched = [];
           const connPath = connectionsPath(root);
-          if (!existsSync34(connPath)) {
+          if (!existsSync35(connPath)) {
             writeConnections(root, { version: 1, connections: [] });
             filesTouched.push("state/.connections.json");
           } else {
             readConnections(root);
           }
-          const inboxExisted = existsSync34(consumedDir(root));
+          const inboxExisted = existsSync35(consumedDir(root));
           ensureInbox(root);
           if (!inboxExisted) {
             filesTouched.push("state/.federation-inbox/", "state/.federation-inbox/consumed/");
@@ -34479,7 +34892,7 @@ var init__3 = __esm({
           const summary = detected ? "Federation already scaffolded (.connections.json + .federation-inbox/ present, shareable set) \u2014 nothing to do." : `Scaffolded federation: ${filesTouched.join(", ")}` + (shareableTouched ? "" : cfg ? " (shareable already set \u2014 preserved)" : "");
           return {
             step: "scaffold-federation",
-            filesTouched: filesTouched.map((f) => join34(root, f.split(" ")[0])),
+            filesTouched: filesTouched.map((f) => join35(root, f.split(" ")[0])),
             summary,
             detected
           };
@@ -34509,21 +34922,21 @@ var init_migrations = __esm({
 
 // src/lib/migration-ledger.ts
 import {
-  existsSync as existsSync35,
-  mkdirSync as mkdirSync19,
-  readFileSync as readFileSync29,
-  writeFileSync as writeFileSync26,
-  renameSync as renameSync5
+  existsSync as existsSync36,
+  mkdirSync as mkdirSync20,
+  readFileSync as readFileSync30,
+  writeFileSync as writeFileSync27,
+  renameSync as renameSync6
 } from "fs";
-import { dirname as dirname17, join as join35 } from "path";
+import { dirname as dirname18, join as join36 } from "path";
 function ledgerPath(contextRoot) {
-  return join35(contextRoot, LEDGER_REL_PATH);
+  return join36(contextRoot, LEDGER_REL_PATH);
 }
 function readLedger(contextRoot) {
   const path2 = ledgerPath(contextRoot);
-  if (!existsSync35(path2)) return [];
+  if (!existsSync36(path2)) return [];
   try {
-    const raw = readFileSync29(path2, "utf-8");
+    const raw = readFileSync30(path2, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) return [];
     return parsed;
@@ -34534,9 +34947,9 @@ function readLedger(contextRoot) {
 function writeLedger(contextRoot, entries) {
   const path2 = ledgerPath(contextRoot);
   const tmp = path2 + ".tmp";
-  mkdirSync19(dirname17(path2), { recursive: true });
-  writeFileSync26(tmp, JSON.stringify(entries, null, 2) + "\n", "utf-8");
-  renameSync5(tmp, path2);
+  mkdirSync20(dirname18(path2), { recursive: true });
+  writeFileSync27(tmp, JSON.stringify(entries, null, 2) + "\n", "utf-8");
+  renameSync6(tmp, path2);
 }
 function appendLedger(contextRoot, entry) {
   const entries = readLedger(contextRoot);
@@ -34556,8 +34969,8 @@ var init_migration_ledger = __esm({
 });
 
 // src/lib/migration-runner.ts
-import { existsSync as existsSync36 } from "fs";
-import { join as join36 } from "path";
+import { existsSync as existsSync37 } from "fs";
+import { join as join37 } from "path";
 function runMigrations(contextRoot, fromVersion, toVersion) {
   if (compareVersions(toVersion, fromVersion) < 0) {
     return { applied: [], pendingAgentTasks: [] };
@@ -34588,8 +35001,8 @@ function runMigrations(contextRoot, fromVersion, toVersion) {
       applied.push(entry);
     }
   }
-  const changelogPath = join36(contextRoot, "core", "CHANGELOG.json");
-  if (existsSync36(changelogPath)) {
+  const changelogPath = join37(contextRoot, "core", "CHANGELOG.json");
+  if (existsSync37(changelogPath)) {
     const codeByVersion = /* @__PURE__ */ new Map();
     for (const entry of applied) {
       if (entry.executor === "code") {
@@ -34808,13 +35221,13 @@ var init_sleep_consolidation = __esm({
 });
 
 // src/cli/commands/sleep.ts
-import { existsSync as existsSync37 } from "fs";
-import { join as join37, dirname as dirname18 } from "path";
+import { existsSync as existsSync38 } from "fs";
+import { join as join38, dirname as dirname19 } from "path";
 function getSleepPath(root) {
-  return join37(root, "state", ".sleep.json");
+  return join38(root, "state", ".sleep.json");
 }
 function getSleepHistoryPath(root) {
-  return join37(root, "state", ".sleep-history.json");
+  return join38(root, "state", ".sleep-history.json");
 }
 function freshDefaults() {
   return {
@@ -34836,7 +35249,7 @@ function freshDefaults() {
 }
 function readSleepState(root) {
   const filePath = getSleepPath(root);
-  if (!existsSync37(filePath)) {
+  if (!existsSync38(filePath)) {
     return freshDefaults();
   }
   try {
@@ -34845,7 +35258,7 @@ function readSleepState(root) {
       const historyPath = getSleepHistoryPath(root);
       let existing = [];
       try {
-        if (existsSync37(historyPath)) {
+        if (existsSync38(historyPath)) {
           existing = readJsonArray(historyPath);
         }
       } catch {
@@ -34872,7 +35285,7 @@ function readSleepState(root) {
 }
 function readSleepHistory(root) {
   const filePath = getSleepHistoryPath(root);
-  if (!existsSync37(filePath)) return [];
+  if (!existsSync38(filePath)) return [];
   try {
     return readJsonArray(filePath);
   } catch {
@@ -34965,7 +35378,7 @@ function registerSleepCommand(program2) {
     const decision = consolidationDepth(state.debt, { userRequestedDeep: !!opts.deep });
     state.consolidation_depth = decision.depth;
     state.pendingMigrationNotices = [];
-    const projectRoot = dirname18(root);
+    const projectRoot = dirname19(root);
     const config = readSetupConfig(projectRoot);
     const fromVersion = config?.setupVersion ?? "0.0.0";
     const migResult = runMigrations(root, fromVersion, dreamcontextVersion());
@@ -35119,19 +35532,19 @@ var init_sleep = __esm({
 });
 
 // src/cli/commands/knowledge.ts
-import { existsSync as existsSync38 } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync39 } from "fs";
+import { join as join39 } from "path";
 function getKnowledgeDir() {
   const root = ensureContextRoot();
-  return join38(root, "knowledge");
+  return join39(root, "knowledge");
 }
 function registerKnowledgeCommand(program2) {
   const knowledge = program2.command("knowledge").description("Create and index knowledge files");
   knowledge.command("create").argument("<name>").option("-d, --description <desc>", "Description").option("-t, --tags <tags>", "Tags (comma-separated)").option("-c, --content <content>", "Content body").description("Create a new knowledge file").action(async (name, opts) => {
     const dir = getKnowledgeDir();
     const slug = slugify(name);
-    const filePath = join38(dir, `${slug}.md`);
-    if (existsSync38(filePath)) {
+    const filePath = join39(dir, `${slug}.md`);
+    if (existsSync39(filePath)) {
       error(`Knowledge file already exists: ${slug}.md`);
       return;
     }
@@ -35206,8 +35619,8 @@ ${content || "(Content to be added)"}
   });
   knowledge.command("touch").argument("<slug>", "Knowledge file slug").description("Record access to a knowledge file (for decay tracking)").action((slug) => {
     const root = ensureContextRoot();
-    const knowledgePath2 = join38(root, "knowledge", `${slug}.md`);
-    if (!existsSync38(knowledgePath2)) {
+    const knowledgePath2 = join39(root, "knowledge", `${slug}.md`);
+    if (!existsSync39(knowledgePath2)) {
       error(`Knowledge file not found: ${slug}.md`);
       return;
     }
@@ -35232,10 +35645,10 @@ var init_knowledge = __esm({
 });
 
 // src/cli/commands/tasks.ts
-import { join as join39, basename as basename10, dirname as dirname19 } from "path";
+import { join as join40, basename as basename10, dirname as dirname20 } from "path";
 function getStateDir() {
   const root = ensureContextRoot();
-  return join39(root, "state");
+  return join40(root, "state");
 }
 function collectOption(value, previous) {
   return previous.concat(value);
@@ -35374,7 +35787,7 @@ function registerTasksCommand(program2) {
     const description = opts.description || name;
     const tags = opts.tags ? opts.tags.split(",").map((t) => t.trim()).filter(Boolean) : [];
     if (opts.person && opts.person.trim()) {
-      const projectRoot = dirname19(ensureContextRoot());
+      const projectRoot = dirname20(ensureContextRoot());
       if (isMultiPerson(readSetupConfig(projectRoot))) {
         const personTag = `person:${slugify(opts.person)}`;
         if (!tags.includes(personTag)) tags.push(personTag);
@@ -35726,7 +36139,7 @@ function registerTasksCommand(program2) {
     }
   });
   tasks.command("sync-hooks").argument("<action>", "install | uninstall").description("Install/uninstall best-effort git sync triggers (post-commit, pre-push)").action((action) => {
-    const projectRoot = dirname19(ensureContextRoot());
+    const projectRoot = dirname20(ensureContextRoot());
     if (action === "install") {
       const res = installTaskSyncHooks(projectRoot);
       if (res.noGit) {
@@ -35754,7 +36167,7 @@ function registerTasksCommand(program2) {
       const backend = getTaskBackend();
       const slug = await resolveTaskSlug(backend, name);
       if (!slug) return;
-      files = [join39(dir, `${slug}.md`)];
+      files = [join40(dir, `${slug}.md`)];
     } else {
       files = import_fast_glob9.default.sync("*.md", { cwd: dir, absolute: true });
     }
@@ -35842,8 +36255,8 @@ var init_tasks = __esm({
 });
 
 // src/cli/commands/update.ts
-import { existsSync as existsSync39, readdirSync as readdirSync9, rmSync as rmSync5 } from "fs";
-import { join as join40 } from "path";
+import { existsSync as existsSync40, readdirSync as readdirSync10, rmSync as rmSync6 } from "fs";
+import { join as join41 } from "path";
 function buildUpdateSummary(input2) {
   const { platforms, installedCount, packs, removed, setupVersion } = input2;
   const lines = ["## Update Summary\n"];
@@ -35866,7 +36279,7 @@ function buildUpdateSummary(input2) {
 }
 function detectInstalledPlatforms(projectRoot) {
   return SUPPORTED_PLATFORMS.filter(
-    (p) => existsSync39(join40(platformSkillRoot(projectRoot, p), "dreamcontext", "SKILL.md"))
+    (p) => existsSync40(join41(platformSkillRoot(projectRoot, p), "dreamcontext", "SKILL.md"))
   );
 }
 function detectInstalledPacks(projectRoot, platforms) {
@@ -35879,11 +36292,11 @@ function detectInstalledPacks(projectRoot, platforms) {
   const found = /* @__PURE__ */ new Set();
   for (const platform2 of platforms) {
     const root = platformSkillRoot(projectRoot, platform2);
-    if (!existsSync39(root)) continue;
-    for (const name of readdirSync9(root)) {
+    if (!existsSync40(root)) continue;
+    for (const name of readdirSync10(root)) {
       if (name === "dreamcontext") continue;
       if (!knownNames.has(name)) continue;
-      if (existsSync39(join40(root, name, "SKILL.md"))) found.add(name);
+      if (existsSync40(join41(root, name, "SKILL.md"))) found.add(name);
     }
   }
   return [...found].sort();
@@ -35933,9 +36346,9 @@ async function pruneStaleFiles(projectRoot, oldManifest, newManifest, isFirstRun
   }
   const removed = [];
   for (const rel of owned) {
-    const abs = join40(projectRoot, rel);
+    const abs = join41(projectRoot, rel);
     try {
-      rmSync5(abs, { force: true });
+      rmSync6(abs, { force: true });
       removed.push(rel);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
@@ -36026,7 +36439,7 @@ function registerUpdateCommand(program2) {
         const ver = dreamcontextVersion();
         updateSetupConfig(projectRoot, { setupVersion: ver });
         newSetupVersion = ver;
-        const ctxRoot = join40(projectRoot, "_dream_context");
+        const ctxRoot = join41(projectRoot, "_dream_context");
         const migResult = runMigrations(ctxRoot, fromVersion, ver);
         if (migResult.applied.length > 0) {
           const codeApplied = migResult.applied.filter(
@@ -36085,11 +36498,11 @@ var init_update = __esm({
 });
 
 // src/lib/core-index.ts
-import { existsSync as existsSync40 } from "fs";
-import { join as join41, basename as basename11 } from "path";
+import { existsSync as existsSync41 } from "fs";
+import { join as join42, basename as basename11 } from "path";
 function buildCoreIndex(contextRoot) {
-  const coreDir = join41(contextRoot, "core");
-  if (!existsSync40(coreDir)) return [];
+  const coreDir = join42(contextRoot, "core");
+  if (!existsSync41(coreDir)) return [];
   const files = import_fast_glob10.default.sync("[3-9]*", { cwd: coreDir, absolute: true });
   const entries = [];
   for (const file of files) {
@@ -36137,19 +36550,19 @@ var init_core_index = __esm({
 });
 
 // src/lib/marketing/paths.ts
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 function marketingRoot(from) {
-  return join42(ensureContextRoot(from), MARKETING_DIR);
+  return join43(ensureContextRoot(from), MARKETING_DIR);
 }
 function marketingRootIfExists(from) {
   const ctx = resolveContextRoot(from);
-  return ctx ? join42(ctx, MARKETING_DIR) : null;
+  return ctx ? join43(ctx, MARKETING_DIR) : null;
 }
 function marketingPath(...segments) {
-  return join42(marketingRoot(), ...segments);
+  return join43(marketingRoot(), ...segments);
 }
 function knowledgePath(...segments) {
-  return join42(ensureContextRoot(), KNOWLEDGE_DIR, ...segments);
+  return join43(ensureContextRoot(), KNOWLEDGE_DIR, ...segments);
 }
 var MARKETING_DIR, KNOWLEDGE_DIR, LEARNINGS_SUBDIR, MARKETING_PATHS;
 var init_paths2 = __esm({
@@ -36231,33 +36644,33 @@ var init_secrets2 = __esm({
 
 // src/lib/marketing/store.ts
 import {
-  existsSync as existsSync41,
-  mkdirSync as mkdirSync20,
+  existsSync as existsSync42,
+  mkdirSync as mkdirSync21,
   openSync,
   closeSync,
-  readFileSync as readFileSync30,
-  writeFileSync as writeFileSync27,
-  renameSync as renameSync6,
+  readFileSync as readFileSync31,
+  writeFileSync as writeFileSync28,
+  renameSync as renameSync7,
   unlinkSync as unlinkSync2,
-  readdirSync as readdirSync10
+  readdirSync as readdirSync11
 } from "fs";
-import { dirname as dirname20, join as join43 } from "path";
+import { dirname as dirname21, join as join44 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 function atomicWriteFile(path2, data) {
-  mkdirSync20(dirname20(path2), { recursive: true });
+  mkdirSync21(dirname21(path2), { recursive: true });
   const tmp = `${path2}.tmp.${process.pid}.${randomBytes2(4).toString("hex")}`;
-  writeFileSync27(tmp, data, "utf8");
-  renameSync6(tmp, path2);
+  writeFileSync28(tmp, data, "utf8");
+  renameSync7(tmp, path2);
 }
 function writeJsonWithBridge(jsonPath, bridgePath, jsonValue, bridgeMarkdown) {
-  mkdirSync20(dirname20(jsonPath), { recursive: true });
-  mkdirSync20(dirname20(bridgePath), { recursive: true });
+  mkdirSync21(dirname21(jsonPath), { recursive: true });
+  mkdirSync21(dirname21(bridgePath), { recursive: true });
   const jsonStr = JSON.stringify(jsonValue, null, 2) + "\n";
   const jsonTmp = `${jsonPath}.tmp.${process.pid}.${randomBytes2(4).toString("hex")}`;
   const bridgeTmp = `${bridgePath}.tmp.${process.pid}.${randomBytes2(4).toString("hex")}`;
-  writeFileSync27(jsonTmp, jsonStr, "utf8");
+  writeFileSync28(jsonTmp, jsonStr, "utf8");
   try {
-    writeFileSync27(bridgeTmp, bridgeMarkdown, "utf8");
+    writeFileSync28(bridgeTmp, bridgeMarkdown, "utf8");
   } catch (e) {
     try {
       unlinkSync2(jsonTmp);
@@ -36265,9 +36678,9 @@ function writeJsonWithBridge(jsonPath, bridgePath, jsonValue, bridgeMarkdown) {
     }
     throw e;
   }
-  renameSync6(jsonTmp, jsonPath);
+  renameSync7(jsonTmp, jsonPath);
   try {
-    renameSync6(bridgeTmp, bridgePath);
+    renameSync7(bridgeTmp, bridgePath);
   } catch (e) {
     try {
       unlinkSync2(bridgeTmp);
@@ -36288,9 +36701,9 @@ function pidAlive(pid) {
 }
 function acquireLock() {
   const lockPath = MARKETING_PATHS.lockFile();
-  mkdirSync20(marketingRoot(), { recursive: true });
-  if (existsSync41(lockPath)) {
-    const heldRaw = readFileSync30(lockPath, "utf8").trim();
+  mkdirSync21(marketingRoot(), { recursive: true });
+  if (existsSync42(lockPath)) {
+    const heldRaw = readFileSync31(lockPath, "utf8").trim();
     const heldPid = Number.parseInt(heldRaw, 10);
     if (pidAlive(heldPid)) {
       throw new LockBusyError(heldPid);
@@ -36306,19 +36719,19 @@ function acquireLock() {
   } catch (e) {
     const code = e.code;
     if (code === "EEXIST") {
-      const heldRaw = existsSync41(lockPath) ? readFileSync30(lockPath, "utf8").trim() : "?";
+      const heldRaw = existsSync42(lockPath) ? readFileSync31(lockPath, "utf8").trim() : "?";
       throw new LockBusyError(Number.parseInt(heldRaw, 10) || -1);
     }
     throw e;
   }
   try {
-    writeFileSync27(fd, String(process.pid), "utf8");
+    writeFileSync28(fd, String(process.pid), "utf8");
   } finally {
     closeSync(fd);
   }
   return function release2() {
     try {
-      const heldRaw = readFileSync30(lockPath, "utf8").trim();
+      const heldRaw = readFileSync31(lockPath, "utf8").trim();
       if (Number.parseInt(heldRaw, 10) === process.pid) {
         unlinkSync2(lockPath);
       }
@@ -36337,7 +36750,7 @@ function newRunId(verb) {
   return `${isoTs()}__${verb}`;
 }
 function runPath(runId) {
-  return join43(MARKETING_PATHS.runsDir(), `${runId}.json`);
+  return join44(MARKETING_PATHS.runsDir(), `${runId}.json`);
 }
 function beginRun(verb, inputs) {
   const id = newRunId(verb);
@@ -36380,24 +36793,24 @@ function beginRun(verb, inputs) {
 }
 function appendIndex(runId, verb, status) {
   const path2 = MARKETING_PATHS.runsIndex();
-  mkdirSync20(dirname20(path2), { recursive: true });
+  mkdirSync21(dirname21(path2), { recursive: true });
   const ts = (/* @__PURE__ */ new Date()).toISOString();
   const line = `- \`${ts}\` **${verb}** (${status}) \u2014 [\`${runId}\`](./${runId}.json)
 `;
   let header2 = "";
   let body = "";
-  if (existsSync41(path2)) {
-    body = readFileSync30(path2, "utf8");
+  if (existsSync42(path2)) {
+    body = readFileSync31(path2, "utf8");
   } else {
     header2 = "# Marketing runs (LIFO)\n\n";
   }
   if (header2) {
-    writeFileSync27(path2, header2 + line + body, "utf8");
+    writeFileSync28(path2, header2 + line + body, "utf8");
   } else if (body.startsWith("# Marketing runs (LIFO)\n\n")) {
     const HDR = "# Marketing runs (LIFO)\n\n";
-    writeFileSync27(path2, HDR + line + body.slice(HDR.length), "utf8");
+    writeFileSync28(path2, HDR + line + body.slice(HDR.length), "utf8");
   } else {
-    writeFileSync27(path2, "# Marketing runs (LIFO)\n\n" + line + body, "utf8");
+    writeFileSync28(path2, "# Marketing runs (LIFO)\n\n" + line + body, "utf8");
   }
 }
 var LockBusyError;
@@ -36417,35 +36830,35 @@ var init_store = __esm({
 });
 
 // src/lib/marketing/cohort.ts
-import { existsSync as existsSync42, readFileSync as readFileSync31, readdirSync as readdirSync11 } from "fs";
-import { join as join44 } from "path";
+import { existsSync as existsSync43, readFileSync as readFileSync32, readdirSync as readdirSync12 } from "fs";
+import { join as join45 } from "path";
 function newCohortId() {
   return `coh_${idgen()}`;
 }
 function cohortPaths(id) {
   const dir = MARKETING_PATHS.cohortsDir();
   return {
-    json: join44(dir, `${id}.json`),
-    md: join44(dir, `${id}.md`)
+    json: join45(dir, `${id}.json`),
+    md: join45(dir, `${id}.md`)
   };
 }
 function loadCohort(id) {
   const { json } = cohortPaths(id);
-  if (!existsSync42(json)) return null;
+  if (!existsSync43(json)) return null;
   try {
-    return JSON.parse(readFileSync31(json, "utf8"));
+    return JSON.parse(readFileSync32(json, "utf8"));
   } catch {
     return null;
   }
 }
 function listCohorts() {
   const dir = MARKETING_PATHS.cohortsDir();
-  if (!existsSync42(dir)) return [];
-  const files = readdirSync11(dir).filter((f) => f.endsWith(".json"));
+  if (!existsSync43(dir)) return [];
+  const files = readdirSync12(dir).filter((f) => f.endsWith(".json"));
   const cohorts = [];
   for (const f of files) {
     try {
-      const c = JSON.parse(readFileSync31(join44(dir, f), "utf8"));
+      const c = JSON.parse(readFileSync32(join45(dir, f), "utf8"));
       cohorts.push(c);
     } catch {
     }
@@ -36498,19 +36911,19 @@ var init_cohort = __esm({
 
 // src/lib/marketing/learnings.ts
 import {
-  existsSync as existsSync43,
-  mkdirSync as mkdirSync21,
-  readFileSync as readFileSync32,
-  writeFileSync as writeFileSync28,
-  renameSync as renameSync7
+  existsSync as existsSync44,
+  mkdirSync as mkdirSync22,
+  readFileSync as readFileSync33,
+  writeFileSync as writeFileSync29,
+  renameSync as renameSync8
 } from "fs";
-import { dirname as dirname21 } from "path";
+import { dirname as dirname22 } from "path";
 import { randomBytes as randomBytes3 } from "crypto";
 function atomicWriteFile2(path2, data) {
-  mkdirSync21(dirname21(path2), { recursive: true });
+  mkdirSync22(dirname22(path2), { recursive: true });
   const tmp = `${path2}.tmp.${process.pid}.${randomBytes3(4).toString("hex")}`;
-  writeFileSync28(tmp, data, "utf8");
-  renameSync7(tmp, path2);
+  writeFileSync29(tmp, data, "utf8");
+  renameSync8(tmp, path2);
 }
 function newLearningId(type) {
   return type === "ledger" ? `led_${idgen2()}` : `rec_${idgen2()}`;
@@ -36520,11 +36933,11 @@ function todayDateString(now = /* @__PURE__ */ new Date()) {
 }
 function loadIndex() {
   const path2 = MARKETING_PATHS.learningsIndex();
-  if (!existsSync43(path2)) {
+  if (!existsSync44(path2)) {
     return { version: INDEX_VERSION, entries: [] };
   }
   try {
-    const parsed = JSON.parse(readFileSync32(path2, "utf8"));
+    const parsed = JSON.parse(readFileSync33(path2, "utf8"));
     if (parsed.version !== INDEX_VERSION || !Array.isArray(parsed.entries)) {
       return { version: INDEX_VERSION, entries: [] };
     }
@@ -36538,8 +36951,8 @@ function saveIndex(index) {
 }
 function loadByDate(date) {
   const path2 = MARKETING_PATHS.learningsFile(date);
-  if (!existsSync43(path2)) return null;
-  return readFileSync32(path2, "utf8");
+  if (!existsSync44(path2)) return null;
+  return readFileSync33(path2, "utf8");
 }
 function renderEntryBlock(entry, body) {
   const time = entry.created_at.slice(11, 16);
@@ -36574,7 +36987,7 @@ function ensureDailyHeader(date, existing) {
 }
 function appendToDayFile(entry, body) {
   const path2 = MARKETING_PATHS.learningsFile(entry.date_file);
-  const existing = existsSync43(path2) ? readFileSync32(path2, "utf8") : null;
+  const existing = existsSync44(path2) ? readFileSync33(path2, "utf8") : null;
   const base = ensureDailyHeader(entry.date_file, existing);
   const block = renderEntryBlock(entry, body);
   const next = existing && existing.startsWith("# Marketing learnings") ? existing.endsWith("\n") ? existing + block : existing + "\n" + block : base + block;
@@ -36582,8 +36995,8 @@ function appendToDayFile(entry, body) {
 }
 function rewriteDayFileForStatusUpdate(oldEntry, newEntry) {
   const path2 = MARKETING_PATHS.learningsFile(oldEntry.date_file);
-  if (!existsSync43(path2)) return;
-  const text = readFileSync32(path2, "utf8");
+  if (!existsSync44(path2)) return;
+  const text = readFileSync33(path2, "utf8");
   const re = new RegExp(
     `<!-- entry ([^>]*?id=${escapeRegExp(oldEntry.id)}[^>]*) -->`
   );
@@ -36691,10 +37104,10 @@ var init_learnings = __esm({
 });
 
 // src/lib/marketing/snapshot.ts
-import { existsSync as existsSync44, readFileSync as readFileSync33 } from "fs";
+import { existsSync as existsSync45, readFileSync as readFileSync34 } from "fs";
 function buildMarketingSnapshot(opts = {}) {
   const root = marketingRootIfExists();
-  if (!root || !existsSync44(root)) return null;
+  if (!root || !existsSync45(root)) return null;
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const lines = ["## Marketing\n"];
   const cohorts = listCohorts();
@@ -36751,9 +37164,9 @@ function cohortHypothesisLine(c) {
 }
 function readLastInsightsPull() {
   const idxPath = MARKETING_PATHS.insightsDir() + "/_index.json";
-  if (!existsSync44(idxPath)) return null;
+  if (!existsSync45(idxPath)) return null;
   try {
-    const raw = JSON.parse(readFileSync33(idxPath, "utf8"));
+    const raw = JSON.parse(readFileSync34(idxPath, "utf8"));
     return raw.updated_at && raw.updated_at !== "1970-01-01T00:00:00Z" ? raw.updated_at : null;
   } catch {
     return null;
@@ -36851,16 +37264,16 @@ var init_setup_drift = __esm({
 });
 
 // src/lib/asset-drift-cache.ts
-import { existsSync as existsSync45, readFileSync as readFileSync34, writeFileSync as writeFileSync29, mkdirSync as mkdirSync22 } from "fs";
-import { join as join45, dirname as dirname22 } from "path";
+import { existsSync as existsSync46, readFileSync as readFileSync35, writeFileSync as writeFileSync30, mkdirSync as mkdirSync23 } from "fs";
+import { join as join46, dirname as dirname23 } from "path";
 function assetDriftCachePath(contextRoot) {
-  return join45(contextRoot, "state", ".asset-drift.json");
+  return join46(contextRoot, "state", ".asset-drift.json");
 }
 function readAssetDriftCache(contextRoot) {
   try {
     const p = assetDriftCachePath(contextRoot);
-    if (!existsSync45(p)) return null;
-    const parsed = JSON.parse(readFileSync34(p, "utf-8"));
+    if (!existsSync46(p)) return null;
+    const parsed = JSON.parse(readFileSync35(p, "utf-8"));
     if (!parsed || typeof parsed.cliVersion !== "string" || typeof parsed.setupVersion !== "string" || typeof parsed.usedAssetsChanged !== "boolean") {
       return null;
     }
@@ -36876,8 +37289,8 @@ function readAssetDriftCache(contextRoot) {
 }
 function writeAssetDriftCache(contextRoot, cache) {
   const p = assetDriftCachePath(contextRoot);
-  mkdirSync22(dirname22(p), { recursive: true });
-  writeFileSync29(p, JSON.stringify(cache, null, 2) + "\n", "utf-8");
+  mkdirSync23(dirname23(p), { recursive: true });
+  writeFileSync30(p, JSON.stringify(cache, null, 2) + "\n", "utf-8");
 }
 function cacheConfidentlyClean(cache, cliVersion, setupVersion) {
   return cache !== null && cache.cliVersion === cliVersion && cache.setupVersion === setupVersion && cache.usedAssetsChanged === false;
@@ -37022,8 +37435,8 @@ var init_recall_synonyms = __esm({
 });
 
 // src/lib/session-digest.ts
-import { existsSync as existsSync46, mkdirSync as mkdirSync23, writeFileSync as writeFileSync30 } from "fs";
-import { join as join46 } from "path";
+import { existsSync as existsSync47, mkdirSync as mkdirSync24, writeFileSync as writeFileSync31 } from "fs";
+import { join as join47 } from "path";
 function coerceCreatedAt(value) {
   if (typeof value === "string" && value.trim()) return value.trim();
   if (value instanceof Date && !Number.isNaN(value.getTime())) return value.toISOString();
@@ -37081,18 +37494,18 @@ function enforceByteCap(lines, maxBytes) {
   return out.trimEnd() + "\n";
 }
 function digestsDir(root) {
-  return join46(root, "state", DIGESTS_DIRNAME);
+  return join47(root, "state", DIGESTS_DIRNAME);
 }
 function digestPath(root, sessionId) {
   const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join46(digestsDir(root), `${safe}.md`);
+  return join47(digestsDir(root), `${safe}.md`);
 }
 function digestExists(root, sessionId) {
-  return existsSync46(digestPath(root, sessionId));
+  return existsSync47(digestPath(root, sessionId));
 }
 function digestIsPartial(root, sessionId) {
   const file = digestPath(root, sessionId);
-  if (!existsSync46(file)) return false;
+  if (!existsSync47(file)) return false;
   try {
     const { data } = readFrontmatter(file);
     return data.partial === true;
@@ -37102,7 +37515,7 @@ function digestIsPartial(root, sessionId) {
 }
 function writeDigest(root, sessionId, md, opts = {}) {
   const dir = digestsDir(root);
-  mkdirSync23(dir, { recursive: true });
+  mkdirSync24(dir, { recursive: true });
   const file = digestPath(root, sessionId);
   const safeId = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
   const frontmatter = [
@@ -37114,12 +37527,12 @@ function writeDigest(root, sessionId, md, opts = {}) {
     "---",
     ""
   ].join("\n");
-  writeFileSync30(file, frontmatter + md, "utf-8");
+  writeFileSync31(file, frontmatter + md, "utf-8");
   return file;
 }
 function loadDigestDocs(root) {
   const dir = digestsDir(root);
-  if (!existsSync46(dir)) return [];
+  if (!existsSync47(dir)) return [];
   const files = import_fast_glob11.default.sync("*.md", { cwd: dir, absolute: true });
   const parsed = [];
   for (const file of files) {
@@ -37130,7 +37543,7 @@ function loadDigestDocs(root) {
       const title = `Session digest ${sessionId}`;
       const body = content.trim();
       if (!body) continue;
-      const relPath = join46("state", DIGESTS_DIRNAME, `${sessionId}.md`);
+      const relPath = join47("state", DIGESTS_DIRNAME, `${sessionId}.md`);
       const createdAt = coerceCreatedAt(data.created_at);
       const fields = buildFields({ slug, title, description: "", tags: [], body });
       const ms = createdAt ? Date.parse(createdAt) : NaN;
@@ -37182,8 +37595,8 @@ var init_session_digest = __esm({
 });
 
 // src/lib/recall.ts
-import { existsSync as existsSync47, readFileSync as readFileSync36 } from "fs";
-import { join as join47, basename as basename12, dirname as dirname23, relative as relative3 } from "path";
+import { existsSync as existsSync48, readFileSync as readFileSync37 } from "fs";
+import { join as join48, basename as basename12, dirname as dirname24, relative as relative3 } from "path";
 function isFederated(doc) {
   return doc.federated === true;
 }
@@ -37272,7 +37685,7 @@ function productFromRelPath(relPath) {
   return m ? m[1] : void 0;
 }
 function loadMarkdownDocs(dir, type, contextRoot) {
-  if (!existsSync47(dir)) return [];
+  if (!existsSync48(dir)) return [];
   const files = import_fast_glob12.default.sync("**/*.md", { cwd: dir, absolute: true });
   const boardDirs = diagramFolderDirs(files);
   const out = [];
@@ -37316,11 +37729,11 @@ function loadMarkdownDocs(dir, type, contextRoot) {
   return out;
 }
 function loadChangelogEntries(contextRoot) {
-  const path2 = join47(contextRoot, "core", "CHANGELOG.json");
-  if (!existsSync47(path2)) return [];
+  const path2 = join48(contextRoot, "core", "CHANGELOG.json");
+  if (!existsSync48(path2)) return [];
   let entries = [];
   try {
-    const raw = readFileSync36(path2, "utf-8");
+    const raw = readFileSync37(path2, "utf-8");
     const parsed = JSON.parse(raw);
     if (Array.isArray(parsed)) entries = parsed;
   } catch {
@@ -37368,9 +37781,9 @@ function loadChangelogEntries(contextRoot) {
   return out;
 }
 function loadMemoryFile(contextRoot) {
-  const path2 = join47(contextRoot, "core", "2.memory.md");
-  if (!existsSync47(path2)) return [];
-  const raw = readFileSync36(path2, "utf-8");
+  const path2 = join48(contextRoot, "core", "2.memory.md");
+  if (!existsSync48(path2)) return [];
+  const raw = readFileSync37(path2, "utf-8");
   const sections = raw.split(/^##\s+/m).slice(1);
   const out = [];
   for (let i = 0; i < sections.length; i++) {
@@ -37402,11 +37815,11 @@ function loadMemoryFile(contextRoot) {
   return out;
 }
 function loadBookmarkDocs(contextRoot) {
-  const path2 = join47(contextRoot, "state", ".sleep.json");
-  if (!existsSync47(path2)) return [];
+  const path2 = join48(contextRoot, "state", ".sleep.json");
+  if (!existsSync48(path2)) return [];
   let bookmarks = [];
   try {
-    const parsed = JSON.parse(readFileSync36(path2, "utf-8"));
+    const parsed = JSON.parse(readFileSync37(path2, "utf-8"));
     if (parsed && typeof parsed === "object" && Array.isArray(parsed.bookmarks)) {
       bookmarks = parsed.bookmarks;
     }
@@ -37448,14 +37861,14 @@ function loadBookmarkDocs(contextRoot) {
   return out;
 }
 function loadSkillDocs(skillsRoot) {
-  if (!existsSync47(skillsRoot)) return [];
+  if (!existsSync48(skillsRoot)) return [];
   const files = import_fast_glob12.default.sync("*/SKILL.md", { cwd: skillsRoot, absolute: true });
   const out = [];
   for (const file of files) {
     try {
       const { data, content } = readFrontmatter(file);
       if (data.alwaysApply === true) continue;
-      const slug = typeof data.name === "string" && data.name ? data.name : basename12(dirname23(file));
+      const slug = typeof data.name === "string" && data.name ? data.name : basename12(dirname24(file));
       const title = slug;
       const description = typeof data.description === "string" ? data.description : "";
       const tags = Array.isArray(data.tags) ? data.tags.map(String) : [];
@@ -37487,13 +37900,13 @@ function buildCorpus(contextRoot, opts = {}) {
   const types = new Set(opts.types ?? ["knowledge", "feature", "task", "memory", "changelog"]);
   const docs = [];
   if (types.has("knowledge")) {
-    docs.push(...loadMarkdownDocs(join47(contextRoot, "knowledge"), "knowledge", contextRoot));
+    docs.push(...loadMarkdownDocs(join48(contextRoot, "knowledge"), "knowledge", contextRoot));
   }
   if (types.has("feature")) {
-    docs.push(...loadMarkdownDocs(join47(contextRoot, "core", "features"), "feature", contextRoot));
+    docs.push(...loadMarkdownDocs(join48(contextRoot, "core", "features"), "feature", contextRoot));
   }
   if (types.has("task")) {
-    docs.push(...loadMarkdownDocs(join47(contextRoot, "state"), "task", contextRoot));
+    docs.push(...loadMarkdownDocs(join48(contextRoot, "state"), "task", contextRoot));
     docs.push(...loadDigestDocs(contextRoot));
   }
   if (types.has("memory")) {
@@ -37855,7 +38268,7 @@ var init_federation_config = __esm({
 });
 
 // src/lib/federation-recall.ts
-import { basename as basename13, dirname as dirname24 } from "path";
+import { basename as basename13, dirname as dirname25 } from "path";
 function namespacedKey(vault, type, slug) {
   return `${vault}::${type}/${slug}`;
 }
@@ -37880,7 +38293,7 @@ function crossVaultRecall(query, opts) {
     }
     const isCurrent = target.current === true;
     if (!isCurrent) {
-      const projectRoot = dirname24(contextRoot);
+      const projectRoot = dirname25(contextRoot);
       if (!isShareable(projectRoot)) continue;
     }
     const corpus = buildCorpus(contextRoot, opts.types ? { types: opts.types } : {}).filter((doc) => !isFederated(doc));
@@ -37953,16 +38366,16 @@ var init_federation_recall = __esm({
 });
 
 // src/lib/federation-peer-summary.ts
-import { existsSync as existsSync48, mkdirSync as mkdirSync24, readFileSync as readFileSync37, writeFileSync as writeFileSync31 } from "fs";
-import { dirname as dirname25, join as join48 } from "path";
+import { existsSync as existsSync49, mkdirSync as mkdirSync25, readFileSync as readFileSync38, writeFileSync as writeFileSync32 } from "fs";
+import { dirname as dirname26, join as join49 } from "path";
 function peerSummaryCachePath(contextRoot) {
-  return join48(contextRoot, CACHE_REL_PATH2);
+  return join49(contextRoot, CACHE_REL_PATH2);
 }
 function readPeerSummaryCache(contextRoot) {
   const path2 = peerSummaryCachePath(contextRoot);
-  if (!existsSync48(path2)) return null;
+  if (!existsSync49(path2)) return null;
   try {
-    const parsed = JSON.parse(readFileSync37(path2, "utf-8"));
+    const parsed = JSON.parse(readFileSync38(path2, "utf-8"));
     if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.peers)) return null;
     const peers = parsed.peers.filter((p) => p !== null && typeof p === "object").map(sanitizePeer);
     return {
@@ -37993,8 +38406,8 @@ function buildPeerSummary(peerRoot, peerName) {
   };
 }
 function readWhatItIs(peerRoot) {
-  const soulPath = join48(peerRoot, "core", "0.soul.md");
-  if (!existsSync48(soulPath)) return "";
+  const soulPath = join49(peerRoot, "core", "0.soul.md");
+  if (!existsSync49(soulPath)) return "";
   try {
     const { data, content } = readFrontmatter(soulPath);
     const name = typeof data.name === "string" ? data.name : "";
@@ -38011,8 +38424,8 @@ function readWhatItIs(peerRoot) {
   }
 }
 function readLastActivity(peerRoot) {
-  const path2 = join48(peerRoot, "core", "CHANGELOG.json");
-  if (!existsSync48(path2)) return [];
+  const path2 = join49(peerRoot, "core", "CHANGELOG.json");
+  if (!existsSync49(path2)) return [];
   try {
     const entries = readJsonArray(path2);
     const out = [];
@@ -38030,8 +38443,8 @@ function readLastActivity(peerRoot) {
   }
 }
 function readActiveTask(peerRoot) {
-  const stateDir = join48(peerRoot, "state");
-  if (!existsSync48(stateDir)) return "";
+  const stateDir = join49(peerRoot, "state");
+  if (!existsSync49(stateDir)) return "";
   let files;
   try {
     files = import_fast_glob13.default.sync("*.md", { cwd: stateDir, absolute: true });
@@ -38059,9 +38472,9 @@ function readActiveTask(peerRoot) {
 }
 function readTopTags(peerRoot) {
   const counts = /* @__PURE__ */ new Map();
-  const dirs = [join48(peerRoot, "knowledge"), join48(peerRoot, "core", "features")];
+  const dirs = [join49(peerRoot, "knowledge"), join49(peerRoot, "core", "features")];
   for (const dir of dirs) {
-    if (!existsSync48(dir)) continue;
+    if (!existsSync49(dir)) continue;
     let files;
     try {
       files = import_fast_glob13.default.sync("*.md", { cwd: dir, absolute: true });
@@ -38083,7 +38496,7 @@ function readTopTags(peerRoot) {
   return Array.from(counts.entries()).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, MAX_TAGS).map(([t]) => t);
 }
 function refreshPeerSummaries(contextRoot, home) {
-  const { name, target } = currentVaultTarget(dirname25(contextRoot), home);
+  const { name, target } = currentVaultTarget(dirname26(contextRoot), home);
   const targets = resolveConnectedVaults(target, contextRoot, home).filter(
     (t) => t.current !== true && t.name !== name
   );
@@ -38103,8 +38516,8 @@ function refreshPeerSummaries(contextRoot, home) {
 }
 function writePeerSummaryCache(contextRoot, cache) {
   const path2 = peerSummaryCachePath(contextRoot);
-  mkdirSync24(dirname25(path2), { recursive: true });
-  writeFileSync31(path2, JSON.stringify(cache, null, 2) + "\n", "utf-8");
+  mkdirSync25(dirname26(path2), { recursive: true });
+  writeFileSync32(path2, JSON.stringify(cache, null, 2) + "\n", "utf-8");
 }
 var import_fast_glob13, CACHE_REL_PATH2, MAX_ACTIVITY, MAX_TAGS, WHAT_IT_IS_CHARS;
 var init_federation_peer_summary = __esm({
@@ -38227,8 +38640,8 @@ var init_snapshot_budget = __esm({
 });
 
 // src/cli/commands/snapshot.ts
-import { readFileSync as readFileSync38, existsSync as existsSync49, statSync as statSync5 } from "fs";
-import { join as join49, basename as basename14, dirname as dirname26 } from "path";
+import { readFileSync as readFileSync39, existsSync as existsSync50, statSync as statSync5 } from "fs";
+import { join as join50, basename as basename14, dirname as dirname27 } from "path";
 function extractFirstParagraph(content) {
   const lines = content.split("\n");
   const paragraphLines = [];
@@ -38262,8 +38675,8 @@ function sortTaskEntriesByActivity(entries) {
   return [...entries].sort((a, b) => statusRank(a.status) - statusRank(b.status) || prioRank(a.priority) - prioRank(b.priority) || b.updated.localeCompare(a.updated));
 }
 function getActiveTaskEntries(root) {
-  const stateDir = join49(root, "state");
-  if (!existsSync49(stateDir)) return [];
+  const stateDir = join50(root, "state");
+  if (!existsSync50(stateDir)) return [];
   const taskFiles = import_fast_glob14.default.sync("*.md", { cwd: stateDir, absolute: true });
   const entries = [];
   for (const file of taskFiles) {
@@ -38295,15 +38708,15 @@ function getActiveTaskEntries(root) {
   return entries;
 }
 function resolveActiveTaskPath(root) {
-  const stateDir = join49(root, "state");
-  if (!existsSync49(stateDir)) return null;
-  const overridePath = join49(stateDir, ".active-task");
-  if (existsSync49(overridePath)) {
+  const stateDir = join50(root, "state");
+  if (!existsSync50(stateDir)) return null;
+  const overridePath = join50(stateDir, ".active-task");
+  if (existsSync50(overridePath)) {
     try {
-      const slug = readFileSync38(overridePath, "utf-8").trim();
+      const slug = readFileSync39(overridePath, "utf-8").trim();
       if (slug) {
-        const taskPath = join49(stateDir, `${slug}.md`);
-        if (existsSync49(taskPath)) return taskPath;
+        const taskPath = join50(stateDir, `${slug}.md`);
+        if (existsSync50(taskPath)) return taskPath;
       }
     } catch {
     }
@@ -38329,7 +38742,7 @@ function resolveActiveTaskPath(root) {
   return candidates[0].path;
 }
 function getActiveProductKnowledge(root) {
-  const config = readSetupConfig(dirname26(root));
+  const config = readSetupConfig(dirname27(root));
   if (!config || !Array.isArray(config.multiProduct) || config.multiProduct.length === 0) {
     return [];
   }
@@ -38346,11 +38759,11 @@ function getActiveProductKnowledge(root) {
   }
   if (!product) return [];
   if (!config.multiProduct.includes(product)) return [];
-  const productKnowledgePath = join49(root, "knowledge", "products", `${product}.md`);
-  if (!existsSync49(productKnowledgePath)) return [];
+  const productKnowledgePath = join50(root, "knowledge", "products", `${product}.md`);
+  if (!existsSync50(productKnowledgePath)) return [];
   let raw;
   try {
-    raw = readFileSync38(productKnowledgePath, "utf-8");
+    raw = readFileSync39(productKnowledgePath, "utf-8");
   } catch {
     return [];
   }
@@ -38385,7 +38798,7 @@ function getActiveProductKnowledge(root) {
 }
 function getVersionNudge(root) {
   try {
-    const projectRoot = dirname26(root);
+    const projectRoot = dirname27(root);
     const cache = readVersionCache(projectRoot);
     if (!cache || !isCacheFresh(cache)) return "";
     const installedCli = dreamcontextVersion();
@@ -38401,9 +38814,9 @@ function getVersionNudge(root) {
 }
 function getMigrationNote(root) {
   try {
-    const sleepPath = join49(root, "state", ".sleep.json");
-    if (!existsSync49(sleepPath)) return "";
-    const raw = readFileSync38(sleepPath, "utf-8");
+    const sleepPath = join50(root, "state", ".sleep.json");
+    if (!existsSync50(sleepPath)) return "";
+    const raw = readFileSync39(sleepPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || !Array.isArray(parsed.pendingMigrationNotices) || parsed.pendingMigrationNotices.length === 0) {
       return "";
@@ -38421,7 +38834,7 @@ Migrations applied since last session: ${notices.join("; ")}`;
 }
 function getDriftDirective(root) {
   try {
-    const projectRoot = dirname26(root);
+    const projectRoot = dirname27(root);
     const config = readSetupConfig(projectRoot);
     if (!config) return "";
     const cliVersion = dreamcontextVersion();
@@ -38451,24 +38864,24 @@ function generateSnapshot(rootOverride) {
       parts = [];
     }
   };
-  const soulPath = join49(root, "core", "0.soul.md");
-  if (existsSync49(soulPath)) {
-    const content = readFileSync38(soulPath, "utf-8").trim();
+  const soulPath = join50(root, "core", "0.soul.md");
+  if (existsSync50(soulPath)) {
+    const content = readFileSync39(soulPath, "utf-8").trim();
     parts.push("## Soul (Agent Identity, Principles, Rules)\n");
     parts.push(content);
     parts.push("");
   }
-  const userPath = join49(root, "core", "1.user.md");
-  if (existsSync49(userPath)) {
-    const content = readFileSync38(userPath, "utf-8").trim();
+  const userPath = join50(root, "core", "1.user.md");
+  if (existsSync50(userPath)) {
+    const content = readFileSync39(userPath, "utf-8").trim();
     parts.push("## User (Preferences, Project Details, Rules)\n");
     parts.push(content);
     parts.push("");
   }
   flush("identity", { neverEvict: true });
-  const memoryPath = join49(root, "core", "2.memory.md");
-  if (existsSync49(memoryPath)) {
-    const content = readFileSync38(memoryPath, "utf-8").trim();
+  const memoryPath = join50(root, "core", "2.memory.md");
+  if (existsSync50(memoryPath)) {
+    const content = readFileSync39(memoryPath, "utf-8").trim();
     if (content) {
       parts.push("## Memory (Technical Decisions, Known Issues, Session Log)\n");
       parts.push(content);
@@ -38533,8 +38946,8 @@ function generateSnapshot(rootOverride) {
   if (sleepState.triggers.length > 0) {
     const taskNames = [];
     const taskTags = [];
-    const stateDir = join49(root, "state");
-    if (existsSync49(stateDir)) {
+    const stateDir = join50(root, "state");
+    if (existsSync50(stateDir)) {
       const taskFiles = import_fast_glob14.default.sync("*.md", { cwd: stateDir, absolute: true });
       for (const file of taskFiles) {
         try {
@@ -38570,14 +38983,14 @@ function generateSnapshot(rootOverride) {
   const CHANGELOG_TIER2 = 10;
   const TIER1_BODY_CHARS = 300;
   const TIER2_LINE_CHARS = 140;
-  const multiPerson = isMultiPerson(readSetupConfig(dirname26(root)));
+  const multiPerson = isMultiPerson(readSetupConfig(dirname27(root)));
   const authorSuffix = (e) => {
     if (!multiPerson) return "";
     const authors = Array.isArray(e.authors) ? e.authors.filter((a) => typeof a === "string") : [];
     return authors.length > 0 ? ` \u2014 by ${authors.join(", ")}` : "";
   };
-  const changelogPath = join49(root, "core", "CHANGELOG.json");
-  if (existsSync49(changelogPath)) {
+  const changelogPath = join50(root, "core", "CHANGELOG.json");
+  if (existsSync50(changelogPath)) {
     try {
       const entries = readJsonArray(changelogPath);
       const tier1 = entries.slice(0, CHANGELOG_TIER1);
@@ -38633,8 +39046,8 @@ function generateSnapshot(rootOverride) {
     } catch {
     }
   }
-  const releasesPath = join49(root, "core", "RELEASES.json");
-  if (existsSync49(releasesPath)) {
+  const releasesPath = join50(root, "core", "RELEASES.json");
+  if (existsSync50(releasesPath)) {
     try {
       const releases = readJsonArray(releasesPath);
       if (releases.length > 0) {
@@ -38670,8 +39083,8 @@ function generateSnapshot(rootOverride) {
     }
   }
   flush("releases", { neverEvict: true });
-  const featuresDir = join49(root, "core", "features");
-  if (existsSync49(featuresDir)) {
+  const featuresDir = join50(root, "core", "features");
+  if (existsSync50(featuresDir)) {
     const featureFiles = import_fast_glob14.default.sync("*.md", { cwd: featuresDir, absolute: true });
     const features = [];
     const featureMeta = [];
@@ -38759,8 +39172,8 @@ function generateSnapshot(rootOverride) {
     const pinnedEntries = [];
     const warmEntries = [];
     const activeTaskTags = [];
-    const stDir = join49(root, "state");
-    if (existsSync49(stDir)) {
+    const stDir = join50(root, "state");
+    if (existsSync50(stDir)) {
       const tFiles = import_fast_glob14.default.sync("*.md", { cwd: stDir, absolute: true });
       for (const file of tFiles) {
         try {
@@ -38916,8 +39329,8 @@ function generateSubagentBriefing() {
   parts.push('`dreamcontext memory recall "<keywords>"` (BM25 over knowledge/features/tasks/');
   parts.push("memory/changelog, <100ms, zero token overhead) BEFORE Glob/Grep \u2014 it frequently");
   parts.push("beats blind exploration outright.\n");
-  const soulPath = join49(root, "core", "0.soul.md");
-  if (existsSync49(soulPath)) {
+  const soulPath = join50(root, "core", "0.soul.md");
+  if (existsSync50(soulPath)) {
     const { data, content } = readFrontmatter(soulPath);
     const projectName = typeof data.name === "string" ? data.name : "";
     const lines = content.split("\n");
@@ -38936,8 +39349,8 @@ function generateSubagentBriefing() {
 `);
     }
   }
-  const featuresDir = join49(root, "core", "features");
-  if (existsSync49(featuresDir)) {
+  const featuresDir = join50(root, "core", "features");
+  if (existsSync50(featuresDir)) {
     const featureFiles = import_fast_glob14.default.sync("*.md", { cwd: featuresDir, absolute: true });
     const features = [];
     for (const file of featureFiles) {
@@ -39004,8 +39417,8 @@ function generateSubagentBriefing() {
     }
     parts.push("");
   }
-  const coreDir = join49(root, "core");
-  if (existsSync49(coreDir)) {
+  const coreDir = join50(root, "core");
+  if (existsSync50(coreDir)) {
     const allCoreFiles = import_fast_glob14.default.sync(["[0-9]*"], { cwd: coreDir, absolute: true });
     allCoreFiles.sort((a, b) => basename14(a).localeCompare(basename14(b), void 0, { numeric: true }));
     if (allCoreFiles.length > 0) {
@@ -39149,7 +39562,7 @@ var init_salience = __esm({
 });
 
 // src/cli/commands/transcript.ts
-import { readFileSync as readFileSync39, existsSync as existsSync50, statSync as statSync6 } from "fs";
+import { readFileSync as readFileSync40, existsSync as existsSync51, statSync as statSync6 } from "fs";
 function distillTranscript(transcriptPath, sinceTimestamp) {
   const result = {
     userMessages: [],
@@ -39158,11 +39571,11 @@ function distillTranscript(transcriptPath, sinceTimestamp) {
     errors: [],
     bookmarks: []
   };
-  if (!existsSync50(transcriptPath)) return result;
+  if (!existsSync51(transcriptPath)) return result;
   try {
     const stat = statSync6(transcriptPath);
     if (stat.size === 0 || stat.size > MAX_TRANSCRIPT_BYTES) return result;
-    const content = readFileSync39(transcriptPath, "utf-8");
+    const content = readFileSync40(transcriptPath, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     for (const line of lines) {
       let entry;
@@ -39346,7 +39759,7 @@ function registerTranscriptCommand(program2) {
       error(`No transcript path for session: ${sessionId}`);
       return;
     }
-    if (!existsSync50(session.transcript_path)) {
+    if (!existsSync51(session.transcript_path)) {
       error(`Transcript file not found: ${session.transcript_path}`);
       return;
     }
@@ -39390,22 +39803,22 @@ var init_transcript = __esm({
 });
 
 // src/lib/marketing/path-guards.ts
-import { existsSync as existsSync51, realpathSync } from "fs";
-import { basename as basename15, dirname as dirname27, resolve as resolve8, sep as sep5 } from "path";
+import { existsSync as existsSync52, realpathSync } from "fs";
+import { basename as basename15, dirname as dirname28, resolve as resolve9, sep as sep5 } from "path";
 function isMarketingEnvPath(filePath, from) {
   if (!filePath) return false;
   const root = resolveContextRoot(from);
   if (!root) return false;
   const realRoot = realpathOrSelf(root);
-  const target = resolve8(realRoot, "marketing", ".env");
-  const realCandidate = realpathOfNearestAncestor(resolve8(filePath));
+  const target = resolve9(realRoot, "marketing", ".env");
+  const realCandidate = realpathOfNearestAncestor(resolve9(filePath));
   if (realCandidate === target) return true;
   if (!realCandidate.startsWith(realRoot + sep5)) return false;
   return realCandidate.endsWith(`${sep5}marketing${sep5}.env`);
 }
 function realpathOrSelf(p) {
   try {
-    return existsSync51(p) ? realpathSync(p) : p;
+    return existsSync52(p) ? realpathSync(p) : p;
   } catch {
     return p;
   }
@@ -39413,9 +39826,9 @@ function realpathOrSelf(p) {
 function realpathOfNearestAncestor(p) {
   let current = p;
   const tail = [];
-  while (current && current !== sep5 && !existsSync51(current)) {
+  while (current && current !== sep5 && !existsSync52(current)) {
     tail.unshift(basename15(current));
-    current = dirname27(current);
+    current = dirname28(current);
   }
   if (!current || current === sep5) return p;
   try {
@@ -39433,7 +39846,7 @@ var init_path_guards = __esm({
 });
 
 // src/lib/recall-query-extractor.ts
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync4 } from "child_process";
 function buildCorpusIndex(corpus) {
   return corpus.map((d) => {
     const desc = d.description ? ` \u2014 ${d.description}` : "";
@@ -39532,7 +39945,7 @@ If nothing is relevant: {"docs":[],"skip":false}
 If pure greeting: {"skip":true}`;
     DEFAULT_TIMEOUT_MS2 = 12e4;
     defaultExecutor = (prompt, systemPrompt) => {
-      return execFileSync2("claude", [
+      return execFileSync4("claude", [
         "--model",
         "haiku",
         "-p",
@@ -39554,371 +39967,6 @@ If pure greeting: {"skip":true}`;
   }
 });
 
-// src/cli/commands/app.ts
-import { execFileSync as execFileSync3, spawn as spawnProcess } from "child_process";
-import {
-  existsSync as existsSync52,
-  mkdirSync as mkdirSync25,
-  mkdtempSync,
-  readFileSync as readFileSync40,
-  writeFileSync as writeFileSync32,
-  rmSync as rmSync6,
-  renameSync as renameSync8,
-  readdirSync as readdirSync12
-} from "fs";
-import { homedir as homedir2, tmpdir } from "os";
-import { join as join50, resolve as resolve9, dirname as dirname28 } from "path";
-import { createHash as createHash2 } from "crypto";
-function detectPlatform(platform2 = process.platform, arch2 = process.arch) {
-  const os3 = platform2 === "darwin" ? "darwin" : platform2 === "win32" ? "win32" : platform2 === "linux" ? "linux" : "other";
-  const a = arch2 === "arm64" ? "aarch64" : arch2 === "x64" ? "x86_64" : "other";
-  return { os: os3, arch: a };
-}
-function pickAssetForArch(assetNames, arch2) {
-  const appAssets = assetNames.filter((n) => n.endsWith(".app.tar.gz"));
-  const exact = appAssets.find((n) => n.includes(`_${arch2}.`));
-  return exact ?? null;
-}
-function defaultInstallDir(home = homedir2()) {
-  return join50(home, "Applications");
-}
-function appManifestPath(home = homedir2()) {
-  return join50(home, ".dreamcontext", "app.json");
-}
-function readAppManifest(home = homedir2()) {
-  const p = appManifestPath(home);
-  if (!existsSync52(p)) return null;
-  try {
-    const parsed = JSON.parse(readFileSync40(p, "utf-8"));
-    if (!parsed || typeof parsed.version !== "string" || typeof parsed.path !== "string") return null;
-    return {
-      version: parsed.version,
-      path: parsed.path,
-      installedAt: typeof parsed.installedAt === "number" ? parsed.installedAt : 0,
-      source: typeof parsed.source === "string" ? parsed.source : "unknown"
-    };
-  } catch {
-    return null;
-  }
-}
-function writeAppManifest(manifest, home = homedir2()) {
-  const p = appManifestPath(home);
-  mkdirSync25(dirname28(p), { recursive: true });
-  writeFileSync32(p, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
-}
-function run(cmd, args) {
-  execFileSync3(cmd, args, { stdio: ["ignore", "ignore", "pipe"] });
-}
-function runCapture(cmd, args) {
-  return execFileSync3(cmd, args, { encoding: "utf-8" }).toString().trim();
-}
-function validateAppBundle(appDir) {
-  if (!appDir.endsWith(".app") || !existsSync52(appDir)) {
-    throw new Error(`Not a .app bundle: ${appDir}`);
-  }
-  const macos = join50(appDir, "Contents", "MacOS");
-  const plist = join50(appDir, "Contents", "Info.plist");
-  if (!existsSync52(macos) || !existsSync52(plist)) {
-    throw new Error(`Malformed .app (missing Contents/MacOS or Info.plist): ${appDir}`);
-  }
-}
-function readBundleVersion(appDir) {
-  const plist = join50(appDir, "Contents", "Info.plist");
-  try {
-    return runCapture("plutil", ["-extract", "CFBundleShortVersionString", "raw", "-o", "-", plist]) || null;
-  } catch {
-    return null;
-  }
-}
-function findAppInDir(dir) {
-  const entries = readdirSync12(dir).filter((e) => e.endsWith(".app"));
-  return entries.length > 0 ? join50(dir, entries[0]) : null;
-}
-function materializeAppBundle(source, workDir) {
-  const src = resolve9(source);
-  if (!existsSync52(src)) throw new Error(`Source not found: ${src}`);
-  if (src.endsWith(".app")) {
-    return src;
-  }
-  if (src.endsWith(".tar.gz") || src.endsWith(".tgz")) {
-    run("tar", ["-xzf", src, "-C", workDir]);
-  } else if (src.endsWith(".zip")) {
-    run("ditto", ["-x", "-k", src, workDir]);
-  } else {
-    throw new Error(`Unsupported source (expect .app, .tar.gz, or .zip): ${src}`);
-  }
-  const app = findAppInDir(workDir);
-  if (!app) throw new Error(`No .app found inside archive: ${src}`);
-  return app;
-}
-function verifyCodesign(appDir) {
-  try {
-    execFileSync3("codesign", ["--verify", "--deep", appDir], { stdio: ["ignore", "ignore", "ignore"] });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isAppRunning() {
-  try {
-    const out = execFileSync3("pgrep", ["-f", `${APP_BUNDLE_NAME}/Contents/MacOS/`], { encoding: "utf-8" }).toString().trim();
-    return out.length > 0;
-  } catch {
-    return false;
-  }
-}
-function installAppBundle(source, opts = {}) {
-  if (detectPlatform().os !== "darwin") {
-    throw new Error("Desktop app install is currently macOS-only.");
-  }
-  const home = opts.home ?? homedir2();
-  const installDir = opts.installDir ?? defaultInstallDir(home);
-  mkdirSync25(installDir, { recursive: true });
-  const workDir = mkdtempSync(join50(tmpdir(), "dc-app-"));
-  try {
-    const appDir = materializeAppBundle(source, workDir);
-    validateAppBundle(appDir);
-    const target = join50(installDir, APP_BUNDLE_NAME);
-    const staging = join50(installDir, `.${APP_BUNDLE_NAME}.new-${process.pid}`);
-    const backup = join50(installDir, `.${APP_BUNDLE_NAME}.old-${process.pid}`);
-    rmSync6(staging, { recursive: true, force: true });
-    rmSync6(backup, { recursive: true, force: true });
-    let wasRunning;
-    let replaced;
-    try {
-      run("ditto", [appDir, staging]);
-      try {
-        run("xattr", ["-dr", "com.apple.quarantine", staging]);
-      } catch {
-      }
-      wasRunning = isAppRunning();
-      replaced = existsSync52(target);
-      if (replaced) renameSync8(target, backup);
-      renameSync8(staging, target);
-    } catch (e) {
-      if (existsSync52(target) === false && existsSync52(backup)) {
-        try {
-          renameSync8(backup, target);
-        } catch {
-        }
-      }
-      rmSync6(staging, { recursive: true, force: true });
-      throw e;
-    }
-    rmSync6(backup, { recursive: true, force: true });
-    const version = readBundleVersion(target);
-    writeAppManifest(
-      {
-        version: version ?? "unknown",
-        path: target,
-        installedAt: Date.now(),
-        source: opts.sourceLabel ?? "local"
-      },
-      home
-    );
-    const signatureValid = verifyCodesign(target);
-    return { version, path: target, replaced, wasRunning, signatureValid };
-  } finally {
-    rmSync6(workDir, { recursive: true, force: true });
-  }
-}
-function versionFromTag(tag) {
-  return tag.replace(/^v/, "");
-}
-async function fetchLatestRelease(repo = APP_RELEASE_REPO, fetchImpl = fetch) {
-  try {
-    const res = await fetchImpl(`https://api.github.com/repos/${repo}/releases/latest`, {
-      headers: { Accept: "application/vnd.github+json", "User-Agent": "dreamcontext-cli" }
-    });
-    if (!res.ok) return null;
-    const json = await res.json();
-    if (!json || typeof json.tag_name !== "string" || !Array.isArray(json.assets)) return null;
-    return json;
-  } catch {
-    return null;
-  }
-}
-async function downloadTo(url, destFile, fetchImpl = fetch) {
-  const res = await fetchImpl(url, { headers: { "User-Agent": "dreamcontext-cli" } });
-  if (!res.ok) throw new Error(`Download failed (${res.status}): ${url}`);
-  const buf = Buffer.from(await res.arrayBuffer());
-  writeFileSync32(destFile, buf);
-}
-function sha256File(file) {
-  return createHash2("sha256").update(readFileSync40(file)).digest("hex");
-}
-async function downloadLatestArtifact(repo = APP_RELEASE_REPO, fetchImpl = fetch) {
-  const plat = detectPlatform();
-  if (plat.os !== "darwin") return null;
-  const release2 = await fetchLatestRelease(repo, fetchImpl);
-  if (!release2) return null;
-  const assetName = pickAssetForArch(release2.assets.map((a) => a.name), plat.arch);
-  if (!assetName) return null;
-  const asset = release2.assets.find((a) => a.name === assetName);
-  const sumAsset = release2.assets.find((a) => a.name === `${assetName}.sha256`);
-  if (!sumAsset) {
-    throw new Error(
-      `Release ${release2.tag_name} is missing ${assetName}.sha256 \u2014 refusing to install an unverified binary.`
-    );
-  }
-  const workDir = mkdtempSync(join50(tmpdir(), "dc-app-dl-"));
-  try {
-    const archivePath = join50(workDir, assetName);
-    await downloadTo(asset.browser_download_url, archivePath, fetchImpl);
-    const sumFile = join50(workDir, `${assetName}.sha256`);
-    await downloadTo(sumAsset.browser_download_url, sumFile, fetchImpl);
-    const expected = readFileSync40(sumFile, "utf-8").trim().split(/\s+/)[0].toLowerCase();
-    const actual = sha256File(archivePath).toLowerCase();
-    if (!expected || expected !== actual) {
-      throw new Error(`Checksum mismatch for ${assetName}: expected ${expected || "(empty)"}, got ${actual}`);
-    }
-    return { archivePath, version: versionFromTag(release2.tag_name) };
-  } catch (e) {
-    rmSync6(workDir, { recursive: true, force: true });
-    throw e;
-  }
-}
-function appAutoUpdateEnabled(env2 = process.env) {
-  if (env2.DREAMCONTEXT_VERSION_CHECK === "0") return false;
-  return env2.DREAMCONTEXT_APP_AUTO_UPDATE !== "0";
-}
-function defaultAppUpdateSpawner() {
-  const child = spawnProcess(process.execPath, [process.argv[1], "app", "update"], {
-    detached: true,
-    stdio: "ignore"
-  });
-  child.unref();
-}
-function maybeTriggerAppUpdate(env2 = process.env, deps = {}) {
-  try {
-    if (detectPlatform().os !== "darwin") return false;
-    if (!appAutoUpdateEnabled(env2)) return false;
-    const installed = deps.manifest !== void 0 ? deps.manifest : readAppManifest();
-    if (!installed) return false;
-    (deps.spawner ?? defaultAppUpdateSpawner)();
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function doInstall(from, dir) {
-  const plat = detectPlatform();
-  if (plat.os !== "darwin") {
-    console.log(source_default.yellow("The desktop app is currently macOS-only. Windows/Linux support is planned."));
-    return;
-  }
-  let tempToClean = null;
-  let source = from;
-  let sourceLabel = "local";
-  if (!source) {
-    console.log(source_default.cyan("Fetching the latest desktop app from GitHub Releases\u2026"));
-    let dl = null;
-    try {
-      dl = await downloadLatestArtifact();
-    } catch (e) {
-      console.log(source_default.red(`Install aborted: ${e.message}`));
-      return;
-    }
-    if (!dl) {
-      console.log(
-        source_default.yellow(
-          "No published desktop release found yet.\nBuild one locally and install it with:  dreamcontext app install --from <path-to.app|.tar.gz>"
-        )
-      );
-      return;
-    }
-    source = dl.archivePath;
-    sourceLabel = "github";
-    tempToClean = dirname28(dl.archivePath);
-  }
-  try {
-    const res = installAppBundle(source, { installDir: dir, sourceLabel });
-    console.log(source_default.green(`\u2713 Installed dreamcontext-beta ${res.version ?? ""}`.trim()) + source_default.dim(` \u2192 ${res.path}`));
-    if (res.signatureValid === false) {
-      console.log(
-        source_default.yellow(
-          "Warning: the installed app failed code-signature verification. It may still launch (ad-hoc),\nbut the published artifact should be properly ad-hoc deep-signed at build time."
-        )
-      );
-    }
-    if (res.wasRunning) {
-      console.log(source_default.yellow("The app is currently running \u2014 restart it to apply the update."));
-    } else {
-      console.log(source_default.dim(`Launch it:  open "${res.path}"`));
-    }
-  } finally {
-    if (tempToClean) rmSync6(tempToClean, { recursive: true, force: true });
-  }
-}
-async function doUpdate(from, dir) {
-  const installed = readAppManifest();
-  if (!installed) {
-    console.log(source_default.dim("No installed app recorded \u2014 running a fresh install."));
-    await doInstall(from, dir);
-    return;
-  }
-  if (from) {
-    await doInstall(from, dir);
-    return;
-  }
-  let dl = null;
-  try {
-    dl = await downloadLatestArtifact();
-  } catch (e) {
-    console.log(source_default.red(`Update aborted: ${e.message}`));
-    return;
-  }
-  if (!dl) {
-    console.log(source_default.yellow("No published desktop release available to update to."));
-    return;
-  }
-  try {
-    if (compareVersions(installed.version, dl.version) >= 0) {
-      console.log(source_default.green(`Desktop app is up to date (${installed.version}).`));
-      return;
-    }
-    const res = installAppBundle(dl.archivePath, { installDir: dir, sourceLabel: "github" });
-    console.log(source_default.green(`\u2713 Updated dreamcontext-beta ${installed.version} \u2192 ${res.version ?? dl.version}`));
-    if (res.wasRunning) console.log(source_default.yellow("Restart the app to apply the update."));
-  } finally {
-    rmSync6(dirname28(dl.archivePath), { recursive: true, force: true });
-  }
-}
-function doStatus() {
-  const installed = readAppManifest();
-  if (!installed) {
-    console.log("Desktop app: not installed (run `dreamcontext app install`).");
-    return;
-  }
-  const onDisk = existsSync52(installed.path);
-  console.log(`Desktop app: ${installed.version}`);
-  console.log(`  path:      ${installed.path}${onDisk ? "" : source_default.red("  (missing!)")}`);
-  console.log(`  source:    ${installed.source}`);
-  console.log(`  running:   ${isAppRunning() ? "yes" : "no"}`);
-}
-function registerAppCommand(program2) {
-  const app = program2.command("app").description("Manage the dreamcontext desktop app (install / update / status)");
-  app.command("install").description("Install the desktop app to ~/Applications (no quarantine, no admin)").option("--from <path>", "Install from a local .app, .tar.gz, or .zip instead of GitHub Releases").option("--dir <dir>", "Install directory (default: ~/Applications)").action(async (opts) => {
-    await doInstall(opts.from, opts.dir);
-  });
-  app.command("update").description("Update the installed desktop app to the latest version").option("--from <path>", "Update from a local artifact instead of GitHub Releases").option("--dir <dir>", "Install directory (default: ~/Applications)").action(async (opts) => {
-    await doUpdate(opts.from, opts.dir);
-  });
-  app.command("status").description("Show the installed desktop app version and state").action(() => {
-    doStatus();
-  });
-}
-var APP_BUNDLE_NAME, APP_RELEASE_REPO;
-var init_app = __esm({
-  "src/cli/commands/app.ts"() {
-    "use strict";
-    init_source();
-    init_version_check();
-    APP_BUNDLE_NAME = "dreamcontext-beta.app";
-    APP_RELEASE_REPO = "meanllbrl/dreamcontext";
-  }
-});
-
 // src/cli/commands/asset-drift.ts
 import { mkdtempSync as mkdtempSync2, rmSync as rmSync7, existsSync as existsSync53, readFileSync as readFileSync41, readdirSync as readdirSync13 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
@@ -39988,7 +40036,7 @@ var init_asset_drift = __esm({
 
 // src/cli/commands/hook.ts
 import { readFileSync as readFileSync42, existsSync as existsSync54, statSync as statSync7 } from "fs";
-import { execFileSync as execFileSync4, spawn as spawn3 } from "child_process";
+import { execFileSync as execFileSync5, spawn as spawn3 } from "child_process";
 import { get as httpGet } from "http";
 import { dirname as dirname30, resolve as resolve10, join as join52, extname as extname2, basename as basename16, relative as relative4 } from "path";
 function readStdin() {
@@ -40143,13 +40191,13 @@ function runFormatter(detection, filePath) {
     if (detection.type === "biome") {
       const localBin = resolveLocalBin("biome", detection.projectRoot);
       if (localBin) {
-        execFileSync4(localBin, ["format", "--write", filePath], {
+        execFileSync5(localBin, ["format", "--write", filePath], {
           cwd: detection.projectRoot,
           timeout: 15e3,
           stdio: ["pipe", "pipe", "pipe"]
         });
       } else {
-        execFileSync4("npx", ["@biomejs/biome", "format", "--write", filePath], {
+        execFileSync5("npx", ["@biomejs/biome", "format", "--write", filePath], {
           cwd: detection.projectRoot,
           timeout: 15e3,
           stdio: ["pipe", "pipe", "pipe"]
@@ -40158,13 +40206,13 @@ function runFormatter(detection, filePath) {
     } else {
       const localBin = resolveLocalBin("prettier", detection.projectRoot);
       if (localBin) {
-        execFileSync4(localBin, ["--write", filePath], {
+        execFileSync5(localBin, ["--write", filePath], {
           cwd: detection.projectRoot,
           timeout: 15e3,
           stdio: ["pipe", "pipe", "pipe"]
         });
       } else {
-        execFileSync4("npx", ["prettier", "--write", filePath], {
+        execFileSync5("npx", ["prettier", "--write", filePath], {
           cwd: detection.projectRoot,
           timeout: 15e3,
           stdio: ["pipe", "pipe", "pipe"]
@@ -40184,14 +40232,14 @@ function runTscCheckWithConfig(filePath, tsconfigPath) {
     const localBin = resolveLocalBin("tsc", projectRoot);
     const args = ["--noEmit", "--pretty", "false", "--incremental"];
     if (localBin) {
-      execFileSync4(localBin, args, {
+      execFileSync5(localBin, args, {
         cwd: projectRoot,
         timeout: 3e4,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       });
     } else {
-      execFileSync4("npx", ["tsc", ...args], {
+      execFileSync5("npx", ["tsc", ...args], {
         cwd: projectRoot,
         timeout: 3e4,
         encoding: "utf-8",
@@ -57139,7 +57187,7 @@ var init_rem_sleep2 = __esm({
 });
 
 // src/lib/marketing/git-guard.ts
-import { execFileSync as execFileSync5 } from "child_process";
+import { execFileSync as execFileSync6 } from "child_process";
 function isBlockedMarketingPath(repoRelPath) {
   if (typeof repoRelPath !== "string" || repoRelPath.length === 0) return false;
   const norm2 = repoRelPath.replace(/\\/g, "/");
@@ -57153,7 +57201,7 @@ function isBlockedMarketingPath(repoRelPath) {
 function getStagedFiles(cwd) {
   let raw;
   try {
-    raw = execFileSync5("git", ["diff", "--cached", "--name-only", "-z"], {
+    raw = execFileSync6("git", ["diff", "--cached", "--name-only", "-z"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -57178,11 +57226,11 @@ var init_git_guard = __esm({
 
 // src/cli/commands/marketing/hooks.ts
 import { existsSync as existsSync87, readFileSync as readFileSync66, writeFileSync as writeFileSync44, chmodSync as chmodSync3, mkdirSync as mkdirSync39, statSync as statSync18 } from "fs";
-import { execFileSync as execFileSync6 } from "child_process";
+import { execFileSync as execFileSync7 } from "child_process";
 import { join as join78 } from "path";
 function findGitDir(cwd = process.cwd()) {
   try {
-    const out = execFileSync6("git", ["rev-parse", "--git-dir"], {
+    const out = execFileSync7("git", ["rev-parse", "--git-dir"], {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -57869,10 +57917,39 @@ var init_memory = __esm({
 });
 
 // src/cli/commands/upgrade.ts
-import { execFileSync as execFileSync8 } from "child_process";
+import { execFileSync as execFileSync9 } from "child_process";
 import { dirname as dirname52 } from "path";
+import { existsSync as existsSync91 } from "fs";
 function defaultInstaller(args) {
-  execFileSync8("npm", args, { stdio: "inherit" });
+  execFileSync9("npm", args, { stdio: "inherit" });
+}
+function defaultProjectUpdater(vault) {
+  if (!existsSync91(vault.path)) {
+    return { vault, ok: false, error: "project folder no longer exists" };
+  }
+  try {
+    execFileSync9("npx", ["dreamcontext", "update", "--yes"], {
+      cwd: vault.path,
+      stdio: "inherit"
+    });
+    return { vault, ok: true };
+  } catch (e) {
+    return { vault, ok: false, error: e.message };
+  }
+}
+async function defaultConfirmAll(count) {
+  return esm_default4({
+    message: `Also refresh ${count} registered dreamcontext project(s) to the new version?`,
+    default: true
+  });
+}
+function defaultAppUpdater() {
+  try {
+    execFileSync9("npx", ["dreamcontext", "app", "update"], { stdio: "inherit" });
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
 }
 function projectRootForCache() {
   const contextDir = resolveContextRoot();
@@ -57881,7 +57958,7 @@ function projectRootForCache() {
 function defaultLiveLatest() {
   let latest = null;
   try {
-    const raw = execFileSync8("npm", ["view", "dreamcontext", "version"], {
+    const raw = execFileSync9("npm", ["view", "dreamcontext", "version"], {
       timeout: 5e3,
       encoding: "utf-8"
     });
@@ -57905,7 +57982,62 @@ function defaultLiveLatest() {
   }
   return latest;
 }
-function runUpgrade(check2, opts) {
+async function maybeUpdateApp(opts) {
+  const installed = (opts?.appInstalledCheck ?? (() => readAppManifest() !== null))();
+  if (!installed) return;
+  const auto = opts?.yes === true;
+  const interactive = process.stdin.isTTY === true;
+  if (!auto && !interactive) {
+    console.log(
+      source_default.dim(
+        "Tip: the desktop app is installed \u2014 run `dreamcontext upgrade --yes` (or `dreamcontext app update`) to update it too."
+      )
+    );
+    return;
+  }
+  console.log(source_default.cyan("\n\u21BB Updating the desktop app\u2026"));
+  const result = (opts?.appUpdater ?? defaultAppUpdater)();
+  if (result.ok) console.log(source_default.green("\u2713 Desktop app updated."));
+  else console.log(source_default.yellow(`  \u26A0 Desktop app update skipped: ${result.error ?? "failed"}`));
+}
+async function maybeUpdateAllProjects(opts) {
+  const vaults = (opts?.vaultLister ?? (() => listVaults()))();
+  if (vaults.length === 0) return;
+  const auto = opts?.yes === true;
+  const canPrompt = process.stdin.isTTY === true || opts?.confirmAll !== void 0;
+  if (!auto && !canPrompt) {
+    console.log(
+      source_default.dim(
+        `Tip: ${vaults.length} registered project(s) were not refreshed. Run \`dreamcontext upgrade --yes\` to refresh them all, or \`dreamcontext update\` in each.`
+      )
+    );
+    return;
+  }
+  let proceed = auto;
+  if (!proceed) {
+    const confirmFn = opts?.confirmAll ?? defaultConfirmAll;
+    proceed = await confirmFn(vaults.length);
+  }
+  if (!proceed) {
+    console.log(source_default.dim("Skipped refreshing other projects. Run `dreamcontext update` in any project later."));
+    return;
+  }
+  const updater = opts?.projectUpdater ?? defaultProjectUpdater;
+  const results = [];
+  for (const vault of vaults) {
+    console.log(source_default.cyan(`
+\u21BB Refreshing ${source_default.bold(vault.name)} (${vault.path})...`));
+    results.push(updater(vault));
+  }
+  const ok = results.filter((r) => r.ok);
+  const failed = results.filter((r) => !r.ok);
+  console.log("");
+  console.log(source_default.green(`\u2713 Refreshed ${ok.length}/${results.length} project(s).`));
+  for (const f of failed) {
+    console.log(source_default.yellow(`  \u26A0 ${f.vault.name}: ${f.error ?? "update failed"}`));
+  }
+}
+async function runUpgrade(check2, opts) {
   const installer = opts?.installer ?? defaultInstaller;
   if (check2) {
     const current = dreamcontextVersion();
@@ -57921,20 +58053,26 @@ function runUpgrade(check2, opts) {
   console.log(source_default.cyan("Installing dreamcontext@latest via npm..."));
   installer(["install", "-g", "dreamcontext@latest"]);
   console.log("");
-  console.log(source_default.green("CLI upgraded. Run") + " dreamcontext update " + source_default.green("to refresh your project files."));
+  console.log(source_default.green("CLI upgraded."));
+  await maybeUpdateApp(opts);
+  await maybeUpdateAllProjects(opts);
+  console.log(source_default.dim("\nIn each project, the new files take effect next session (hooks re-read them)."));
 }
 function registerUpgradeCommand(program2) {
-  program2.command("upgrade").description("Upgrade the dreamcontext CLI itself to the latest published version").option("--check", "Print current vs latest version and exit without installing").option("-y, --yes", "Non-interactive (no prompts; reserved for future use)").action((options2, _cmd, opts) => {
-    runUpgrade(Boolean(options2.check), opts);
+  program2.command("upgrade").description("Upgrade the dreamcontext CLI, then offer to refresh every registered project to match").option("--check", "Print current vs latest version and exit without installing").option("-y, --yes", "Refresh every registered project without prompting (non-interactive)").action(async (options2, _cmd, opts) => {
+    await runUpgrade(Boolean(options2.check), { ...opts, yes: options2.yes });
   });
 }
 var init_upgrade = __esm({
   "src/cli/commands/upgrade.ts"() {
     "use strict";
     init_source();
+    init_esm16();
     init_manifest();
     init_version_check();
     init_context_path();
+    init_vaults();
+    init_app();
   }
 });
 
@@ -58502,7 +58640,7 @@ var init_people = __esm({
 
 // src/cli/commands/config.ts
 import { dirname as dirname54 } from "path";
-import { existsSync as existsSync91, readFileSync as readFileSync69, writeFileSync as writeFileSync46 } from "fs";
+import { existsSync as existsSync92, readFileSync as readFileSync69, writeFileSync as writeFileSync46 } from "fs";
 import { join as join82 } from "path";
 function resolveProjectRoot() {
   const contextRoot = resolveContextRoot();
@@ -58764,7 +58902,7 @@ function registerConfigCommand(program2) {
     let userMdSynced = false;
     if (contextRoot) {
       const userMdPath = join82(contextRoot, "core", "1.user.md");
-      if (existsSync91(userMdPath)) {
+      if (existsSync92(userMdPath)) {
         try {
           const before = readFileSync69(userMdPath, "utf-8");
           const after = ensurePeopleSection(before, roster);
@@ -58911,7 +59049,7 @@ var init_config4 = __esm({
 });
 
 // src/lib/feedback.ts
-import { execFileSync as execFileSync9 } from "child_process";
+import { execFileSync as execFileSync10 } from "child_process";
 import { platform, release, arch } from "os";
 function isFeedbackCategory(value) {
   return Object.prototype.hasOwnProperty.call(CATEGORY_META, value);
@@ -59068,7 +59206,7 @@ var init_feedback = __esm({
     FEEDBACK_CATEGORIES = Object.keys(CATEGORY_META);
     defaultRunner = (cmd, args) => {
       try {
-        const stdout = execFileSync9(cmd, args, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+        const stdout = execFileSync10(cmd, args, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
         return { ok: true, stdout, stderr: "" };
       } catch (err) {
         const e = err;