dreamcontext 0.8.1 → 0.8.3

package/dist/index.js

@@ -18458,11 +18458,11 @@ var init_install_claude_md = __esm({
 import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync7 } from "fs";
 import { dirname as dirname4, join as join6 } from "path";
 function applyClaudeAutoMemory(projectRoot, disable) {
-  const settingsPath = join6(projectRoot, ".claude", "settings.json");
+  const settingsPath2 = join6(projectRoot, ".claude", "settings.json");
   let settings = {};
-  if (existsSync6(settingsPath)) {
+  if (existsSync6(settingsPath2)) {
     try {
-      const parsed = JSON.parse(readFileSync7(settingsPath, "utf-8"));
+      const parsed = JSON.parse(readFileSync7(settingsPath2, "utf-8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         settings = parsed;
       }
@@ -18473,8 +18473,8 @@ function applyClaudeAutoMemory(projectRoot, disable) {
   const desired = !disable;
   if (settings.autoMemoryEnabled === desired) return false;
   settings.autoMemoryEnabled = desired;
-  mkdirSync4(dirname4(settingsPath), { recursive: true });
-  writeFileSync7(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  mkdirSync4(dirname4(settingsPath2), { recursive: true });
+  writeFileSync7(settingsPath2, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   return true;
 }
 var init_claude_settings = __esm({
@@ -22458,12 +22458,12 @@ async function resolvePlatforms(projectRoot, raw) {
   return platforms;
 }
 function ensureClaudeHooks(projectRoot) {
-  const settingsPath = join9(projectRoot, ".claude", "settings.json");
+  const settingsPath2 = join9(projectRoot, ".claude", "settings.json");
   const result = { added: [], migrated: false };
   let settings = {};
-  if (existsSync9(settingsPath)) {
+  if (existsSync9(settingsPath2)) {
     try {
-      settings = JSON.parse(readFileSync10(settingsPath, "utf-8"));
+      settings = JSON.parse(readFileSync10(settingsPath2, "utf-8"));
     } catch {
       settings = {};
     }
@@ -22497,7 +22497,7 @@ function ensureClaudeHooks(projectRoot) {
     }
   }
   mkdirSync6(join9(projectRoot, ".claude"), { recursive: true });
-  writeFileSync9(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  writeFileSync9(settingsPath2, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   return result;
 }
 function findPackageFile(subdir, filename) {
@@ -34672,6 +34672,170 @@ var init_migration_runner = __esm({
   }
 });
 
+// src/lib/sleep-consolidation.ts
+function sleepinessLevel(debt) {
+  if (debt <= 3) return "Alert";
+  if (debt <= 6) return "Drowsy";
+  if (debt <= 9) return "Sleepy";
+  return "Must Sleep";
+}
+function sleepinessRange(debt) {
+  if (debt <= 3) return "0-3";
+  if (debt <= 6) return "4-6";
+  if (debt <= 9) return "7-9";
+  return "10+";
+}
+function recomputeDebt(sessions) {
+  return sessions.reduce((sum, s) => sum + (s.score ?? 0), 0);
+}
+function depthFromDebt(debt) {
+  if (debt <= 3) return "light";
+  if (debt <= 9) return "standard";
+  return "deep";
+}
+function consolidationDepth(debt, opts = {}) {
+  const base = depthFromDebt(debt);
+  if (opts.userRequestedDeep) {
+    return { depth: "deep", reason: "user requested deep consolidation", source: "user" };
+  }
+  const bump = Math.max(0, Math.min(2, opts.agentBump ?? 0));
+  if (bump > 0) {
+    const baseIdx = DEPTH_ORDER.indexOf(base);
+    const idx = Math.min(DEPTH_ORDER.length - 1, baseIdx + bump);
+    return {
+      depth: DEPTH_ORDER[idx],
+      reason: `agent bumped depth by ${bump} tier(s) from ${base}`,
+      source: "agent"
+    };
+  }
+  return { depth: base, reason: `debt ${debt} \u2192 ${base}`, source: "debt" };
+}
+function isDestructiveAllowed(depth) {
+  return depth === "deep";
+}
+function applyConsolidation(state, epoch) {
+  const next = cloneState(state);
+  let sessionsProcessed = 0;
+  let bookmarksProcessed = 0;
+  let processedSessionIds = [];
+  if (epoch) {
+    const processedSessions = next.sessions.filter((s) => !s.stopped_at || s.stopped_at <= epoch);
+    sessionsProcessed = processedSessions.length;
+    processedSessionIds = processedSessions.map((s) => s.session_id);
+    bookmarksProcessed = next.bookmarks.filter((b) => b.created_at <= epoch).length;
+    next.sessions = next.sessions.filter((s) => {
+      if (!s.stopped_at) return false;
+      return s.stopped_at > epoch;
+    });
+    next.bookmarks = next.bookmarks.filter((b) => b.created_at > epoch);
+    next.dashboard_changes = next.dashboard_changes.filter((c) => c.timestamp > epoch);
+    next.debt = recomputeDebt(next.sessions);
+  } else {
+    sessionsProcessed = next.sessions.length;
+    processedSessionIds = next.sessions.map((s) => s.session_id);
+    bookmarksProcessed = next.bookmarks.length;
+    next.sessions = [];
+    next.bookmarks = [];
+    next.dashboard_changes = [];
+    next.debt = 0;
+  }
+  next.triggers = next.triggers.filter((t) => t.fired_count < t.max_fires);
+  return { state: next, sessionsProcessed, bookmarksProcessed, processedSessionIds };
+}
+function upsertSessionOnStop(state, input2) {
+  const next = cloneState(state);
+  const existing = next.sessions.findIndex((s) => s.session_id === input2.session_id);
+  if (existing >= 0) {
+    const oldScore = next.sessions[existing].score ?? 0;
+    next.debt = Math.max(0, next.debt - oldScore);
+    const existingSlugs = next.sessions[existing].task_slugs ?? [];
+    next.sessions[existing] = {
+      ...next.sessions[existing],
+      transcript_path: input2.transcript_path,
+      stopped_at: input2.stopped_at,
+      last_assistant_message: input2.last_assistant_message,
+      change_count: input2.change_count,
+      tool_count: input2.tool_count,
+      score: input2.score,
+      task_slugs: [.../* @__PURE__ */ new Set([...existingSlugs, ...input2.task_slugs])]
+    };
+    next.debt += input2.score;
+  } else {
+    next.sessions.unshift({
+      session_id: input2.session_id,
+      transcript_path: input2.transcript_path,
+      stopped_at: input2.stopped_at,
+      last_assistant_message: input2.last_assistant_message,
+      change_count: input2.change_count,
+      tool_count: input2.tool_count,
+      score: input2.score,
+      task_slugs: input2.task_slugs
+    });
+    next.debt += input2.score;
+    next.sessions_since_last_sleep = (next.sessions_since_last_sleep || 0) + 1;
+  }
+  return next;
+}
+function appendCompactionRecord(state, record) {
+  const next = cloneState(state);
+  next.compaction_log.unshift(record);
+  if (next.compaction_log.length > COMPACTION_LOG_CAP) {
+    next.compaction_log = next.compaction_log.slice(0, COMPACTION_LOG_CAP);
+  }
+  return next;
+}
+function validateSleepAdd(scoreStr, desc) {
+  const score = parseInt(scoreStr, 10);
+  if (isNaN(score) || score < 1 || score > 3) {
+    return { ok: false, error: "Score must be 1, 2, or 3." };
+  }
+  if (!desc.trim()) {
+    return { ok: false, error: "Description is required." };
+  }
+  return { ok: true };
+}
+function buildHistoryEntry(prevDebt, result, summary, today2) {
+  return {
+    date: today2,
+    consolidated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    summary: summary.trim(),
+    debt_before: prevDebt,
+    debt_after: result.state.debt,
+    sessions_processed: result.sessionsProcessed,
+    bookmarks_processed: result.bookmarksProcessed,
+    session_ids: result.processedSessionIds
+  };
+}
+function finalizeSleepState(state, summary, today2) {
+  const next = cloneState(state);
+  next.last_sleep = today2;
+  next.last_sleep_summary = summary.trim();
+  next.sleep_started_at = null;
+  next.sessions_since_last_sleep = 0;
+  next.consolidation_depth = null;
+  return next;
+}
+function cloneState(state) {
+  return {
+    ...state,
+    sessions: state.sessions.map((s) => ({ ...s, task_slugs: [...s.task_slugs ?? []] })),
+    bookmarks: state.bookmarks.map((b) => ({ ...b })),
+    triggers: state.triggers.map((t) => ({ ...t })),
+    knowledge_access: { ...state.knowledge_access },
+    dashboard_changes: state.dashboard_changes.map((c) => ({ ...c })),
+    compaction_log: state.compaction_log.map((c) => ({ ...c })),
+    pendingMigrationNotices: [...state.pendingMigrationNotices]
+  };
+}
+var DEPTH_ORDER, COMPACTION_LOG_CAP;
+var init_sleep_consolidation = __esm({
+  "src/lib/sleep-consolidation.ts"() {
+    "use strict";
+    DEPTH_ORDER = ["light", "standard", "deep"];
+    COMPACTION_LOG_CAP = 20;
+  }
+});
+
 // src/cli/commands/sleep.ts
 import { existsSync as existsSync37 } from "fs";
 import { join as join37, dirname as dirname18 } from "path";
@@ -34695,6 +34859,7 @@ function freshDefaults() {
     dashboard_changes: [],
     compaction_log: [],
     recall_mode: "haiku",
+    consolidation_depth: null,
     pendingMigrationNotices: []
   };
 }
@@ -34757,25 +34922,13 @@ function bumpKnowledgeAccess(state, slug) {
   state.knowledge_access[slug].last_accessed = today();
   state.knowledge_access[slug].count++;
 }
-function getSleepinessLevel(debt) {
-  if (debt <= 3) return "Alert";
-  if (debt <= 6) return "Drowsy";
-  if (debt <= 9) return "Sleepy";
-  return "Must Sleep";
-}
-function getSleepinessRange(debt) {
-  if (debt <= 3) return "0-3";
-  if (debt <= 6) return "4-6";
-  if (debt <= 9) return "7-9";
-  return "10+";
-}
 function registerSleepCommand(program2) {
   const sleep2 = program2.command("sleep").description("Track sleep debt and consolidation state");
   sleep2.command("status").description("Show current sleep debt level and history").action(() => {
     const root = ensureContextRoot();
     const state = readSleepState(root);
-    const level = getSleepinessLevel(state.debt);
-    const range = getSleepinessRange(state.debt);
+    const level = sleepinessLevel(state.debt);
+    const range = sleepinessRange(state.debt);
     console.log(header("Sleep State"));
     console.log(`  Debt:       ${source_default.bold(String(state.debt))} ${source_default.dim(`(${range})`)} ${source_default.magentaBright(level)}`);
     console.log(`  Last sleep: ${state.last_sleep ? source_default.white(state.last_sleep) : source_default.dim("never")}`);
@@ -34803,16 +34956,13 @@ function registerSleepCommand(program2) {
     }
   });
   sleep2.command("add").argument("<score>", "Debt score to add (1-3)").argument("<description...>", "Description of what happened").description("Record a debt-accumulating action").action((scoreStr, descParts) => {
-    const score = parseInt(scoreStr, 10);
-    if (isNaN(score) || score < 1 || score > 3) {
-      error("Score must be 1, 2, or 3.");
-      return;
-    }
     const description = descParts.join(" ");
-    if (!description.trim()) {
-      error("Description is required.");
+    const valid = validateSleepAdd(scoreStr, description);
+    if (!valid.ok) {
+      error(valid.error);
       return;
     }
+    const score = parseInt(scoreStr, 10);
     const root = ensureContextRoot();
     const state = readSleepState(root);
     state.sessions.unshift({
@@ -34827,7 +34977,7 @@ function registerSleepCommand(program2) {
     });
     state.debt += score;
     writeSleepState(root, state);
-    const level = getSleepinessLevel(state.debt);
+    const level = sleepinessLevel(state.debt);
     success(`Sleep debt: ${state.debt} (${level})`);
     if (state.debt >= 10) {
       warn("Must sleep! Debt is 10+. Consolidation needed.");
@@ -34835,12 +34985,14 @@ function registerSleepCommand(program2) {
       info("Getting sleepy. Consider consolidating soon.");
     }
   });
-  sleep2.command("start").description("Mark beginning of consolidation (sets epoch for safe clearing)").action(() => {
+  sleep2.command("start").description("Mark beginning of consolidation (sets epoch for safe clearing)").option("--deep", "Force a deep consolidation (authorizes destructive knowledge ops)").action((opts) => {
     const root = ensureContextRoot();
     const state = readSleepState(root);
     if (state.sleep_started_at) {
       warn(`Consolidation already in progress (started ${state.sleep_started_at}). Overwriting epoch.`);
     }
+    const decision = consolidationDepth(state.debt, { userRequestedDeep: !!opts.deep });
+    state.consolidation_depth = decision.depth;
     state.pendingMigrationNotices = [];
     const projectRoot = dirname18(root);
     const config = readSetupConfig(projectRoot);
@@ -34864,6 +35016,10 @@ function registerSleepCommand(program2) {
     state.sleep_started_at = (/* @__PURE__ */ new Date()).toISOString();
     writeSleepState(root, state);
     success(`Consolidation epoch set: ${state.sleep_started_at}`);
+    info(`Consolidation depth: ${decision.depth} (source: ${decision.source}) \u2014 ${decision.reason}`);
+    if (decision.depth !== "deep") {
+      info("Light/standard consolidation: do NOT merge/summarize-replace/delete knowledge \u2014 flag candidates in the report instead.");
+    }
   });
   sleep2.command("done").argument("<summary...>", "Summary of what was consolidated").description("Mark consolidation complete, reset debt").action(async (summaryParts) => {
     const summary = summaryParts.join(" ");
@@ -34875,52 +35031,17 @@ function registerSleepCommand(program2) {
     const state = readSleepState(root);
     const previousDebt = state.debt;
     const epoch = state.sleep_started_at;
-    let sessionsProcessed = 0;
-    let bookmarksProcessed = 0;
-    let processedSessionIds = [];
-    if (epoch) {
-      const processedSessions = state.sessions.filter((s) => !s.stopped_at || s.stopped_at <= epoch);
-      sessionsProcessed = processedSessions.length;
-      processedSessionIds = processedSessions.map((s) => s.session_id);
-      bookmarksProcessed = state.bookmarks.filter((b) => b.created_at <= epoch).length;
-      state.sessions = state.sessions.filter((s) => {
-        if (!s.stopped_at) return false;
-        return s.stopped_at > epoch;
-      });
-      state.bookmarks = state.bookmarks.filter((b) => b.created_at > epoch);
-      state.dashboard_changes = state.dashboard_changes.filter((c) => c.timestamp > epoch);
-      state.debt = state.sessions.reduce((sum, s) => sum + (s.score ?? 0), 0);
-    } else {
-      sessionsProcessed = state.sessions.length;
-      processedSessionIds = state.sessions.map((s) => s.session_id);
-      bookmarksProcessed = state.bookmarks.length;
-      state.sessions = [];
-      state.bookmarks = [];
-      state.dashboard_changes = [];
-      state.debt = 0;
-    }
-    state.triggers = state.triggers.filter((t) => t.fired_count < t.max_fires);
+    const result = applyConsolidation(state, epoch);
+    const today_ = today();
     const history = readSleepHistory(root);
-    history.unshift({
-      date: today(),
-      consolidated_at: (/* @__PURE__ */ new Date()).toISOString(),
-      summary: summary.trim(),
-      debt_before: previousDebt,
-      debt_after: state.debt,
-      sessions_processed: sessionsProcessed,
-      bookmarks_processed: bookmarksProcessed,
-      session_ids: processedSessionIds
-    });
+    history.unshift(buildHistoryEntry(previousDebt, result, summary, today_));
     writeSleepHistory(root, history);
-    state.last_sleep = today();
-    state.last_sleep_summary = summary.trim();
-    state.sleep_started_at = null;
-    state.sessions_since_last_sleep = 0;
-    writeSleepState(root, state);
-    if (epoch && state.sessions.length > 0) {
-      success(`Consolidation complete. Debt reduced from ${previousDebt} to ${state.debt}. ${state.sessions.length} post-epoch session(s) preserved.`);
+    const finalState = finalizeSleepState(result.state, summary, today_);
+    writeSleepState(root, finalState);
+    if (epoch && finalState.sessions.length > 0) {
+      success(`Consolidation complete. Debt reduced from ${previousDebt} to ${finalState.debt}. ${finalState.sessions.length} post-epoch session(s) preserved.`);
     } else {
-      success(`Consolidation complete. Debt reset from ${previousDebt} to ${state.debt}.`);
+      success(`Consolidation complete. Debt reset from ${previousDebt} to ${finalState.debt}.`);
     }
     try {
       const backend = getTaskBackend(root);
@@ -35012,6 +35133,7 @@ var init_sleep = __esm({
     init_migration_runner();
     init_setup_config();
     init_manifest();
+    init_sleep_consolidation();
   }
 });
 
@@ -37695,6 +37817,53 @@ var init_snapshot2 = __esm({
   }
 });
 
+// src/lib/salience.ts
+function clamp(text) {
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  return oneLine.length <= MAX_MESSAGE_CHARS ? oneLine : oneLine.slice(0, MAX_MESSAGE_CHARS - 1) + "\u2026";
+}
+function detectSalience(distilled) {
+  const moments = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (message, salience) => {
+    const clamped = clamp(message);
+    if (!clamped) return;
+    const key = `${salience}::${clamped.toLowerCase()}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    moments.push({ message: clamped, salience });
+  };
+  for (const msg of distilled.userMessages) {
+    if (CORRECTION_RE.test(msg)) {
+      push(`User correction: ${msg}`, 2);
+    }
+  }
+  if (distilled.errors.length > 0 && distilled.codeChanges.length > 0) {
+    const firstError = distilled.errors[0];
+    push(`Error resolved by code change: ${firstError}`, 1);
+  }
+  const decisionSources = [
+    ...distilled.agentDecisions.filter((d) => !d.startsWith("[thinking]")),
+    ...distilled.userMessages
+  ];
+  for (const src of decisionSources) {
+    if (DECISION_RE.test(src)) {
+      push(`Decision: ${src}`, 2);
+    }
+  }
+  return moments.slice(0, MAX_MOMENTS);
+}
+var CORRECTION_RE, DECISION_RE, MAX_MOMENTS, MAX_MESSAGE_CHARS;
+var init_salience = __esm({
+  "src/lib/salience.ts"() {
+    "use strict";
+    CORRECTION_RE = /\b(no|actually|wrong|instead|hayır|yanlış|değil)\b/i;
+    DECISION_RE = /\b(decided|chose|switched to|will use|karar|seçtik)\b/i;
+    MAX_MOMENTS = 5;
+    MAX_MESSAGE_CHARS = 200;
+  }
+});
+
 // src/cli/commands/transcript.ts
 import { readFileSync as readFileSync35, existsSync as existsSync46, statSync as statSync6 } from "fs";
 function distillTranscript(transcriptPath, sinceTimestamp) {
@@ -38889,53 +39058,6 @@ var init_session_digest = __esm({
   }
 });
 
-// src/lib/salience.ts
-function clamp(text) {
-  const oneLine = text.replace(/\s+/g, " ").trim();
-  return oneLine.length <= MAX_MESSAGE_CHARS ? oneLine : oneLine.slice(0, MAX_MESSAGE_CHARS - 1) + "\u2026";
-}
-function detectSalience(distilled) {
-  const moments = [];
-  const seen = /* @__PURE__ */ new Set();
-  const push = (message, salience) => {
-    const clamped = clamp(message);
-    if (!clamped) return;
-    const key = `${salience}::${clamped.toLowerCase()}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    moments.push({ message: clamped, salience });
-  };
-  for (const msg of distilled.userMessages) {
-    if (CORRECTION_RE.test(msg)) {
-      push(`User correction: ${msg}`, 2);
-    }
-  }
-  if (distilled.errors.length > 0 && distilled.codeChanges.length > 0) {
-    const firstError = distilled.errors[0];
-    push(`Error resolved by code change: ${firstError}`, 1);
-  }
-  const decisionSources = [
-    ...distilled.agentDecisions.filter((d) => !d.startsWith("[thinking]")),
-    ...distilled.userMessages
-  ];
-  for (const src of decisionSources) {
-    if (DECISION_RE.test(src)) {
-      push(`Decision: ${src}`, 2);
-    }
-  }
-  return moments.slice(0, MAX_MOMENTS);
-}
-var CORRECTION_RE, DECISION_RE, MAX_MOMENTS, MAX_MESSAGE_CHARS;
-var init_salience = __esm({
-  "src/lib/salience.ts"() {
-    "use strict";
-    CORRECTION_RE = /\b(no|actually|wrong|instead|hayır|yanlış|değil)\b/i;
-    DECISION_RE = /\b(decided|chose|switched to|will use|karar|seçtik)\b/i;
-    MAX_MOMENTS = 5;
-    MAX_MESSAGE_CHARS = 200;
-  }
-});
-
 // src/lib/marketing/path-guards.ts
 import { existsSync as existsSync49, realpathSync } from "fs";
 import { basename as basename14, dirname as dirname24, resolve as resolve8, sep as sep5 } from "path";
@@ -39498,15 +39620,76 @@ function analyzeTranscript(transcriptPath) {
     for (const m of content.matchAll(/"file_path"\s*:\s*"[^"]*_dream_context\/state\/([a-z0-9][a-z0-9-]*)\.md"/g)) {
       slugs.add(m[1]);
     }
+    let userTurns = 0;
+    let assistantChars = 0;
+    let decisionMarkers = 0;
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      if (DECISION_RE.test(trimmed) || CORRECTION_RE.test(trimmed)) {
+        decisionMarkers++;
+      }
+      let rec;
+      try {
+        rec = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (!rec || typeof rec !== "object") continue;
+      const role = recordRole(rec);
+      if (role === "user") {
+        userTurns++;
+      } else if (role === "assistant") {
+        assistantChars += sumAssistantTextChars(rec);
+      }
+    }
     return {
       changeCount: changeMatches ? changeMatches.length : 0,
       toolCount: toolMatches ? toolMatches.length : 0,
-      taskSlugs: [...slugs]
+      taskSlugs: [...slugs],
+      userTurns,
+      assistantChars,
+      decisionMarkers
     };
   } catch {
     return ZERO_ANALYSIS;
   }
 }
+function recordRole(rec) {
+  const r = rec;
+  if (typeof r.role === "string") return r.role;
+  if (r.message && typeof r.message === "object" && typeof r.message.role === "string") {
+    return r.message.role;
+  }
+  return null;
+}
+function sumAssistantTextChars(rec) {
+  const r = rec;
+  const content = (r.message && typeof r.message === "object" ? r.message.content : void 0) ?? r.content;
+  let total = 0;
+  if (typeof content === "string") {
+    return Math.min(MAX_TEXT_BLOCK_CHARS, content.length);
+  }
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (block && typeof block === "object") {
+        const b = block;
+        if (b.type === "text" && typeof b.text === "string") {
+          total += Math.min(MAX_TEXT_BLOCK_CHARS, b.text.length);
+        }
+      }
+    }
+  }
+  return total;
+}
+function scoreFromSubstance(signals2) {
+  let pts = 0;
+  if (signals2.userTurns >= 6) pts++;
+  if (signals2.assistantChars >= 6e3) pts++;
+  if (signals2.decisionMarkers >= 1) pts++;
+  if (signals2.taskSlugs.length >= 2) pts++;
+  return Math.min(3, pts);
+}
 function scoreFromChangeCount(count) {
   if (count <= 0) return 0;
   if (count <= 3) return 1;
@@ -39698,6 +39881,29 @@ function getConsolidationDirective(state) {
   }
   return null;
 }
+function userPromptReminder(state) {
+  const { debt, bookmarks, sleep_started_at } = state;
+  if (sleep_started_at) {
+    if (debt >= 4) {
+      return `Consolidation already in progress (started: ${sleep_started_at}). Do NOT dispatch another sleep agent.`;
+    }
+    return null;
+  }
+  const criticalBookmarks = bookmarks.filter((b) => b.salience === 3);
+  if (debt >= 10) {
+    return `Sleep debt is ${debt}. CONSOLIDATION REQUIRED. Run sleep flow per SKILL.md (parallel specialist fan-out) NOW.`;
+  }
+  if (criticalBookmarks.length > 0) {
+    return `${criticalBookmarks.length} critical bookmark(s) need consolidation. Run sleep flow per SKILL.md.`;
+  }
+  if (debt >= 7) {
+    return `Sleep debt is ${debt}. Consolidation recommended before starting new work.`;
+  }
+  if (debt >= 4) {
+    return `Sleep debt is ${debt}. After completing the current task, offer to consolidate.`;
+  }
+  return null;
+}
 function resolveDashboardPort() {
   const raw = process.env.DREAMCONTEXT_DASHBOARD_PORT;
   if (raw) {
@@ -39760,7 +39966,11 @@ function registerHookCommand(program2) {
     const stoppedAt = (/* @__PURE__ */ new Date()).toISOString();
     const analysis = transcriptPath ? analyzeTranscript(transcriptPath) : ZERO_ANALYSIS;
     const { changeCount, toolCount } = analysis;
-    const score = Math.max(scoreFromChangeCount(changeCount), scoreFromToolCount(toolCount));
+    const score = Math.max(
+      scoreFromChangeCount(changeCount),
+      scoreFromToolCount(toolCount),
+      scoreFromSubstance(analysis)
+    );
     for (const bookmark of state.bookmarks) {
       if (!bookmark.session_id) {
         bookmark.session_id = sessionId;
@@ -39769,35 +39979,18 @@ function registerHookCommand(program2) {
     const bookmarkTaskSlugs = state.bookmarks.filter((b) => b.session_id === sessionId && b.task_slug).map((b) => b.task_slug);
     const transcriptTaskSlugs = analysis.taskSlugs;
     const taskSlugs = [.../* @__PURE__ */ new Set([...transcriptTaskSlugs, ...bookmarkTaskSlugs])];
-    const existing = state.sessions.findIndex((s) => s.session_id === sessionId);
-    if (existing >= 0) {
-      const oldScore = state.sessions[existing].score ?? 0;
-      state.debt = Math.max(0, state.debt - oldScore);
-      state.sessions[existing].transcript_path = transcriptPath;
-      state.sessions[existing].stopped_at = stoppedAt;
-      state.sessions[existing].last_assistant_message = lastAssistantMessage;
-      state.sessions[existing].change_count = changeCount;
-      state.sessions[existing].tool_count = toolCount;
-      state.sessions[existing].score = score;
-      const existingSlugs = state.sessions[existing].task_slugs ?? [];
-      state.sessions[existing].task_slugs = [.../* @__PURE__ */ new Set([...existingSlugs, ...taskSlugs])];
-    } else {
-      state.sessions.unshift({
-        session_id: sessionId,
-        transcript_path: transcriptPath,
-        stopped_at: stoppedAt,
-        last_assistant_message: lastAssistantMessage,
-        change_count: changeCount,
-        tool_count: toolCount,
-        score,
-        task_slugs: taskSlugs
-      });
-    }
-    state.debt += score;
-    if (existing < 0) {
-      state.sessions_since_last_sleep = (state.sessions_since_last_sleep || 0) + 1;
-    }
-    writeSleepState(root, state);
+    const upsertInput = {
+      session_id: sessionId,
+      transcript_path: transcriptPath,
+      stopped_at: stoppedAt,
+      last_assistant_message: lastAssistantMessage,
+      change_count: changeCount,
+      tool_count: toolCount,
+      score,
+      task_slugs: taskSlugs
+    };
+    const nextState = upsertSessionOnStop(state, upsertInput);
+    writeSleepState(root, nextState);
   });
   hook.command("session-start").description("Analyze previous session + output context snapshot (called by Claude Code SessionStart hook)").action(() => {
     const input2 = readStdin();
@@ -39819,7 +40012,11 @@ function registerHookCommand(program2) {
         continue;
       }
       const analysis = analyzeTranscript(session.transcript_path);
-      const score = Math.max(scoreFromChangeCount(analysis.changeCount), scoreFromToolCount(analysis.toolCount));
+      const score = Math.max(
+        scoreFromChangeCount(analysis.changeCount),
+        scoreFromToolCount(analysis.toolCount),
+        scoreFromSubstance(analysis)
+      );
       session.change_count = analysis.changeCount;
       session.tool_count = analysis.toolCount;
       session.score = score;
@@ -39924,23 +40121,12 @@ function registerHookCommand(program2) {
     const root = resolveContextRoot();
     if (!root) process.exit(0);
     const state = readSleepState(root);
-    const { debt, bookmarks, sleep_started_at } = state;
-    if (sleep_started_at) {
-      if (debt >= 4) {
-        console.log(`Consolidation already in progress (started: ${sleep_started_at}). Do NOT dispatch another sleep agent.`);
-      }
+    const reminder = userPromptReminder(state);
+    if (state.sleep_started_at) {
+      if (reminder) console.log(reminder);
       return;
     }
-    const criticalBookmarks = bookmarks.filter((b) => b.salience === 3);
-    if (debt >= 10) {
-      console.log(`Sleep debt is ${debt}. CONSOLIDATION REQUIRED. Run sleep flow per SKILL.md (parallel specialist fan-out) NOW.`);
-    } else if (criticalBookmarks.length > 0) {
-      console.log(`${criticalBookmarks.length} critical bookmark(s) need consolidation. Run sleep flow per SKILL.md.`);
-    } else if (debt >= 7) {
-      console.log(`Sleep debt is ${debt}. Consolidation recommended before starting new work.`);
-    } else if (debt >= 4) {
-      console.log(`Sleep debt is ${debt}. After completing the current task, offer to consolidate.`);
-    }
+    if (reminder) console.log(reminder);
     try {
       const stale = listStaleRecs(24);
       if (stale.length > 0) {
@@ -40090,17 +40276,14 @@ function registerHookCommand(program2) {
     if (!root) process.exit(0);
     const state = readSleepState(root);
     const trigger = input2 && typeof input2.trigger === "string" ? input2.trigger : "unknown";
-    state.compaction_log.unshift({
+    const nextState = appendCompactionRecord(state, {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       trigger,
       debt_at_compaction: state.debt,
       sessions_count: state.sessions.length,
       bookmarks_count: state.bookmarks.length
     });
-    if (state.compaction_log.length > 20) {
-      state.compaction_log = state.compaction_log.slice(0, 20);
-    }
-    writeSleepState(root, state);
+    writeSleepState(root, nextState);
     try {
       const sessionId = input2 && typeof input2.session_id === "string" ? input2.session_id : "";
       const transcriptPath = input2 && typeof input2.transcript_path === "string" ? input2.transcript_path : "";
@@ -40129,12 +40312,14 @@ function registerHookCommand(program2) {
     process.exit(0);
   });
 }
-var MAX_TRANSCRIPT_BYTES2, SKILL_SCORE_THRESHOLD, ZERO_ANALYSIS, JS_TS_EXTENSIONS, MAX_WALK_LEVELS, BIOME_CONFIGS, PRETTIER_CONFIGS, DEFAULT_DASHBOARD_PORT;
+var MAX_TRANSCRIPT_BYTES2, SKILL_SCORE_THRESHOLD, ZERO_ANALYSIS, MAX_TEXT_BLOCK_CHARS, JS_TS_EXTENSIONS, MAX_WALK_LEVELS, BIOME_CONFIGS, PRETTIER_CONFIGS, DEFAULT_DASHBOARD_PORT;
 var init_hook = __esm({
   "src/cli/commands/hook.ts"() {
     "use strict";
     init_context_path();
     init_sleep();
+    init_sleep_consolidation();
+    init_salience();
     init_transcript();
     init_session_digest();
     init_salience();
@@ -40151,7 +40336,15 @@ var init_hook = __esm({
     init_install_skill();
     MAX_TRANSCRIPT_BYTES2 = 50 * 1024 * 1024;
     SKILL_SCORE_THRESHOLD = 1;
-    ZERO_ANALYSIS = { changeCount: 0, toolCount: 0, taskSlugs: [] };
+    ZERO_ANALYSIS = {
+      changeCount: 0,
+      toolCount: 0,
+      taskSlugs: [],
+      userTurns: 0,
+      assistantChars: 0,
+      decisionMarkers: 0
+    };
+    MAX_TEXT_BLOCK_CHARS = 2e4;
     JS_TS_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".mts", ".cts"]);
     MAX_WALK_LEVELS = 10;
     BIOME_CONFIGS = ["biome.json", "biome.jsonc"];
@@ -41091,8 +41284,8 @@ async function handleCoreGet(_req, res, params, contextRoot) {
     return;
   }
   if (filename.endsWith(".json")) {
-    const { readFileSync: readFileSync66 } = await import("fs");
-    const raw2 = readFileSync66(filePath, "utf-8");
+    const { readFileSync: readFileSync67 } = await import("fs");
+    const raw2 = readFileSync67(filePath, "utf-8");
     try {
       const data = JSON.parse(raw2);
       sendJson(res, 200, { filename, type: "json", data });
@@ -41126,8 +41319,8 @@ async function handleCoreGet(_req, res, params, contextRoot) {
     });
     return;
   }
-  const { readFileSync: readFileSync65 } = await import("fs");
-  const raw = readFileSync65(filePath, "utf-8");
+  const { readFileSync: readFileSync66 } = await import("fs");
+  const raw = readFileSync66(filePath, "utf-8");
   sendJson(res, 200, { filename, type: "text", content: raw });
 }
 async function handleCoreUpdate(req, res, params, contextRoot) {
@@ -41177,8 +41370,8 @@ async function handleCoreUpdate(req, res, params, contextRoot) {
       return;
     }
     changedParts.push("content");
-    const { writeFileSync: writeFileSync44 } = await import("fs");
-    writeFileSync44(filePath, body.content, "utf-8");
+    const { writeFileSync: writeFileSync45 } = await import("fs");
+    writeFileSync45(filePath, body.content, "utf-8");
   }
   const what = changedParts.length > 0 ? changedParts.join(" and ") : "file";
   recordDashboardChange(contextRoot, {
@@ -42793,8 +42986,9 @@ function buildAskPrompt(question) {
 
 Question: "${question}"`;
 }
-function buildSleepPrompt() {
-  return `Think hard. Run a dreamcontext memory consolidation ("sleep") for THIS project now, fully autonomously \u2014 do NOT ask any questions. Follow the project's dreamcontext sleep/consolidation flow: pin the epoch with \`dreamcontext sleep start\`, reconcile the task/changelog/knowledge/feature files to current truth as warranted (prefer updating existing entities over creating new ones), then close the cycle with \`dreamcontext sleep done "<one-paragraph summary>"\` to reset the debt. When finished, reply with a SHORT GitHub-flavored Markdown summary (a few bullets) of what was consolidated. Keep it concise.`;
+function buildSleepPrompt(depth) {
+  const depthLine = isDestructiveAllowed(depth) ? `This is a DEEP consolidation: you ARE authorized to perform destructive/expensive knowledge ops (merge-with-delete, summarize-and-replace still-valid detail, archive/delete stale files) \u2014 but first copy any file you will merge/replace/delete to \`_dream_context/knowledge/.archive/<slug>-<YYYYMMDD>.md\` (create the dir if absent).` : `This is a ${depth.toUpperCase()} consolidation: do NOT merge, summarize-and-replace, or delete any knowledge. Only create/extend/retag/tick. If you spot merge or deletion candidates, FLAG them in your report instead of acting on them.`;
+  return `Think hard. Run a dreamcontext memory consolidation ("sleep") for THIS project now, fully autonomously \u2014 do NOT ask any questions. Follow the project's dreamcontext sleep/consolidation flow: pin the epoch with \`dreamcontext sleep start\`, reconcile the task/changelog/knowledge/feature files to current truth as warranted (prefer updating existing entities over creating new ones), then close the cycle with \`dreamcontext sleep done "<one-paragraph summary>"\` to reset the debt. ${depthLine} When finished, reply with a SHORT GitHub-flavored Markdown summary (a few bullets) of what was consolidated. Keep it concise.`;
 }
 async function handleLauncherCapture(req, res, _params, _contextRoot) {
   const body = await parseJsonBody(req);
@@ -42852,7 +43046,18 @@ async function handleLauncherCapture(req, res, _params, _contextRoot) {
   captureRuns.set(captureId, run2);
   try {
     const shell = process.env.SHELL || "/bin/zsh";
-    const prompt = mode === "sleep" ? buildSleepPrompt() : mode === "ask" ? buildAskPrompt(text) : buildCapturePrompt(text);
+    let sleepDepth = "deep";
+    if (mode === "sleep") {
+      try {
+        sleepDepth = consolidationDepth(readSleepState(cwd).debt, {
+          userRequestedDeep: true
+        }).depth;
+      } catch (err) {
+        console.error("[launcher] could not read sleep state for depth:", err);
+        sleepDepth = "deep";
+      }
+    }
+    const prompt = mode === "sleep" ? buildSleepPrompt(sleepDepth) : mode === "ask" ? buildAskPrompt(text) : buildCapturePrompt(text);
     const child = spawn4(shell, ["-ilc", 'exec claude --model sonnet -p "$0"', prompt], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -42899,6 +43104,177 @@ async function handleLauncherDefaults(_req, res, _params, _contextRoot) {
   const home = homedir3();
   sendJson(res, 200, { home, defaultParent: join59(home, "projects") });
 }
+function computeVaultStatus(v, latest) {
+  const exists = existsSync63(resolve15(v.path));
+  let setupVersion = "0.0.0";
+  let shareable = false;
+  if (exists) {
+    try {
+      const cfg = readSetupConfig(resolve15(v.path));
+      if (cfg) {
+        setupVersion = cfg.setupVersion || "0.0.0";
+        shareable = cfg.shareable === true;
+      }
+    } catch {
+    }
+  }
+  const needsUpdate = exists && compareVersions(setupVersion, latest) < 0;
+  return { name: v.name, path: v.path, exists, setupVersion, latestVersion: latest, needsUpdate, shareable };
+}
+async function handleLauncherStatus(_req, res, _params, _contextRoot) {
+  const latest = dreamcontextVersion();
+  const vaults = listVaults().map((v) => computeVaultStatus(v, latest));
+  sendJson(res, 200, { vaults, latestVersion: latest });
+}
+async function handleLauncherUnregister(req, res, _params, _contextRoot) {
+  const body = await parseJsonBody(req);
+  if (!body) {
+    sendError(res, 400, "invalid_body", "Request body must be valid JSON.");
+    return;
+  }
+  const name = typeof body.name === "string" ? body.name.trim() : "";
+  if (!name) {
+    sendError(res, 400, "invalid_name", "name must be a non-empty string.");
+    return;
+  }
+  const removed = removeVault(name);
+  sendJson(res, 200, { removed, vaults: listVaults() });
+}
+async function handleLauncherUpdate(req, res, _params, _contextRoot) {
+  const body = await parseJsonBody(req);
+  if (!body) {
+    sendError(res, 400, "invalid_body", "Request body must be valid JSON.");
+    return;
+  }
+  const name = typeof body.name === "string" ? body.name.trim() : "";
+  if (!name) {
+    sendError(res, 400, "invalid_name", "name must be a non-empty string.");
+    return;
+  }
+  const vault = listVaults().find((v) => v.name === name);
+  if (!vault) {
+    sendError(res, 400, "unknown_vault", `No registered vault named "${name}".`);
+    return;
+  }
+  const target = resolve15(vault.path);
+  if (!existsSync63(target)) {
+    sendError(res, 400, "missing_vault", `Vault path no longer exists: ${target}`);
+    return;
+  }
+  try {
+    await defaultCliRunner(["update"], target);
+    const latest = dreamcontextVersion();
+    sendJson(res, 200, { ok: true, status: computeVaultStatus(vault, latest) });
+  } catch (err) {
+    console.error("[launcher] update failed:", err);
+    const detail = err instanceof Error ? err.message : "unknown error";
+    sendError(res, 500, "update_failed", `Update failed: ${detail}`);
+  }
+}
+async function handleLauncherFederationGraph(_req, res, _params, _contextRoot) {
+  const latest = dreamcontextVersion();
+  const vaults = listVaults();
+  const nodes = vaults.map((v) => computeVaultStatus(v, latest));
+  const shareableByName = new Map(nodes.map((n) => [n.name, n.shareable]));
+  const known = new Set(vaults.map((v) => v.name));
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const v of vaults) {
+    if (!existsSync63(resolve15(v.path))) continue;
+    const conns = listConnections(join59(resolve15(v.path), "_dream_context"));
+    for (const c of conns) {
+      if (c.direction !== "out" && c.direction !== "both") continue;
+      if (!known.has(c.vault)) continue;
+      if (c.status === "stale") continue;
+      const key = `${v.name}\0${c.vault}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edges.push({ source: v.name, target: c.vault, active: shareableByName.get(c.vault) === true });
+    }
+  }
+  sendJson(res, 200, { nodes, edges, latestVersion: latest });
+}
+async function handleLauncherConnectionCreate(req, res, _params, _contextRoot) {
+  const body = await parseJsonBody(req);
+  if (!body) {
+    sendError(res, 400, "invalid_body", "Request body must be valid JSON.");
+    return;
+  }
+  const from = typeof body.from === "string" ? body.from.trim() : "";
+  const to = typeof body.to === "string" ? body.to.trim() : "";
+  if (!from || !to) {
+    sendError(res, 400, "invalid_body", "from and to must be non-empty strings.");
+    return;
+  }
+  const fromVault = listVaults().find((v) => v.name === from);
+  if (!fromVault) {
+    sendError(res, 400, "unknown_vault", `No registered vault named "${from}".`);
+    return;
+  }
+  const fromRoot = join59(resolve15(fromVault.path), "_dream_context");
+  try {
+    addConnection(fromRoot, from, to, "out", null);
+    sendJson(res, 200, { ok: true });
+  } catch (err) {
+    if (err instanceof VaultError) {
+      sendError(res, 400, "invalid_connection", err.message);
+      return;
+    }
+    console.error("[launcher] connection create failed:", err);
+    sendError(res, 500, "connection_failed", "Failed to create connection.");
+  }
+}
+async function handleLauncherConnectionRemove(req, res, _params, _contextRoot) {
+  const body = await parseJsonBody(req);
+  if (!body) {
+    sendError(res, 400, "invalid_body", "Request body must be valid JSON.");
+    return;
+  }
+  const from = typeof body.from === "string" ? body.from.trim() : "";
+  const to = typeof body.to === "string" ? body.to.trim() : "";
+  if (!from || !to) {
+    sendError(res, 400, "invalid_body", "from and to must be non-empty strings.");
+    return;
+  }
+  const fromVault = listVaults().find((v) => v.name === from);
+  if (!fromVault) {
+    sendError(res, 400, "unknown_vault", `No registered vault named "${from}".`);
+    return;
+  }
+  const fromRoot = join59(resolve15(fromVault.path), "_dream_context");
+  const removed = removeConnection(fromRoot, to);
+  sendJson(res, 200, { ok: true, removed });
+}
+async function handleLauncherShareable(req, res, _params, _contextRoot) {
+  const body = await parseJsonBody(req);
+  if (!body) {
+    sendError(res, 400, "invalid_body", "Request body must be valid JSON.");
+    return;
+  }
+  const name = typeof body.name === "string" ? body.name.trim() : "";
+  const shareable = body.shareable === true;
+  if (!name) {
+    sendError(res, 400, "invalid_name", "name must be a non-empty string.");
+    return;
+  }
+  const vault = listVaults().find((v) => v.name === name);
+  if (!vault) {
+    sendError(res, 400, "unknown_vault", `No registered vault named "${name}".`);
+    return;
+  }
+  const root = resolve15(vault.path);
+  if (!existsSync63(root)) {
+    sendError(res, 400, "missing_vault", `Vault path no longer exists: ${root}`);
+    return;
+  }
+  try {
+    updateSetupConfig(root, { shareable });
+    sendJson(res, 200, { ok: true, name, shareable });
+  } catch (err) {
+    console.error("[launcher] shareable toggle failed:", err);
+    sendError(res, 500, "shareable_failed", "Failed to update sharing.");
+  }
+}
 var execFileAsync2, captureRuns, CAPTURE_RUN_TTL_MS, CAPTURE_RUNS_MAX, ScaffoldError, defaultCliRunner, SAFE_NAME_RE, SLEEPY_MODES;
 var init_launcher = __esm({
   "src/server/routes/launcher.ts"() {
@@ -42906,12 +43282,18 @@ var init_launcher = __esm({
     init_middleware();
     init_vault_discovery();
     init_vaults();
+    init_connections();
+    init_setup_config();
+    init_manifest();
+    init_version_check();
     init_tech_stack();
     init_ensure_cli();
     init_platforms();
     init_catalog();
     init_json_file();
     init_id();
+    init_sleep();
+    init_sleep_consolidation();
     execFileAsync2 = promisify2(execFile2);
     captureRuns = /* @__PURE__ */ new Map();
     CAPTURE_RUN_TTL_MS = 10 * 60 * 1e3;
@@ -42940,6 +43322,62 @@ var init_launcher = __esm({
   }
 });
 
+// src/server/routes/ui-settings.ts
+import { dirname as dirname30, join as join60 } from "path";
+import { existsSync as existsSync64, mkdirSync as mkdirSync26, readFileSync as readFileSync46, writeFileSync as writeFileSync33 } from "fs";
+function settingsPath(contextRoot) {
+  return join60(contextRoot, BRAIN_SETTINGS_REL_PATH);
+}
+async function handleBrainSettingsGet(_req, res, _params, contextRoot) {
+  const path2 = settingsPath(contextRoot);
+  if (!existsSync64(path2)) {
+    sendJson(res, 200, { settings: {} });
+    return;
+  }
+  try {
+    const raw = JSON.parse(readFileSync46(path2, "utf-8"));
+    const settings = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+    sendJson(res, 200, { settings });
+  } catch {
+    sendJson(res, 200, { settings: {} });
+  }
+}
+async function handleBrainSettingsPut(req, res, _params, contextRoot) {
+  const body = await parseJsonBody(req);
+  if (!body) {
+    sendError(res, 400, "invalid_body", "Request body must be valid JSON.");
+    return;
+  }
+  const settings = body.settings;
+  if (settings === null || typeof settings !== "object" || Array.isArray(settings)) {
+    sendError(res, 400, "invalid_settings", "settings must be a JSON object.");
+    return;
+  }
+  const serialized = JSON.stringify(settings, null, 2);
+  if (Buffer.byteLength(serialized, "utf-8") > MAX_BYTES) {
+    sendError(res, 400, "too_large", "settings payload is too large.");
+    return;
+  }
+  try {
+    const path2 = settingsPath(contextRoot);
+    mkdirSync26(dirname30(path2), { recursive: true });
+    writeFileSync33(path2, serialized + "\n", "utf-8");
+    sendJson(res, 200, { ok: true });
+  } catch (err) {
+    console.error("[ui-settings] brain-settings write failed:", err);
+    sendError(res, 500, "write_failed", "Failed to persist brain settings.");
+  }
+}
+var BRAIN_SETTINGS_REL_PATH, MAX_BYTES;
+var init_ui_settings = __esm({
+  "src/server/routes/ui-settings.ts"() {
+    "use strict";
+    init_middleware();
+    BRAIN_SETTINGS_REL_PATH = "state/.brain-settings.json";
+    MAX_BYTES = 256 * 1024;
+  }
+});
+
 // src/lib/federation-config.ts
 function isShareable(projectRoot) {
   const cfg = readSetupConfig(projectRoot);
@@ -42953,7 +43391,7 @@ var init_federation_config = __esm({
 });
 
 // src/lib/federation-recall.ts
-import { basename as basename19, dirname as dirname30 } from "path";
+import { basename as basename19, dirname as dirname31 } from "path";
 function namespacedKey(vault, type, slug) {
   return `${vault}::${type}/${slug}`;
 }
@@ -42978,7 +43416,7 @@ function crossVaultRecall(query, opts) {
     }
     const isCurrent = target.current === true;
     if (!isCurrent) {
-      const projectRoot = dirname30(contextRoot);
+      const projectRoot = dirname31(contextRoot);
       if (!isShareable(projectRoot)) continue;
     }
     const corpus = buildCorpus(contextRoot, opts.types ? { types: opts.types } : {}).filter((doc) => !isFederated(doc));
@@ -43051,9 +43489,9 @@ var init_federation_recall = __esm({
 });
 
 // src/server/routes/connections.ts
-import { dirname as dirname31 } from "path";
+import { dirname as dirname32 } from "path";
 function currentVaultName(contextRoot) {
-  return currentVaultTarget(dirname31(contextRoot)).name;
+  return currentVaultTarget(dirname32(contextRoot)).name;
 }
 async function handleConnectionsList(_req, res, _params, contextRoot) {
   sendJson(res, 200, { connections: listConnections(contextRoot) });
@@ -43128,8 +43566,8 @@ var init_connections2 = __esm({
 });
 
 // src/lib/federation-digest.ts
-import { existsSync as existsSync64 } from "fs";
-import { join as join60 } from "path";
+import { existsSync as existsSync65 } from "fs";
+import { join as join61 } from "path";
 function buildInterestProfile(peerRoot, topics) {
   if (topics && topics.length > 0) {
     const terms2 = Array.from(new Set(tokenize(topics.join(" "))));
@@ -43148,8 +43586,8 @@ function buildInterestProfile(peerRoot, topics) {
   return { terms, query: terms.join(" ") };
 }
 function activeTaskTerms(peerRoot) {
-  const stateDir = join60(peerRoot, "state");
-  if (!existsSync64(stateDir)) return [];
+  const stateDir = join61(peerRoot, "state");
+  if (!existsSync65(stateDir)) return [];
   let files;
   try {
     files = import_fast_glob17.default.sync("*.md", { cwd: stateDir, absolute: true });
@@ -43250,7 +43688,7 @@ var init_federation_digest = __esm({
 });
 
 // src/server/routes/federation.ts
-import { dirname as dirname32 } from "path";
+import { dirname as dirname33 } from "path";
 async function handleFederationInboxGet(_req, res, _params, contextRoot) {
   const { entries, quarantined } = drainInbox(contextRoot);
   const pending = entries.map((e) => e.entry);
@@ -43262,7 +43700,7 @@ async function handleFederationInboxGet(_req, res, _params, contextRoot) {
   });
 }
 async function handleFederationSyncPost(_req, res, _params, contextRoot) {
-  const senderName = currentVaultTarget(dirname32(contextRoot)).name;
+  const senderName = currentVaultTarget(dirname33(contextRoot)).name;
   const outbound = listConnections(contextRoot).filter(
     (c) => (c.direction === "out" || c.direction === "both") && c.status !== "stale"
   );
@@ -43310,14 +43748,14 @@ var init_federation = __esm({
 });
 
 // src/server/routes/packs.ts
-import { dirname as dirname33 } from "path";
+import { dirname as dirname34 } from "path";
 async function handlePacksGet(_req, res, _params, contextRoot) {
   const loaded = loadCatalog();
   if (!loaded) {
     sendJson(res, 200, { packs: [], standalone: [] });
     return;
   }
-  const projectRoot = dirname33(contextRoot);
+  const projectRoot = dirname34(contextRoot);
   const packs = loaded.catalog.packs.map((p) => ({ ...p, installed: isSkillInstalled(projectRoot, p.name) }));
   const standalone = loaded.catalog.standalone.map((s) => ({ ...s, installed: isSkillInstalled(projectRoot, s.name) }));
   sendJson(res, 200, { packs, standalone });
@@ -43331,7 +43769,7 @@ var init_packs = __esm({
 });
 
 // src/server/routes/packs-install.ts
-import { dirname as dirname34 } from "path";
+import { dirname as dirname35 } from "path";
 function validatePackName(name, contextRoot) {
   if (name.includes("/") || name.includes("\0") || safeChildPath2("/x", name) === null) {
     return { ok: false, status: 400, code: "invalid_name", message: "Invalid pack name." };
@@ -43344,7 +43782,7 @@ function validatePackName(name, contextRoot) {
   if (!known) {
     return { ok: false, status: 404, code: "unknown_pack", message: `Pack "${name}" not found.` };
   }
-  const projectRoot = dirname34(contextRoot);
+  const projectRoot = dirname35(contextRoot);
   const config = readSetupConfig(projectRoot);
   const platforms = normalizePlatforms(config?.platforms ?? []);
   const resolved = platforms.length > 0 ? platforms : [...DEFAULT_PLATFORMS];
@@ -43417,10 +43855,10 @@ var init_packs_install = __esm({
 });
 
 // src/server/routes/version-check.ts
-import { dirname as dirname35 } from "path";
+import { dirname as dirname36 } from "path";
 async function handleVersionCheckGet(_req, res, _params, contextRoot) {
   try {
-    const projectRoot = dirname35(contextRoot);
+    const projectRoot = dirname36(contextRoot);
     const cache = readVersionCache(projectRoot);
     const fresh = isCacheFresh(cache);
     const installedCli = dreamcontextVersion();
@@ -43475,7 +43913,7 @@ var init_taxonomy2 = __esm({
 
 // src/server/index.ts
 import { createServer } from "http";
-import { join as join61, resolve as resolve16 } from "path";
+import { join as join62, resolve as resolve16 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 import { exec } from "child_process";
 function buildRouter() {
@@ -43521,6 +43959,13 @@ function buildRouter() {
   router.get("/api/launcher/capture/status", handleLauncherCaptureStatus);
   router.get("/api/launcher/sleepy-config", handleSleepyConfigGet);
   router.post("/api/launcher/sleepy-config", handleSleepyConfigSet);
+  router.get("/api/launcher/status", handleLauncherStatus);
+  router.post("/api/launcher/unregister", handleLauncherUnregister);
+  router.post("/api/launcher/update", handleLauncherUpdate);
+  router.get("/api/launcher/federation-graph", handleLauncherFederationGraph);
+  router.post("/api/launcher/connection", handleLauncherConnectionCreate);
+  router.post("/api/launcher/connection/remove", handleLauncherConnectionRemove);
+  router.post("/api/launcher/shareable", handleLauncherShareable);
   router.get("/api/sleepy/video", handleSleepyVideo);
   router.get("/api/sleepy/anim", handleSleepyAnim);
   router.get("/api/vaults", handleVaultsGet);
@@ -43532,6 +43977,8 @@ function buildRouter() {
   router.get("/api/packs", handlePacksGet);
   router.post("/api/packs/:name/install", handlePackInstall);
   router.delete("/api/packs/:name", handlePackUninstall);
+  router.get("/api/brain-settings", handleBrainSettingsGet);
+  router.put("/api/brain-settings", handleBrainSettingsPut);
   router.get("/api/version-check", handleVersionCheckGet);
   router.get("/api/taxonomy", handleTaxonomyGet);
   router.get("/api/changelog", handleChangelogGet);
@@ -43553,7 +44000,7 @@ function resolveRequestVault(req) {
   if (/[/\\:.\x00]/.test(h)) return "INVALID";
   const v = listVaults().find((x) => x.name === h);
   if (!v) return "INVALID";
-  return join61(v.path, "_dream_context");
+  return join62(v.path, "_dream_context");
 }
 function getDashboardDir() {
   const __dirname8 = fileURLToPath7(new URL(".", import.meta.url));
@@ -43653,6 +44100,7 @@ var init_server = __esm({
     init_config();
     init_vaults2();
     init_launcher();
+    init_ui_settings();
     init_connections2();
     init_federation();
     init_packs();
@@ -43844,8 +44292,8 @@ var init_trigger = __esm({
 });
 
 // src/lib/reflection.ts
-import { existsSync as existsSync65, mkdirSync as mkdirSync26, writeFileSync as writeFileSync33 } from "fs";
-import { join as join62, dirname as dirname36 } from "path";
+import { existsSync as existsSync66, mkdirSync as mkdirSync27, writeFileSync as writeFileSync34 } from "fs";
+import { join as join63, dirname as dirname37 } from "path";
 function buildExclusionSet(corpus, excludedExtra) {
   const excluded = new Set(excludedExtra);
   for (const doc of corpus) {
@@ -44021,13 +44469,13 @@ function formatReflection(result) {
   return capToBytes(lines, MAX_REFLECTION_BYTES);
 }
 function reflectionPath(root) {
-  return join62(root, "state", ".reflection.md");
+  return join63(root, "state", ".reflection.md");
 }
 function writeReflection(root, md) {
   const outPath = reflectionPath(root);
-  const dir = dirname36(outPath);
-  if (!existsSync65(dir)) {
-    mkdirSync26(dir, { recursive: true });
+  const dir = dirname37(outPath);
+  if (!existsSync66(dir)) {
+    mkdirSync27(dir, { recursive: true });
   }
   const tsMatch = md.match(/Generated: ([^\n]+)/);
   const generatedAt = tsMatch ? tsMatch[1].trim() : (/* @__PURE__ */ new Date()).toISOString();
@@ -44038,7 +44486,7 @@ function writeReflection(root, md) {
     "---",
     ""
   ].join("\n");
-  writeFileSync33(outPath, frontmatter + md, "utf-8");
+  writeFileSync34(outPath, frontmatter + md, "utf-8");
   return outPath;
 }
 var MAX_REFLECTION_BYTES, DEFAULT_MIN_SESSIONS, DEFAULT_MAX_CANDIDATES, REFLECTION_NOISE;
@@ -44202,14 +44650,14 @@ var init_reflection = __esm({
 });
 
 // src/cli/commands/reflect.ts
-import { existsSync as existsSync66, readFileSync as readFileSync48 } from "fs";
-import { join as join63 } from "path";
+import { existsSync as existsSync67, readFileSync as readFileSync49 } from "fs";
+import { join as join64 } from "path";
 function buildBookmarkSessions(root) {
-  const sleepPath = join63(root, "state", ".sleep.json");
+  const sleepPath = join64(root, "state", ".sleep.json");
   const result = /* @__PURE__ */ new Map();
-  if (!existsSync66(sleepPath)) return result;
+  if (!existsSync67(sleepPath)) return result;
   try {
-    const parsed = JSON.parse(readFileSync48(sleepPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync49(sleepPath, "utf-8"));
     const bookmarks = parsed.bookmarks ?? [];
     for (const b of bookmarks) {
       if (b.id && b.session_id) {
@@ -44223,13 +44671,13 @@ function buildBookmarkSessions(root) {
 function buildExcludedExtra(root) {
   const excluded = /* @__PURE__ */ new Set();
   const coreFiles = [
-    join63(root, "core", "0.soul.md"),
-    join63(root, "core", "1.user.md")
+    join64(root, "core", "0.soul.md"),
+    join64(root, "core", "1.user.md")
   ];
   for (const filePath of coreFiles) {
-    if (!existsSync66(filePath)) continue;
+    if (!existsSync67(filePath)) continue;
     try {
-      const content = readFileSync48(filePath, "utf-8");
+      const content = readFileSync49(filePath, "utf-8");
       for (const tok of tokenize(content)) {
         excluded.add(tok);
       }
@@ -44280,8 +44728,8 @@ var init_reflect = __esm({
 });
 
 // src/cli/commands/council.ts
-import { existsSync as existsSync67, mkdirSync as mkdirSync27, readFileSync as readFileSync49, writeFileSync as writeFileSync34 } from "fs";
-import { join as join64 } from "path";
+import { existsSync as existsSync68, mkdirSync as mkdirSync28, readFileSync as readFileSync50, writeFileSync as writeFileSync35 } from "fs";
+import { join as join65 } from "path";
 function roundRunningStatus(n) {
   return `round_${n}_running`;
 }
@@ -44323,12 +44771,12 @@ function registerCreate(council) {
       }
       const id = generateId("council");
       const dir = getDebateDir(id);
-      mkdirSync27(dir, { recursive: true });
+      mkdirSync28(dir, { recursive: true });
       const template = loadTemplate("council-debate.md");
       const content = template.replaceAll("{{ID}}", id).replaceAll("{{TOPIC}}", topic.replace(/"/g, '\\"')).replaceAll("{{ROUNDS}}", String(rounds)).replaceAll("{{INTERRUPT}}", opts.interrupt ? "true" : "false").replaceAll("{{DATE}}", today());
-      writeFileSync34(join64(dir, "debate.md"), content, "utf-8");
-      writeFileSync34(
-        join64(dir, "round-log.md"),
+      writeFileSync35(join65(dir, "debate.md"), content, "utf-8");
+      writeFileSync35(
+        join65(dir, "round-log.md"),
         `# Round log \u2014 ${id}
 
 (Main agent appends timeline entries here.)
@@ -44370,8 +44818,8 @@ function registerAgent(council) {
         process.exit(1);
       }
       const personaDir = getPersonaDir(debateId, slug);
-      const personaFile = join64(personaDir, "context-and-persona.md");
-      if (existsSync67(personaFile) && !opts.force) {
+      const personaFile = join65(personaDir, "context-and-persona.md");
+      if (existsSync68(personaFile) && !opts.force) {
         error(`Persona already exists: ${slug}`, "Use --force to overwrite.");
         process.exit(1);
       }
@@ -44381,14 +44829,14 @@ function registerAgent(council) {
         process.exit(1);
       }
       const aspects = opts.aspects ? opts.aspects.split(",").map((a) => a.trim()).filter(Boolean) : [];
-      mkdirSync27(personaDir, { recursive: true });
+      mkdirSync28(personaDir, { recursive: true });
       const template = loadTemplate("council-persona.md");
       const personaContent = template.replaceAll("{{SLUG}}", slug).replaceAll("{{MODEL}}", opts.model).replaceAll("{{ASPECTS}}", JSON.stringify(aspects)).replaceAll("{{PERSONA_BODY}}", body.trim());
-      writeFileSync34(personaFile, personaContent, "utf-8");
+      writeFileSync35(personaFile, personaContent, "utf-8");
       const reportTemplate = loadTemplate("council-report.md");
       const reportContent = reportTemplate.replaceAll("{{SLUG}}", slug);
-      writeFileSync34(join64(personaDir, "report.md"), reportContent, "utf-8");
-      const debateFile = join64(getDebateDir(debateId), "debate.md");
+      writeFileSync35(join65(personaDir, "report.md"), reportContent, "utf-8");
+      const debateFile = join65(getDebateDir(debateId), "debate.md");
       const { data } = readFrontmatter(debateFile);
       const personas = Array.isArray(data.personas) ? data.personas.slice() : [];
       if (!personas.includes(slug)) personas.push(slug);
@@ -44417,7 +44865,7 @@ function registerRound(council) {
         error(`Round ${n} exceeds planned rounds (${data.rounds_planned}).`);
         process.exit(1);
       }
-      const debateFile = join64(getDebateDir(debateId), "debate.md");
+      const debateFile = join65(getDebateDir(debateId), "debate.md");
       const personas = data.personas ?? [];
       if (personas.length === 0) {
         error("No personas registered. Run `council agent create` first.");
@@ -44426,9 +44874,9 @@ function registerRound(council) {
       const crossContextHeader = `## Round ${n} \u2014 Cross-context loaded`;
       if (n >= 2) {
         for (const persona of personas) {
-          const personaFile = join64(getPersonaDir(debateId, persona), "context-and-persona.md");
-          if (!existsSync67(personaFile)) continue;
-          const existing = readFileSync49(personaFile, "utf-8");
+          const personaFile = join65(getPersonaDir(debateId, persona), "context-and-persona.md");
+          if (!existsSync68(personaFile)) continue;
+          const existing = readFileSync50(personaFile, "utf-8");
           if (existing.includes(crossContextHeader)) {
             continue;
           }
@@ -44450,7 +44898,7 @@ _(no round ${n - 1} report submitted)_`);
 
 ${peerLines.join("\n\n")}`;
           const updated = existing.trimEnd() + "\n\n" + newSection + "\n";
-          writeFileSync34(personaFile, updated, "utf-8");
+          writeFileSync35(personaFile, updated, "utf-8");
         }
       }
       updateFrontmatterFields(debateFile, {
@@ -44458,13 +44906,13 @@ ${peerLines.join("\n\n")}`;
         current_round: n,
         updated_at: today()
       });
-      const logFile = join64(getDebateDir(debateId), "round-log.md");
-      const logExisting = existsSync67(logFile) ? readFileSync49(logFile, "utf-8") : "";
+      const logFile = join65(getDebateDir(debateId), "round-log.md");
+      const logExisting = existsSync68(logFile) ? readFileSync50(logFile, "utf-8") : "";
       const logEntry = `
 ## Round ${n} started \u2014 ${today()}
 - Personas: ${formatPersonaList(personas)}
 `;
-      writeFileSync34(logFile, logExisting.trimEnd() + "\n" + logEntry + "\n", "utf-8");
+      writeFileSync35(logFile, logExisting.trimEnd() + "\n" + logEntry + "\n", "utf-8");
       upsertCouncilIndex({
         id: debateId,
         topic: data.topic,
@@ -44498,18 +44946,18 @@ ${peerLines.join("\n\n")}`;
         error(`Round ${n} incomplete. Missing reports from: ${missing.join(", ")}`);
         process.exit(1);
       }
-      const debateFile = join64(getDebateDir(debateId), "debate.md");
+      const debateFile = join65(getDebateDir(debateId), "debate.md");
       updateFrontmatterFields(debateFile, {
         status: roundCompleteStatus(n),
         updated_at: today()
       });
-      const logFile = join64(getDebateDir(debateId), "round-log.md");
-      const logExisting = existsSync67(logFile) ? readFileSync49(logFile, "utf-8") : "";
+      const logFile = join65(getDebateDir(debateId), "round-log.md");
+      const logExisting = existsSync68(logFile) ? readFileSync50(logFile, "utf-8") : "";
       const logEntry = `
 ## Round ${n} complete \u2014 ${today()}
 - All ${personas.length} personas submitted reports.
 `;
-      writeFileSync34(logFile, logExisting.trimEnd() + "\n" + logEntry + "\n", "utf-8");
+      writeFileSync35(logFile, logExisting.trimEnd() + "\n" + logEntry + "\n", "utf-8");
       upsertCouncilIndex({
         id: debateId,
         topic: data.topic,
@@ -44532,8 +44980,8 @@ function registerRoundContext(council) {
     try {
       const data = readDebateFrontmatter(debateId);
       ensurePersonaExists(debateId, personaSlug);
-      const personaFile = join64(getPersonaDir(debateId, personaSlug), "context-and-persona.md");
-      const personaContent = readFileSync49(personaFile, "utf-8");
+      const personaFile = join65(getPersonaDir(debateId, personaSlug), "context-and-persona.md");
+      const personaContent = readFileSync50(personaFile, "utf-8");
       console.log(`# Council debate: ${data.topic}`);
       console.log(`Debate ID: ${debateId}`);
       console.log(`Current round: ${data.current_round}/${data.rounds_planned}`);
@@ -44542,8 +44990,8 @@ function registerRoundContext(council) {
       console.log("---");
       console.log("");
       console.log(personaContent);
-      const debateFile = join64(getDebateDir(debateId), "debate.md");
-      const debateRaw = readFileSync49(debateFile, "utf-8");
+      const debateFile = join65(getDebateDir(debateId), "debate.md");
+      const debateRaw = readFileSync50(debateFile, "utf-8");
       const questionMatch = debateRaw.match(/##\s+Question\s*\n([\s\S]*?)(?=\n##\s|\Z)/);
       const constraintsMatch = debateRaw.match(/##\s+Constraints & Known Facts\s*\n([\s\S]*?)(?=\n##\s|\Z)/);
       if (questionMatch) {
@@ -44586,7 +45034,7 @@ function registerReport(council) {
         process.exit(1);
       }
       for (const w of validation.warnings) warn(w);
-      const reportFile = join64(getPersonaDir(debateId, personaSlug), "report.md");
+      const reportFile = join65(getPersonaDir(debateId, personaSlug), "report.md");
       const { data: reportData, content } = readFrontmatter(reportFile);
       const existingRounds = parseReportRounds(content);
       if (existingRounds.find((r) => r.round === round)) {
@@ -44608,7 +45056,7 @@ ${otherSerialized}
         persona: personaSlug,
         rounds_completed: Math.max(reportData.rounds_completed ?? 0, round)
       }, "\n" + merged);
-      const personaFile = join64(getPersonaDir(debateId, personaSlug), "context-and-persona.md");
+      const personaFile = join65(getPersonaDir(debateId, personaSlug), "context-and-persona.md");
       const { data: pData } = readFrontmatter(personaFile);
       updateFrontmatterFields(personaFile, {
         round_entries: Math.max(pData.round_entries ?? 0, round)
@@ -44651,13 +45099,13 @@ function registerResearch(council) {
         error("Research topic is required.");
         process.exit(1);
       }
-      const researchesDir = join64(getPersonaDir(debateId, personaSlug), "researches");
-      mkdirSync27(researchesDir, { recursive: true });
-      const indexPath2 = join64(researchesDir, "index.json");
-      if (!existsSync67(indexPath2)) writeJsonArray(indexPath2, []);
+      const researchesDir = join65(getPersonaDir(debateId, personaSlug), "researches");
+      mkdirSync28(researchesDir, { recursive: true });
+      const indexPath2 = join65(researchesDir, "index.json");
+      if (!existsSync68(indexPath2)) writeJsonArray(indexPath2, []);
       const slug = slugify(topic);
-      const file = join64(researchesDir, `${slug}.md`);
-      if (existsSync67(file)) {
+      const file = join65(researchesDir, `${slug}.md`);
+      if (existsSync68(file)) {
         error(`Research note already exists: ${slug}.md`);
         process.exit(1);
       }
@@ -44672,7 +45120,7 @@ _Added ${today()} by ${personaSlug}_
 
 ${body.trim()}
 `;
-      writeFileSync34(file, noteContent, "utf-8");
+      writeFileSync35(file, noteContent, "utf-8");
       insertToJsonArray(indexPath2, {
         slug,
         topic,
@@ -44687,9 +45135,9 @@ ${body.trim()}
   research.command("list").argument("<debate_id>").argument("<persona_slug>").description("List this persona's prior research notes.").action((debateId, personaSlug) => {
     try {
       ensurePersonaExists(debateId, personaSlug);
-      const researchesDir = join64(getPersonaDir(debateId, personaSlug), "researches");
-      const indexPath2 = join64(researchesDir, "index.json");
-      if (!existsSync67(indexPath2)) {
+      const researchesDir = join65(getPersonaDir(debateId, personaSlug), "researches");
+      const indexPath2 = join65(researchesDir, "index.json");
+      if (!existsSync68(indexPath2)) {
         console.log(source_default.dim("(no researches)"));
         return;
       }
@@ -44711,7 +45159,7 @@ function registerSynthesize(council) {
   council.command("synthesize").argument("<debate_id>").description("Mark status=synthesizing; print manifest of files synthesizer should read.").action((debateId) => {
     try {
       const data = readDebateFrontmatter(debateId);
-      const debateFile = join64(getDebateDir(debateId), "debate.md");
+      const debateFile = join65(getDebateDir(debateId), "debate.md");
       updateFrontmatterFields(debateFile, {
         status: "synthesizing",
         updated_at: today()
@@ -44733,8 +45181,8 @@ function registerSynthesize(council) {
         const personaDir = getPersonaDir(debateId, persona);
         manifest.push(`_dream_context/council/${debateId}/${persona}/context-and-persona.md`);
         manifest.push(`_dream_context/council/${debateId}/${persona}/report.md`);
-        const researchesIndex = join64(personaDir, "researches", "index.json");
-        if (existsSync67(researchesIndex)) {
+        const researchesIndex = join65(personaDir, "researches", "index.json");
+        if (existsSync68(researchesIndex)) {
           manifest.push(`_dream_context/council/${debateId}/${persona}/researches/`);
         }
       }
@@ -44752,12 +45200,12 @@ function registerComplete(council) {
   council.command("complete").argument("<debate_id>").description("Mark status=complete after final-report.md is written.").action((debateId) => {
     try {
       const data = readDebateFrontmatter(debateId);
-      const finalReport = join64(getDebateDir(debateId), "final-report.md");
-      if (!existsSync67(finalReport)) {
+      const finalReport = join65(getDebateDir(debateId), "final-report.md");
+      if (!existsSync68(finalReport)) {
         error("final-report.md not found.", "Synthesizer must write it before calling `council complete`.");
         process.exit(1);
       }
-      const debateFile = join64(getDebateDir(debateId), "debate.md");
+      const debateFile = join65(getDebateDir(debateId), "debate.md");
       updateFrontmatterFields(debateFile, {
         status: "complete",
         updated_at: today()
@@ -44789,8 +45237,8 @@ function registerPromote(council) {
         error(`Cannot promote: debate status is "${data.status}", expected "complete".`);
         process.exit(1);
       }
-      const finalReport = join64(getDebateDir(debateId), "final-report.md");
-      if (!existsSync67(finalReport)) {
+      const finalReport = join65(getDebateDir(debateId), "final-report.md");
+      if (!existsSync68(finalReport)) {
         error("final-report.md not found.");
         process.exit(1);
       }
@@ -44803,12 +45251,12 @@ function registerPromote(council) {
 
 ${sec.body.trim()}` : null;
       }).filter(Boolean).join("\n\n");
-      const knowledgeDir = join64(root, "knowledge");
-      mkdirSync27(knowledgeDir, { recursive: true });
+      const knowledgeDir = join65(root, "knowledge");
+      mkdirSync28(knowledgeDir, { recursive: true });
       const slug = slugify(data.topic).slice(0, 80) || debateId;
       const filename = `decision-${slug}.md`;
-      const target = join64(knowledgeDir, filename);
-      if (existsSync67(target) && !opts.force) {
+      const target = join65(knowledgeDir, filename);
+      if (existsSync68(target) && !opts.force) {
         error(`Knowledge file exists: ${filename}`, "Use --force to overwrite.");
         process.exit(1);
       }
@@ -44832,7 +45280,7 @@ ${kept}
 _Promoted from council debate \`${debateId}\` on ${today()}. See \`_dream_context/council/${debateId}/final-report.md\` for the full record._
 `;
       writeFrontmatter(target, knowledgeFrontmatter, body);
-      updateFrontmatterFields(join64(getDebateDir(debateId), "debate.md"), {
+      updateFrontmatterFields(join65(getDebateDir(debateId), "debate.md"), {
         promoted_to_knowledge: `knowledge/${filename}`,
         updated_at: today()
       });
@@ -44894,10 +45342,10 @@ function registerShow(council) {
       console.log(`  promoted:  ${data.promoted_to_knowledge ?? source_default.dim("(no)")}`);
       console.log(`  created:   ${data.created_at}`);
       console.log(`  updated:   ${data.updated_at}`);
-      const logFile = join64(getDebateDir(debateId), "round-log.md");
-      if (existsSync67(logFile)) {
+      const logFile = join65(getDebateDir(debateId), "round-log.md");
+      if (existsSync68(logFile)) {
         console.log("\n" + source_default.dim("\u2500\u2500\u2500 Round log \u2500\u2500\u2500"));
-        console.log(readFileSync49(logFile, "utf-8"));
+        console.log(readFileSync50(logFile, "utf-8"));
       }
     } catch (err) {
       error(err.message);
@@ -45089,12 +45537,12 @@ var init_env_loader = __esm({
 });
 
 // src/lib/marketing/config.ts
-import { existsSync as existsSync68, readFileSync as readFileSync50, writeFileSync as writeFileSync35, mkdirSync as mkdirSync28 } from "fs";
-import { dirname as dirname37 } from "path";
+import { existsSync as existsSync69, readFileSync as readFileSync51, writeFileSync as writeFileSync36, mkdirSync as mkdirSync29 } from "fs";
+import { dirname as dirname38 } from "path";
 function readEnvFile() {
   const path2 = MARKETING_PATHS.envFile();
-  if (!existsSync68(path2)) return {};
-  const raw = readFileSync50(path2, "utf8");
+  if (!existsSync69(path2)) return {};
+  const raw = readFileSync51(path2, "utf8");
   const parsed = parseEnv(raw);
   if (parsed.errors.length > 0) {
     for (const e of parsed.errors) {
@@ -45138,9 +45586,9 @@ function requireEnv(keys = REQUIRED_KEYS) {
 }
 function loadConfig() {
   const path2 = MARKETING_PATHS.configFile();
-  if (!existsSync68(path2)) return { ...EMPTY_CONFIG, feature_flags: { ...EMPTY_CONFIG.feature_flags } };
+  if (!existsSync69(path2)) return { ...EMPTY_CONFIG, feature_flags: { ...EMPTY_CONFIG.feature_flags } };
   try {
-    const raw = readFileSync50(path2, "utf8");
+    const raw = readFileSync51(path2, "utf8");
     const parsed = JSON.parse(raw);
     return {
       default_profile: parsed.default_profile ?? null,
@@ -45155,21 +45603,21 @@ function loadConfig() {
 }
 function writeConfig(cfg) {
   const path2 = MARKETING_PATHS.configFile();
-  mkdirSync28(dirname37(path2), { recursive: true });
-  writeFileSync35(path2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
+  mkdirSync29(dirname38(path2), { recursive: true });
+  writeFileSync36(path2, JSON.stringify(cfg, null, 2) + "\n", "utf8");
 }
 function ensureConfigFile() {
   const path2 = MARKETING_PATHS.configFile();
-  if (existsSync68(path2)) return loadConfig();
+  if (existsSync69(path2)) return loadConfig();
   const cfg = { ...EMPTY_CONFIG, feature_flags: { ...EMPTY_CONFIG.feature_flags } };
   writeConfig(cfg);
   return cfg;
 }
 function ensureEnvFile() {
   const path2 = MARKETING_PATHS.envFile();
-  if (existsSync68(path2)) return;
-  mkdirSync28(marketingRoot(), { recursive: true });
-  writeFileSync35(path2, ENV_TEMPLATE, { encoding: "utf8", mode: 384 });
+  if (existsSync69(path2)) return;
+  mkdirSync29(marketingRoot(), { recursive: true });
+  writeFileSync36(path2, ENV_TEMPLATE, { encoding: "utf8", mode: 384 });
 }
 var DEFAULT_API_VERSION, EMPTY_CONFIG, REQUIRED_KEYS, OPTIONAL_KEYS, ENV_TEMPLATE;
 var init_config2 = __esm({
@@ -45210,9 +45658,9 @@ REINFLUENCE_BIN=           # optional override; default uses .venv
 
 // src/lib/marketing/bootstrap.ts
 import { spawn as spawn5, spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync69, mkdirSync as mkdirSync29, cpSync as cpSync3 } from "fs";
+import { existsSync as existsSync70, mkdirSync as mkdirSync30, cpSync as cpSync3 } from "fs";
 import { fileURLToPath as fileURLToPath8 } from "url";
-import { dirname as dirname38, resolve as resolve17, join as join65 } from "path";
+import { dirname as dirname39, resolve as resolve17, join as join66 } from "path";
 function findBundledReinfluence() {
   const candidates = [
     // Installed npm package: dist/<chunk>.js -> ../tools/reinfluence
@@ -45222,7 +45670,7 @@ function findBundledReinfluence() {
     resolve17(__dirname7, "..", "..", "..", "tools", "reinfluence")
   ];
   for (const c of candidates) {
-    if (existsSync69(join65(c, "__main__.py"))) return c;
+    if (existsSync70(join66(c, "__main__.py"))) return c;
   }
   throw new Error(
     "Bundled reinfluence not found. Reinstall dreamcontext or set REINFLUENCE_BIN."
@@ -45253,18 +45701,18 @@ async function bootstrapMarketing(opts = {}) {
     if (verbose) process.stderr.write(`[mk init] ${msg}
 `);
   };
-  mkdirSync29(marketingRoot(), { recursive: true });
+  mkdirSync30(marketingRoot(), { recursive: true });
   const bundled = findBundledReinfluence();
   const target = MARKETING_PATHS.reinfluenceDir();
   log(`copying tools \u2192 ${target}`);
-  mkdirSync29(MARKETING_PATHS.toolsDir(), { recursive: true });
+  mkdirSync30(MARKETING_PATHS.toolsDir(), { recursive: true });
   cpSync3(bundled, target, { recursive: true });
   const py = findPython3();
   if (!py) {
     throw new Error("python3 not found on PATH. Install Python 3.10+ and retry.");
   }
   const venv = MARKETING_PATHS.venvDir();
-  if (!existsSync69(MARKETING_PATHS.venvPython())) {
+  if (!existsSync70(MARKETING_PATHS.venvPython())) {
     log(`creating venv \u2192 ${venv}`);
     const r2 = runBlocking(py, ["-m", "venv", venv]);
     if (r2.code !== 0) {
@@ -45277,7 +45725,7 @@ async function bootstrapMarketing(opts = {}) {
   log("upgrading pip");
   let r = runBlocking(venvPy, ["-m", "pip", "install", "--upgrade", "pip", "--quiet"]);
   if (r.code !== 0) log(`pip upgrade warning: ${r.stderr.trim().slice(0, 200)}`);
-  const reqs = join65(target, "requirements.txt");
+  const reqs = join66(target, "requirements.txt");
   log("installing python deps (whisper / yt-dlp / instaloader) \u2014 first run can take several minutes");
   r = runBlocking(venvPy, ["-m", "pip", "install", "-r", reqs, "--quiet"]);
   if (r.code !== 0) {
@@ -45287,7 +45735,7 @@ ${r.stderr.trim() || r.stdout.trim()}`);
   let whisperPrimed = false;
   if (whisperModel) {
     log(`pre-pulling whisper model "${whisperModel}" into ${MARKETING_PATHS.whisperCacheDir()}`);
-    mkdirSync29(MARKETING_PATHS.whisperCacheDir(), { recursive: true });
+    mkdirSync30(MARKETING_PATHS.whisperCacheDir(), { recursive: true });
     whisperPrimed = await primeWhisper(whisperModel);
     if (!whisperPrimed) log("whisper pre-pull failed (will retry on first ingest)");
   }
@@ -45327,15 +45775,15 @@ function subprocessEnv() {
   return {
     ...process.env,
     XDG_CACHE_HOME: cache,
-    HF_HOME: join65(cache, "hf"),
-    TRANSFORMERS_CACHE: join65(cache, "hf", "transformers"),
+    HF_HOME: join66(cache, "hf"),
+    TRANSFORMERS_CACHE: join66(cache, "hf", "transformers"),
     WHISPER_CACHE_DIR: MARKETING_PATHS.whisperCacheDir(),
     PYTHONUNBUFFERED: "1",
     PYTHONPATH: MARKETING_PATHS.toolsDir()
   };
 }
 function isBootstrapped() {
-  return existsSync69(MARKETING_PATHS.venvPython()) && existsSync69(join65(MARKETING_PATHS.reinfluenceDir(), "__main__.py"));
+  return existsSync70(MARKETING_PATHS.venvPython()) && existsSync70(join66(MARKETING_PATHS.reinfluenceDir(), "__main__.py"));
 }
 var __filename, __dirname7;
 var init_bootstrap = __esm({
@@ -45343,12 +45791,12 @@ var init_bootstrap = __esm({
     "use strict";
     init_paths2();
     __filename = fileURLToPath8(import.meta.url);
-    __dirname7 = dirname38(__filename);
+    __dirname7 = dirname39(__filename);
   }
 });
 
 // src/cli/commands/marketing/init.ts
-import { mkdirSync as mkdirSync30 } from "fs";
+import { mkdirSync as mkdirSync31 } from "fs";
 function registerMarketingInit(parent) {
   parent.command("init").description("Bootstrap _dream_context/marketing/ (folders, .env, venv, reinfluence tools, whisper cache)").option("--skip-bootstrap", "Only create folders + .env template; skip venv + pip install", false).option("--whisper-model <model>", "Whisper model to pre-pull (default: medium)", "medium").option("--no-whisper", "Skip Whisper model pre-pull").action(async (opts) => {
     try {
@@ -45359,7 +45807,7 @@ function registerMarketingInit(parent) {
     }
     console.log(header("Marketing init"));
     const root = marketingRoot();
-    mkdirSync30(root, { recursive: true });
+    mkdirSync31(root, { recursive: true });
     for (const dir of [
       MARKETING_PATHS.cohortsDir(),
       MARKETING_PATHS.campaignsDir(),
@@ -45372,7 +45820,7 @@ function registerMarketingInit(parent) {
       MARKETING_PATHS.byIdemDir(),
       MARKETING_PATHS.cacheDir()
     ]) {
-      mkdirSync30(dir, { recursive: true });
+      mkdirSync31(dir, { recursive: true });
     }
     info(`folders ready under ${source_default.dim(root)}`);
     ensureEnvFile();
@@ -45412,8 +45860,8 @@ var init_init2 = __esm({
 });
 
 // src/lib/marketing/vision.ts
-import { existsSync as existsSync70, readFileSync as readFileSync51, writeFileSync as writeFileSync36 } from "fs";
-import { dirname as dirname39, join as join66 } from "path";
+import { existsSync as existsSync71, readFileSync as readFileSync52, writeFileSync as writeFileSync37 } from "fs";
+import { dirname as dirname40, join as join67 } from "path";
 function pickVisionProvider(env2 = process.env) {
   const oai = env2.OPENAI_VISION_API_KEY;
   if (oai && oai.trim().length > 0) return { provider: "openai", apiKey: oai.trim() };
@@ -45452,11 +45900,11 @@ function parseLabelsFromText(text, allowlist = LABEL_ALLOWLIST) {
   return out;
 }
 async function readImageAsBase64(framePath) {
-  const buf = readFileSync51(framePath);
+  const buf = readFileSync52(framePath);
   return buf.toString("base64");
 }
 async function labelHookFrame(framePath, opts) {
-  if (!existsSync70(framePath)) return [];
+  if (!existsSync71(framePath)) return [];
   const fetcher = opts.fetcher ?? defaultFetcher;
   const prompt = opts.promptOverride ?? PROMPT;
   const b64 = await readImageAsBase64(framePath);
@@ -45506,7 +45954,7 @@ async function labelHookFrame(framePath, opts) {
   return parseLabelsFromText(text);
 }
 async function runVisionPassOnPost(postJsonPath, opts = {}) {
-  const raw = readFileSync51(postJsonPath, "utf-8");
+  const raw = readFileSync52(postJsonPath, "utf-8");
   const post = JSON.parse(raw);
   const shortcode = post.shortcode ?? "?";
   const provider = opts.provider && opts.apiKey ? { provider: opts.provider, apiKey: opts.apiKey } : pickVisionProvider();
@@ -45545,15 +45993,15 @@ async function runVisionPassOnPost(postJsonPath, opts = {}) {
   post.pattern_tags = [...aggregated].sort();
   post.vision_summary = post.pattern_tags.length > 0 ? `Vision-tagged ${framesLabeled}/${hookFrames.length} hook frames; patterns: ${post.pattern_tags.join(", ")}.` : `Vision pass found no allowlisted patterns across ${hookFrames.length} hook frames.`;
   const tmp = postJsonPath + ".tmp";
-  writeFileSync36(tmp, JSON.stringify(post, null, 2) + "\n", "utf-8");
+  writeFileSync37(tmp, JSON.stringify(post, null, 2) + "\n", "utf-8");
   const fs = await import("fs");
   fs.renameSync(tmp, postJsonPath);
-  const mdPath = join66(dirname39(postJsonPath), `${shortcode}.md`);
-  if (existsSync70(mdPath)) {
+  const mdPath = join67(dirname40(postJsonPath), `${shortcode}.md`);
+  if (existsSync71(mdPath)) {
     try {
-      const md = readFileSync51(mdPath, "utf-8");
+      const md = readFileSync52(mdPath, "utf-8");
       const refreshed = updatePatternTagsInBridge(md, post.pattern_tags);
-      writeFileSync36(mdPath, refreshed, "utf-8");
+      writeFileSync37(mdPath, refreshed, "utf-8");
     } catch {
     }
   }
@@ -45628,8 +46076,8 @@ Example output: ["talking-head","prop-driven"]`;
 // src/lib/marketing/competitors.ts
 import { spawn as spawn6 } from "child_process";
 import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync71, mkdirSync as mkdirSync31, statfsSync } from "fs";
-import { dirname as dirname40, join as join67, basename as basename20, extname as extname4 } from "path";
+import { existsSync as existsSync72, mkdirSync as mkdirSync32, statfsSync } from "fs";
+import { dirname as dirname41, join as join68, basename as basename20, extname as extname4 } from "path";
 function which(cmd) {
   const r = spawnSync3(process.platform === "win32" ? "where" : "which", [cmd], { encoding: "utf8" });
   if (r.status === 0) return (r.stdout || "").trim().split("\n")[0] || null;
@@ -45706,8 +46154,8 @@ ${h.installHints.join("\n")}`);
     skip_transcripts: !!opts.skipTranscripts,
     skip_frames: !!opts.skipFrames
   });
-  const outDir = join67(MARKETING_PATHS.competitorsDir(), "_ingest-tmp", run2.id);
-  mkdirSync31(outDir, { recursive: true });
+  const outDir = join68(MARKETING_PATHS.competitorsDir(), "_ingest-tmp", run2.id);
+  mkdirSync32(outDir, { recursive: true });
   const args = [
     "-m",
     "reinfluence",
@@ -45807,15 +46255,15 @@ stderr: ${stderrBuf.slice(0, 1e3)}`));
   return { runId: run2.id, postsIngested, warnings, errors };
 }
 function persistPost(evt) {
-  const handleDir = join67(MARKETING_PATHS.competitorsDir(), evt.handle);
-  const postsDir = join67(handleDir, "posts");
-  const mediaDir = join67(handleDir, "_media", evt.shortcode);
-  mkdirSync31(postsDir, { recursive: true });
-  mkdirSync31(mediaDir, { recursive: true });
-  const finalVideoPath = evt.video_path ? moveAsset(evt.video_path, join67(mediaDir, basename20(evt.video_path))) : null;
+  const handleDir = join68(MARKETING_PATHS.competitorsDir(), evt.handle);
+  const postsDir = join68(handleDir, "posts");
+  const mediaDir = join68(handleDir, "_media", evt.shortcode);
+  mkdirSync32(postsDir, { recursive: true });
+  mkdirSync32(mediaDir, { recursive: true });
+  const finalVideoPath = evt.video_path ? moveAsset(evt.video_path, join68(mediaDir, basename20(evt.video_path))) : null;
   const finalFramePaths = [];
   for (const fr of evt.frames) {
-    const finalP = moveAsset(fr.path, join67(mediaDir, "frames", basename20(fr.path)));
+    const finalP = moveAsset(fr.path, join68(mediaDir, "frames", basename20(fr.path)));
     finalFramePaths.push(finalP);
   }
   const id = `${evt.handle}__${evt.shortcode}`;
@@ -45835,14 +46283,14 @@ function persistPost(evt) {
     ingested_at: (/* @__PURE__ */ new Date()).toISOString(),
     asset_paths: { video: finalVideoPath, frames: finalFramePaths }
   };
-  const jsonPath = join67(postsDir, `${evt.shortcode}.json`);
-  const bridgePath = join67(postsDir, `${evt.shortcode}.md`);
+  const jsonPath = join68(postsDir, `${evt.shortcode}.json`);
+  const bridgePath = join68(postsDir, `${evt.shortcode}.md`);
   writeJsonWithBridge(jsonPath, bridgePath, json, renderPostBridge(json));
-  const metaPath = join67(handleDir, "meta.json");
-  if (!existsSync71(metaPath)) {
+  const metaPath = join68(handleDir, "meta.json");
+  if (!existsSync72(metaPath)) {
     writeJsonWithBridge(
       metaPath,
-      join67(handleDir, "meta.md"),
+      join68(handleDir, "meta.md"),
       { handle: evt.handle, first_seen_at: (/* @__PURE__ */ new Date()).toISOString() },
       `---
 id: competitor_${evt.handle}
@@ -45859,8 +46307,8 @@ First seen: ${(/* @__PURE__ */ new Date()).toISOString()}
   return jsonPath;
 }
 function moveAsset(src, dest) {
-  if (!existsSync71(src)) return dest;
-  mkdirSync31(dirname40(dest), { recursive: true });
+  if (!existsSync72(src)) return dest;
+  mkdirSync32(dirname41(dest), { recursive: true });
   const fs = __require("fs");
   try {
     fs.renameSync(src, dest);
@@ -45921,8 +46369,8 @@ var init_competitors = __esm({
 });
 
 // src/cli/commands/marketing/competitor.ts
-import { existsSync as existsSync72, readdirSync as readdirSync16, statSync as statSync11 } from "fs";
-import { join as join68 } from "path";
+import { existsSync as existsSync73, readdirSync as readdirSync16, statSync as statSync11 } from "fs";
+import { join as join69 } from "path";
 function registerMarketingCompetitor(parent) {
   const cmd = parent.command("competitor").description("Ingest competitor IG / YouTube content (Reinfluence pipeline).");
   cmd.command("ingest <target>").description("Ingest a single URL or an IG handle. Outputs land under _dream_context/marketing/competitors/<handle>/.").option("--model <name>", "Whisper model size (tiny|base|small|medium|large)", "medium").option("--max <n>", "Max reels for IG handle ingest (0 = all)", "0").option("--skip-transcripts", "Skip Whisper transcription", false).option("--skip-frames", "Skip frame extraction", false).option("--timeout <seconds>", "Wall-clock kill", "600").action(async (target, opts) => {
@@ -45972,13 +46420,13 @@ function registerMarketingCompetitor(parent) {
   });
   cmd.command("list").description("List ingested competitor handles.").action(() => {
     const dir = MARKETING_PATHS.competitorsDir();
-    if (!existsSync72(dir)) {
+    if (!existsSync73(dir)) {
       info("No competitors ingested yet.");
       return;
     }
     const handles = readdirSync16(dir).filter((name) => {
       if (name.startsWith("_") || name.startsWith(".")) return false;
-      const full = join68(dir, name);
+      const full = join69(dir, name);
       try {
         return statSync11(full).isDirectory();
       } catch {
@@ -45991,8 +46439,8 @@ function registerMarketingCompetitor(parent) {
     }
     console.log(header("Competitors"));
     for (const handle of handles) {
-      const postsDir = join68(dir, handle, "posts");
-      const postCount = existsSync72(postsDir) ? readdirSync16(postsDir).filter((f) => f.endsWith(".json")).length : 0;
+      const postsDir = join69(dir, handle, "posts");
+      const postCount = existsSync73(postsDir) ? readdirSync16(postsDir).filter((f) => f.endsWith(".json")).length : 0;
       console.log(`  ${source_default.cyan("@" + handle)}  ${source_default.dim(`${postCount} post(s)`)}`);
     }
   });
@@ -46005,11 +46453,11 @@ function registerMarketingCompetitor(parent) {
     }
     info(`Provider: ${provider.provider}`);
     const competitorsDir = MARKETING_PATHS.competitorsDir();
-    const handles = opts.handle ? [opts.handle] : existsSync72(competitorsDir) ? readdirSync16(competitorsDir).filter((h) => !h.startsWith("_") && statSync11(join68(competitorsDir, h)).isDirectory()) : [];
+    const handles = opts.handle ? [opts.handle] : existsSync73(competitorsDir) ? readdirSync16(competitorsDir).filter((h) => !h.startsWith("_") && statSync11(join69(competitorsDir, h)).isDirectory()) : [];
     const matches = [];
     for (const h of handles) {
-      const candidate = join68(competitorsDir, h, "posts", `${shortcode}.json`);
-      if (existsSync72(candidate)) matches.push(candidate);
+      const candidate = join69(competitorsDir, h, "posts", `${shortcode}.json`);
+      if (existsSync73(candidate)) matches.push(candidate);
     }
     if (matches.length === 0) {
       error(`No post JSON found for shortcode "${shortcode}".`);
@@ -46044,18 +46492,18 @@ function registerMarketingCompetitor(parent) {
       process.exit(1);
     }
     const competitorsDir = MARKETING_PATHS.competitorsDir();
-    if (!existsSync72(competitorsDir)) {
+    if (!existsSync73(competitorsDir)) {
       warn("No competitors directory yet \u2014 nothing to relabel.");
       return;
     }
-    const handles = readdirSync16(competitorsDir).filter((h) => !h.startsWith("_") && statSync11(join68(competitorsDir, h)).isDirectory());
+    const handles = readdirSync16(competitorsDir).filter((h) => !h.startsWith("_") && statSync11(join69(competitorsDir, h)).isDirectory());
     let labeled = 0;
     let skipped = 0;
     for (const h of handles) {
-      const postsDir = join68(competitorsDir, h, "posts");
-      if (!existsSync72(postsDir)) continue;
+      const postsDir = join69(competitorsDir, h, "posts");
+      if (!existsSync73(postsDir)) continue;
       for (const f of readdirSync16(postsDir).filter((n) => n.endsWith(".json"))) {
-        const path2 = join68(postsDir, f);
+        const path2 = join69(postsDir, f);
         if (opts.dryRun) {
           info(`would relabel: ${path2}`);
           continue;
@@ -46102,8 +46550,8 @@ var init_competitor = __esm({
 });
 
 // src/lib/marketing/meta-fetch.ts
-import { existsSync as existsSync73, mkdirSync as mkdirSync32, readFileSync as readFileSync52, writeFileSync as writeFileSync37, statSync as statSync12, openSync as openSync2, readSync, closeSync as closeSync2 } from "fs";
-import { dirname as dirname41, basename as basename21 } from "path";
+import { existsSync as existsSync74, mkdirSync as mkdirSync33, readFileSync as readFileSync53, writeFileSync as writeFileSync38, statSync as statSync12, openSync as openSync2, readSync, closeSync as closeSync2 } from "fs";
+import { dirname as dirname42, basename as basename21 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 function getQueue(accountId) {
   let q = writeQueues.get(accountId);
@@ -46153,17 +46601,17 @@ function idemCachePath(key) {
 }
 function readIdem(key) {
   const p = idemCachePath(key);
-  if (!existsSync73(p)) return null;
+  if (!existsSync74(p)) return null;
   try {
-    return JSON.parse(readFileSync52(p, "utf8"));
+    return JSON.parse(readFileSync53(p, "utf8"));
   } catch {
     return null;
   }
 }
 function writeIdem(rec) {
   const p = idemCachePath(rec.key);
-  mkdirSync32(dirname41(p), { recursive: true });
-  writeFileSync37(p, JSON.stringify(rec, null, 2) + "\n", "utf8");
+  mkdirSync33(dirname42(p), { recursive: true });
+  writeFileSync38(p, JSON.stringify(rec, null, 2) + "\n", "utf8");
 }
 function backoffMs(attempt, hintSec) {
   if (hintSec != null && Number.isFinite(hintSec) && hintSec > 0) {
@@ -46431,7 +46879,7 @@ async function singleShotVideoUpload(ctx, filepath, fields) {
     if (fields.name) form.set("name", fields.name);
     if (fields.title) form.set("title", fields.title);
     if (fields.description) form.set("description", fields.description);
-    const buffer = readFileSync52(filepath);
+    const buffer = readFileSync53(filepath);
     const blob = new Blob([new Uint8Array(buffer)], { type: "video/mp4" });
     form.set("source", blob, basename21(filepath));
     const resp = await fetch(url, {
@@ -46480,7 +46928,7 @@ async function uploadImageFile(ctx, filepath) {
   return withWriteSlot(ctx.adAccountId, async () => {
     const url = buildUrl(ctx, { method: "POST", path: `${ctx.adAccountId}/adimages` });
     const form = new FormData();
-    const buffer = readFileSync52(filepath);
+    const buffer = readFileSync53(filepath);
     const blob = new Blob([new Uint8Array(buffer)], { type: "image/png" });
     form.set("filename", blob, basename21(filepath));
     const resp = await fetch(url, {
@@ -46899,7 +47347,7 @@ var init_account = __esm({
 });
 
 // src/lib/marketing/hypothesis.ts
-import { existsSync as existsSync74, readFileSync as readFileSync53 } from "fs";
+import { existsSync as existsSync75, readFileSync as readFileSync54 } from "fs";
 function validateHypothesis(raw, options2 = {}) {
   const errors = [];
   const fieldErrors = {};
@@ -46966,12 +47414,12 @@ function validateHypothesis(raw, options2 = {}) {
   };
 }
 function loadHypothesisFile(path2, options2 = {}) {
-  if (!existsSync74(path2)) {
+  if (!existsSync75(path2)) {
     return { ok: false, errors: [`Hypothesis file not found: ${path2}`] };
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync53(path2, "utf8"));
+    parsed = JSON.parse(readFileSync54(path2, "utf8"));
   } catch (e) {
     return { ok: false, errors: [`Failed to parse JSON at ${path2}: ${e.message}`] };
   }
@@ -47159,8 +47607,8 @@ var init_cohort2 = __esm({
 });
 
 // src/lib/marketing/insights-cache.ts
-import { existsSync as existsSync75, readFileSync as readFileSync54, mkdirSync as mkdirSync33, writeFileSync as writeFileSync38, readdirSync as readdirSync17, statSync as statSync13 } from "fs";
-import { join as join69 } from "path";
+import { existsSync as existsSync76, readFileSync as readFileSync55, mkdirSync as mkdirSync34, writeFileSync as writeFileSync39, readdirSync as readdirSync17, statSync as statSync13 } from "fs";
+import { join as join70 } from "path";
 import { randomBytes as randomBytes3 } from "crypto";
 function snapshotFilename(entityId, pulledAt) {
   const yyyy = pulledAt.getUTCFullYear();
@@ -47171,30 +47619,30 @@ function snapshotFilename(entityId, pulledAt) {
   return `${safe}__${yyyy}-${mm}-${dd}-${hh}.json`;
 }
 function indexPath() {
-  return join69(MARKETING_PATHS.insightsDir(), "_index.json");
+  return join70(MARKETING_PATHS.insightsDir(), "_index.json");
 }
 function readIndex() {
   const p = indexPath();
-  if (!existsSync75(p)) return { latest: {}, updated_at: "1970-01-01T00:00:00Z" };
+  if (!existsSync76(p)) return { latest: {}, updated_at: "1970-01-01T00:00:00Z" };
   try {
-    return JSON.parse(readFileSync54(p, "utf8"));
+    return JSON.parse(readFileSync55(p, "utf8"));
   } catch {
     return { latest: {}, updated_at: "1970-01-01T00:00:00Z" };
   }
 }
 function writeIndex(idx) {
   const p = indexPath();
-  mkdirSync33(MARKETING_PATHS.insightsDir(), { recursive: true });
+  mkdirSync34(MARKETING_PATHS.insightsDir(), { recursive: true });
   const tmp = `${p}.tmp.${process.pid}.${randomBytes3(4).toString("hex")}`;
-  writeFileSync38(tmp, JSON.stringify(idx, null, 2) + "\n", "utf8");
+  writeFileSync39(tmp, JSON.stringify(idx, null, 2) + "\n", "utf8");
   __require("fs").renameSync(tmp, p);
 }
 function saveInsightsSnapshot(snap) {
-  mkdirSync33(MARKETING_PATHS.insightsDir(), { recursive: true });
+  mkdirSync34(MARKETING_PATHS.insightsDir(), { recursive: true });
   const filename = snapshotFilename(snap.entity_id, new Date(snap.pulled_at));
-  const fullPath = join69(MARKETING_PATHS.insightsDir(), filename);
+  const fullPath = join70(MARKETING_PATHS.insightsDir(), filename);
   const tmp = `${fullPath}.tmp.${process.pid}.${randomBytes3(4).toString("hex")}`;
-  writeFileSync38(tmp, JSON.stringify(snap, null, 2) + "\n", "utf8");
+  writeFileSync39(tmp, JSON.stringify(snap, null, 2) + "\n", "utf8");
   __require("fs").renameSync(tmp, fullPath);
   const idx = readIndex();
   idx.latest[snap.entity_id] = filename;
@@ -47206,10 +47654,10 @@ function getCachedInsights(entityId) {
   const idx = readIndex();
   const filename = idx.latest[entityId];
   if (!filename) return null;
-  const fullPath = join69(MARKETING_PATHS.insightsDir(), filename);
-  if (!existsSync75(fullPath)) return null;
+  const fullPath = join70(MARKETING_PATHS.insightsDir(), filename);
+  if (!existsSync76(fullPath)) return null;
   try {
-    const snap = JSON.parse(readFileSync54(fullPath, "utf8"));
+    const snap = JSON.parse(readFileSync55(fullPath, "utf8"));
     const ageMs = Date.now() - new Date(snap.pulled_at).getTime();
     if (ageMs > INSIGHTS_TTL_MS) return null;
     return snap;
@@ -47221,20 +47669,20 @@ function getLatestSnapshot(entityId) {
   const idx = readIndex();
   const filename = idx.latest[entityId];
   if (!filename) return null;
-  const fullPath = join69(MARKETING_PATHS.insightsDir(), filename);
-  if (!existsSync75(fullPath)) return null;
+  const fullPath = join70(MARKETING_PATHS.insightsDir(), filename);
+  if (!existsSync76(fullPath)) return null;
   try {
-    return JSON.parse(readFileSync54(fullPath, "utf8"));
+    return JSON.parse(readFileSync55(fullPath, "utf8"));
   } catch {
     return null;
   }
 }
 function getPriorSnapshot(entityId, beforeMs) {
   const dir = MARKETING_PATHS.insightsDir();
-  if (!existsSync75(dir)) return null;
+  if (!existsSync76(dir)) return null;
   const safe = entityId.replace(/[^A-Za-z0-9_-]/g, "_");
   const candidates = readdirSync17(dir).filter((f) => f.startsWith(`${safe}__`) && f.endsWith(".json")).map((f) => {
-    const p = join69(dir, f);
+    const p = join70(dir, f);
     const stat = statSync13(p);
     return { f, p, mtimeMs: stat.mtimeMs };
   }).sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -47242,7 +47690,7 @@ function getPriorSnapshot(entityId, beforeMs) {
   for (const c of candidates) {
     if (c.mtimeMs <= cutoff) {
       try {
-        return JSON.parse(readFileSync54(c.p, "utf8"));
+        return JSON.parse(readFileSync55(c.p, "utf8"));
       } catch {
         continue;
       }
@@ -47878,8 +48326,8 @@ var init_kill = __esm({
 });
 
 // src/cli/commands/marketing/doctor.ts
-import { readFileSync as readFileSync55, readdirSync as readdirSync18, statSync as statSync14 } from "fs";
-import { join as join70 } from "path";
+import { readFileSync as readFileSync56, readdirSync as readdirSync18, statSync as statSync14 } from "fs";
+import { join as join71 } from "path";
 function registerMarketingDoctor(parent) {
   parent.command("doctor").description("Run diagnostics: env, FK integrity, retroactive secret scan, Reinfluence health.").option("--scan", "Run retroactive secret scan over the entire _dream_context/ tree", false).action(async (opts) => {
     console.log(header("Marketing doctor"));
@@ -47960,7 +48408,7 @@ function scanForSecrets(root) {
   for (const file of walkText(root)) {
     let txt;
     try {
-      txt = readFileSync55(file, "utf8");
+      txt = readFileSync56(file, "utf8");
     } catch {
       continue;
     }
@@ -47987,7 +48435,7 @@ function* walkText(dir) {
   }
   for (const e of entries) {
     if (e.startsWith(".") && (e === ".env" || e === ".env.local")) continue;
-    const full = join70(dir, e);
+    const full = join71(dir, e);
     let stat;
     try {
       stat = statSync14(full);
@@ -48025,8 +48473,8 @@ var init_doctor2 = __esm({
 });
 
 // src/lib/marketing/entity-store.ts
-import { existsSync as existsSync77, readFileSync as readFileSync56, readdirSync as readdirSync19 } from "fs";
-import { join as join71 } from "path";
+import { existsSync as existsSync78, readFileSync as readFileSync57, readdirSync as readdirSync19 } from "fs";
+import { join as join72 } from "path";
 function dirFor(kind) {
   switch (kind) {
     case "campaign":
@@ -48045,24 +48493,24 @@ function newEntityId(kind) {
 }
 function entityPaths(kind, id) {
   const d = dirFor(kind);
-  return { json: join71(d, `${id}.json`), md: join71(d, `${id}.md`) };
+  return { json: join72(d, `${id}.json`), md: join72(d, `${id}.md`) };
 }
 function loadEntity(kind, id) {
   const { json } = entityPaths(kind, id);
-  if (!existsSync77(json)) return null;
+  if (!existsSync78(json)) return null;
   try {
-    return JSON.parse(readFileSync56(json, "utf8"));
+    return JSON.parse(readFileSync57(json, "utf8"));
   } catch {
     return null;
   }
 }
 function listEntities(kind) {
   const d = dirFor(kind);
-  if (!existsSync77(d)) return [];
+  if (!existsSync78(d)) return [];
   const out = [];
   for (const f of readdirSync19(d).filter((x) => x.endsWith(".json"))) {
     try {
-      out.push(JSON.parse(readFileSync56(join71(d, f), "utf8")));
+      out.push(JSON.parse(readFileSync57(join72(d, f), "utf8")));
     } catch {
     }
   }
@@ -48256,7 +48704,7 @@ var init_campaign = __esm({
 });
 
 // src/cli/commands/marketing/adset.ts
-import { existsSync as existsSync78, readFileSync as readFileSync57 } from "fs";
+import { existsSync as existsSync79, readFileSync as readFileSync58 } from "fs";
 function registerMarketingAdSet(parent) {
   const cmd = parent.command("adset").description("Manage adsets.");
   cmd.command("create").description("Create an adset (PAUSED). --daily-budget required (no fallback).").requiredOption("--campaign <id>", "parent campaign local id").requiredOption("--name <name>", "adset name").requiredOption("--daily-budget <amount>", "daily budget (major-currency units)").requiredOption("--targeting <file>", "JSON file with Meta targeting spec").option("--currency <code>", "currency code", "TRY").option("--optimization-goal <goal>", "OFFSITE_CONVERSIONS|LINK_CLICKS|...", "OFFSITE_CONVERSIONS").option("--billing-event <event>", "IMPRESSIONS|LINK_CLICKS|THRUPLAY", "IMPRESSIONS").option("--custom-event-type <evt>", "e.g. PURCHASE, COMPLETE_REGISTRATION (for OFFSITE_CONVERSIONS)").option("--no-dry-run", "Actually create on Meta").action(async (opts) => {
@@ -48276,13 +48724,13 @@ function registerMarketingAdSet(parent) {
       }
       throw e;
     }
-    if (!existsSync78(opts.targeting)) {
+    if (!existsSync79(opts.targeting)) {
       error(`Targeting file not found: ${opts.targeting}`);
       process.exit(1);
     }
     let targeting;
     try {
-      targeting = JSON.parse(readFileSync57(opts.targeting, "utf8"));
+      targeting = JSON.parse(readFileSync58(opts.targeting, "utf8"));
     } catch (e) {
       error(`Failed to parse targeting JSON: ${e.message}`);
       process.exit(1);
@@ -48539,12 +48987,12 @@ var init_creative = __esm({
 });
 
 // src/cli/commands/marketing/asset.ts
-import { existsSync as existsSync79, statSync as statSync15 } from "fs";
+import { existsSync as existsSync80, statSync as statSync15 } from "fs";
 import { extname as extname5 } from "path";
 function registerMarketingAsset(parent) {
   const cmd = parent.command("asset").description("Upload creative assets to Meta.");
   cmd.command("upload <path>").description("Upload a video (>50MB \u2192 chunked) or image to Meta. Returns id/hash.").option("--type <type>", "override auto-detection (video|image)").option("--name <name>", "asset name (videos)").option("--no-dry-run", "Actually upload to Meta").action(async (path2, opts) => {
-    if (!existsSync79(path2)) {
+    if (!existsSync80(path2)) {
       error(`File not found: ${path2}`);
       process.exit(1);
     }
@@ -48712,8 +49160,8 @@ var init_ad = __esm({
 });
 
 // src/lib/marketing/launch.ts
-import { existsSync as existsSync80, readFileSync as readFileSync58, writeFileSync as writeFileSync39, mkdirSync as mkdirSync34, renameSync as renameSync8, readdirSync as readdirSync20 } from "fs";
-import { dirname as dirname42, join as join72, basename as basename22 } from "path";
+import { existsSync as existsSync81, readFileSync as readFileSync59, writeFileSync as writeFileSync40, mkdirSync as mkdirSync35, renameSync as renameSync8, readdirSync as readdirSync20 } from "fs";
+import { dirname as dirname43, join as join73, basename as basename22 } from "path";
 import { randomBytes as randomBytes4 } from "crypto";
 function buildLaunchSummary(cohortId) {
   const cohort = loadCohort(cohortId);
@@ -48757,15 +49205,15 @@ function isoTs2() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 }
 function atomicWriteFile3(path2, data) {
-  mkdirSync34(dirname42(path2), { recursive: true });
+  mkdirSync35(dirname43(path2), { recursive: true });
   const tmp = `${path2}.tmp.${process.pid}.${randomBytes4(4).toString("hex")}`;
-  writeFileSync39(tmp, data, "utf8");
+  writeFileSync40(tmp, data, "utf8");
   renameSync8(tmp, path2);
 }
 function readWal(path2) {
-  if (!existsSync80(path2)) return null;
+  if (!existsSync81(path2)) return null;
   try {
-    return JSON.parse(readFileSync58(path2, "utf8"));
+    return JSON.parse(readFileSync59(path2, "utf8"));
   } catch {
     return null;
   }
@@ -48775,13 +49223,13 @@ function writeWal(path2, wal) {
 }
 function findWalByRunId(runId) {
   const dir = MARKETING_PATHS.runsDir();
-  if (!existsSync80(dir)) return null;
+  if (!existsSync81(dir)) return null;
   for (const f of readdirSync20(dir)) {
     if (!f.endsWith(".json")) continue;
     if (f.startsWith("by-idem")) continue;
     const stem = f.replace(/\.json$/, "");
     if (stem === runId || f === runId || basename22(f, ".json") === runId) {
-      return join72(dir, f);
+      return join73(dir, f);
     }
   }
   return null;
@@ -48821,7 +49269,7 @@ function createLaunchWal(args) {
     flipped_count: 0,
     error: null
   };
-  const walPath = join72(MARKETING_PATHS.runsDir(), `${id}.json`);
+  const walPath = join73(MARKETING_PATHS.runsDir(), `${id}.json`);
   writeWal(walPath, wal);
   return { walPath, wal };
 }
@@ -49052,7 +49500,7 @@ var init_launch2 = __esm({
 });
 
 // src/cli/commands/marketing/learnings.ts
-import { existsSync as existsSync81, readFileSync as readFileSync59 } from "fs";
+import { existsSync as existsSync82, readFileSync as readFileSync60 } from "fs";
 function registerMarketingLearnings(parent) {
   const cmd = parent.command("learnings").description("Performance Monitor learnings ledger (per-day .md + index).");
   cmd.command("show").description("Show today's (or specified day's) learnings file.").option("--date <YYYY-MM-DD>", "Day to show (default: today UTC)").option("--id <id>", "Show a single entry by id").action((opts) => {
@@ -49195,8 +49643,8 @@ async function resolveBody(body, bodyFile) {
   if (body) return body;
   if (bodyFile === "-") return readStdin3();
   if (bodyFile) {
-    if (!existsSync81(bodyFile)) throw new Error(`Body file not found: ${bodyFile}`);
-    return readFileSync59(bodyFile, "utf8");
+    if (!existsSync82(bodyFile)) throw new Error(`Body file not found: ${bodyFile}`);
+    return readFileSync60(bodyFile, "utf8");
   }
   return null;
 }
@@ -49226,29 +49674,29 @@ var init_learnings2 = __esm({
 
 // src/lib/marketing/rem-sleep.ts
 import {
-  existsSync as existsSync82,
-  mkdirSync as mkdirSync35,
-  readFileSync as readFileSync60,
-  writeFileSync as writeFileSync40,
+  existsSync as existsSync83,
+  mkdirSync as mkdirSync36,
+  readFileSync as readFileSync61,
+  writeFileSync as writeFileSync41,
   readdirSync as readdirSync21,
   statSync as statSync16,
   unlinkSync as unlinkSync3,
   renameSync as renameSync9
 } from "fs";
-import { dirname as dirname43, join as join73 } from "path";
+import { dirname as dirname44, join as join74 } from "path";
 import { randomBytes as randomBytes5 } from "crypto";
 function atomicWriteFile4(path2, data) {
-  mkdirSync35(dirname43(path2), { recursive: true });
+  mkdirSync36(dirname44(path2), { recursive: true });
   const tmp = `${path2}.tmp.${process.pid}.${randomBytes5(4).toString("hex")}`;
-  writeFileSync40(tmp, data, "utf8");
+  writeFileSync41(tmp, data, "utf8");
   renameSync9(tmp, path2);
 }
 function pruneRuns(opts = {}) {
   const keepLast = opts.keepLast ?? 100;
   const dir = MARKETING_PATHS.runsDir();
-  if (!existsSync82(dir)) return { scanned: 0, kept: 0, deleted: 0, deletedFiles: [] };
+  if (!existsSync83(dir)) return { scanned: 0, kept: 0, deleted: 0, deletedFiles: [] };
   const files = readdirSync21(dir).filter((f) => f.endsWith(".json")).map((f) => {
-    const p = join73(dir, f);
+    const p = join74(dir, f);
     try {
       return { f, p, mtimeMs: statSync16(p).mtimeMs };
     } catch {
@@ -49282,13 +49730,13 @@ function compactInsights(opts = {}) {
   const weeklyAfterDays = opts.weeklyAfterDays ?? 14;
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const dir = MARKETING_PATHS.insightsDir();
-  if (!existsSync82(dir)) return { scanned: 0, kept: 0, deleted: 0, deletedFiles: [] };
+  if (!existsSync83(dir)) return { scanned: 0, kept: 0, deleted: 0, deletedFiles: [] };
   const files = [];
   for (const f of readdirSync21(dir)) {
     if (!f.endsWith(".json") || f.startsWith("_")) continue;
     const m = f.match(SNAP_RE);
     if (!m) continue;
-    const p = join73(dir, f);
+    const p = join74(dir, f);
     try {
       const stat = statSync16(p);
       files.push({ f, p, mtimeMs: stat.mtimeMs, entityId: m[1], bucket: m[2] });
@@ -49354,7 +49802,7 @@ function mergeDailyLearnings(opts = {}) {
   const retainDays = opts.retainDays ?? 7;
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const dir = MARKETING_PATHS.learningsDir();
-  if (!existsSync82(dir)) {
+  if (!existsSync83(dir)) {
     return { scanned: 0, merged: 0, archivePath: null, droppedRejected: 0, mergedFiles: [] };
   }
   const dayMs = 24 * 60 * 60 * 1e3;
@@ -49365,7 +49813,7 @@ function mergeDailyLearnings(opts = {}) {
     if (!m) continue;
     const date = m[1];
     const dateMs = (/* @__PURE__ */ new Date(`${date}T00:00:00Z`)).getTime();
-    if (dateMs < cutoff) candidates.push({ f, p: join73(dir, f), date });
+    if (dateMs < cutoff) candidates.push({ f, p: join74(dir, f), date });
   }
   if (candidates.length === 0) {
     return { scanned: 0, merged: 0, archivePath: null, droppedRejected: 0, mergedFiles: [] };
@@ -49379,10 +49827,10 @@ function mergeDailyLearnings(opts = {}) {
   const mergedFiles = [];
   let lastArchivePath = null;
   for (const [q, list] of byQuarter) {
-    const archivePath = join73(dir, `_archive-${q}.md`);
+    const archivePath = join74(dir, `_archive-${q}.md`);
     list.sort((a, b) => a.date.localeCompare(b.date));
     for (const c of list) {
-      const existingArchive = existsSync82(archivePath) ? readFileSync60(archivePath, "utf8") : `# Marketing learnings archive \u2014 ${q}
+      const existingArchive = existsSync83(archivePath) ? readFileSync61(archivePath, "utf8") : `# Marketing learnings archive \u2014 ${q}
 `;
       const dateMarker = `# Marketing learnings \u2014 ${c.date}`;
       const alreadyMerged = existingArchive.includes(dateMarker);
@@ -49391,7 +49839,7 @@ function mergeDailyLearnings(opts = {}) {
         continue;
       }
       if (!alreadyMerged) {
-        const body = readFileSync60(c.p, "utf8").trimEnd();
+        const body = readFileSync61(c.p, "utf8").trimEnd();
         const next2 = existingArchive.trimEnd() + "\n\n" + body + "\n";
         atomicWriteFile4(archivePath, next2);
       }
@@ -49434,14 +49882,14 @@ function quarterKey(yyyymmdd) {
 }
 function redactRunsSweep(opts = {}) {
   const dir = MARKETING_PATHS.runsDir();
-  if (!existsSync82(dir)) return { scanned: 0, rewritten: 0, rewrittenFiles: [] };
+  if (!existsSync83(dir)) return { scanned: 0, rewritten: 0, rewrittenFiles: [] };
   const files = readdirSync21(dir).filter((f) => f.endsWith(".json"));
   const rewrittenFiles = [];
   for (const f of files) {
-    const p = join73(dir, f);
+    const p = join74(dir, f);
     let raw;
     try {
-      raw = readFileSync60(p, "utf8");
+      raw = readFileSync61(p, "utf8");
     } catch {
       continue;
     }
@@ -49463,7 +49911,7 @@ function redactRunsSweep(opts = {}) {
 function runRemSleep(opts = {}) {
   const ranAt = (opts.now ?? /* @__PURE__ */ new Date()).toISOString();
   const root = marketingRootIfExists();
-  if (!root || !existsSync82(root)) {
+  if (!root || !existsSync83(root)) {
     return {
       ranAt,
       marketingPresent: false,
@@ -49485,7 +49933,7 @@ function runRemSleep(opts = {}) {
     now: opts.now
   });
   const redaction = redactRunsSweep({ dryRun: opts.dryRun });
-  void mkdirSync35;
+  void mkdirSync36;
   return { ranAt, marketingPresent: true, runs, insights, learnings, redaction };
 }
 var SNAP_RE;
@@ -49582,9 +50030,9 @@ var init_git_guard = __esm({
 });
 
 // src/cli/commands/marketing/hooks.ts
-import { existsSync as existsSync83, readFileSync as readFileSync61, writeFileSync as writeFileSync41, chmodSync as chmodSync3, mkdirSync as mkdirSync36, statSync as statSync17 } from "fs";
+import { existsSync as existsSync84, readFileSync as readFileSync62, writeFileSync as writeFileSync42, chmodSync as chmodSync3, mkdirSync as mkdirSync37, statSync as statSync17 } from "fs";
 import { execFileSync as execFileSync6 } from "child_process";
-import { join as join74 } from "path";
+import { join as join75 } from "path";
 function findGitDir(cwd = process.cwd()) {
   try {
     const out = execFileSync6("git", ["rev-parse", "--git-dir"], {
@@ -49593,7 +50041,7 @@ function findGitDir(cwd = process.cwd()) {
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     if (!out) return null;
-    return out.startsWith("/") ? out : join74(cwd, out);
+    return out.startsWith("/") ? out : join75(cwd, out);
   } catch {
     return null;
   }
@@ -49624,11 +50072,11 @@ function registerMarketingHooks(parent) {
       error("Not inside a git repository (or `git` is not on PATH).");
       process.exit(1);
     }
-    const hooksDir = join74(gitDir, "hooks");
-    mkdirSync36(hooksDir, { recursive: true });
-    const target = join74(hooksDir, "pre-commit");
-    if (existsSync83(target)) {
-      const existing = readFileSync61(target, "utf-8");
+    const hooksDir = join75(gitDir, "hooks");
+    mkdirSync37(hooksDir, { recursive: true });
+    const target = join75(hooksDir, "pre-commit");
+    if (existsSync84(target)) {
+      const existing = readFileSync62(target, "utf-8");
       if (existing.includes(MANAGED_MARKER)) {
         info("pre-commit hook already managed by dreamcontext \u2014 refreshing.");
       } else if (!opts.force) {
@@ -49640,7 +50088,7 @@ function registerMarketingHooks(parent) {
         warn("Overwriting existing pre-commit hook (--force).");
       }
     }
-    writeFileSync41(target, HOOK_LAUNCHER, "utf-8");
+    writeFileSync42(target, HOOK_LAUNCHER, "utf-8");
     try {
       chmodSync3(target, 493);
     } catch {
@@ -49679,26 +50127,26 @@ exec dreamcontext mk hooks check-staged
 });
 
 // src/lib/marketing/council-personas.ts
-import { existsSync as existsSync84, readFileSync as readFileSync62, readdirSync as readdirSync22 } from "fs";
+import { existsSync as existsSync85, readFileSync as readFileSync63, readdirSync as readdirSync22 } from "fs";
 import { fileURLToPath as fileURLToPath9 } from "url";
-import { join as join75, dirname as dirname44 } from "path";
+import { join as join76, dirname as dirname45 } from "path";
 function findPersonasDir() {
   const candidates = [
     // dev:   src/lib/marketing/council-personas.ts → ../../../skill-packs/...
-    join75(__dirname_local, "..", "..", "..", PERSONA_SUBPATH),
+    join76(__dirname_local, "..", "..", "..", PERSONA_SUBPATH),
     // built: dist/index.js → ./skill-packs/...
-    join75(__dirname_local, PERSONA_SUBPATH),
+    join76(__dirname_local, PERSONA_SUBPATH),
     // tsup-bundled (deeper nesting if ever): ../skill-packs/...
-    join75(__dirname_local, "..", PERSONA_SUBPATH),
-    join75(__dirname_local, "..", "..", PERSONA_SUBPATH)
+    join76(__dirname_local, "..", PERSONA_SUBPATH),
+    join76(__dirname_local, "..", "..", PERSONA_SUBPATH)
   ];
   for (const candidate of candidates) {
-    if (existsSync84(candidate)) return candidate;
+    if (existsSync85(candidate)) return candidate;
   }
   return null;
 }
 function parsePersonaFile(filePath) {
-  const raw = readFileSync62(filePath, "utf-8");
+  const raw = readFileSync63(filePath, "utf-8");
   const parsed = (0, import_gray_matter5.default)(raw);
   const data = parsed.data;
   const slug = typeof data.slug === "string" ? data.slug.trim() : "";
@@ -49718,9 +50166,9 @@ function parsePersonaFile(filePath) {
 }
 function loadAllPersonas(personasDir) {
   const dir = personasDir ?? findPersonasDir();
-  if (!dir || !existsSync84(dir)) return [];
+  if (!dir || !existsSync85(dir)) return [];
   const files = readdirSync22(dir).filter((n) => n.endsWith(".md")).sort();
-  return files.map((name) => parsePersonaFile(join75(dir, name)));
+  return files.map((name) => parsePersonaFile(join76(dir, name)));
 }
 function selectPersonas(all, requested) {
   if (requested.length === 0) return [...all];
@@ -49739,23 +50187,23 @@ var init_council_personas = __esm({
     import_gray_matter5 = __toESM(require_gray_matter(), 1);
     __dirname_local = (() => {
       try {
-        return dirname44(fileURLToPath9(import.meta.url));
+        return dirname45(fileURLToPath9(import.meta.url));
       } catch {
         return process.cwd();
       }
     })();
     VALID_MODELS2 = /* @__PURE__ */ new Set(["opus", "sonnet", "haiku"]);
-    PERSONA_SUBPATH = join75("skill-packs", "meta-marketing", "council-personas");
+    PERSONA_SUBPATH = join76("skill-packs", "meta-marketing", "council-personas");
   }
 });
 
 // src/cli/commands/marketing/council.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { existsSync as existsSync85 } from "fs";
+import { existsSync as existsSync86 } from "fs";
 function resolveDreamcontextEntry() {
   const node = process.argv[0];
   const script = process.argv[1];
-  if (script && existsSync85(script)) {
+  if (script && existsSync86(script)) {
     return { node, script };
   }
   return { node, script: null };
@@ -49927,8 +50375,8 @@ var init_marketing = __esm({
 });
 
 // src/cli/commands/memory.ts
-import { existsSync as existsSync86, unlinkSync as unlinkSync4 } from "fs";
-import { join as join76, dirname as dirname45 } from "path";
+import { existsSync as existsSync87, unlinkSync as unlinkSync4 } from "fs";
+import { join as join77, dirname as dirname46 } from "path";
 function collectVault(value, previous) {
   return [...previous, value];
 }
@@ -49940,7 +50388,7 @@ function parseTypes(value) {
   return filtered.length > 0 ? filtered : void 0;
 }
 function recallFederated(contextRoot, query, topK, types, opts) {
-  const projectRoot = dirname45(contextRoot);
+  const projectRoot = dirname46(contextRoot);
   const { target: currentTarget } = currentVaultTarget(projectRoot);
   const byName = /* @__PURE__ */ new Map();
   const add = (t) => {
@@ -50093,7 +50541,7 @@ function registerMemoryCommand(program2) {
     const summary = opts.summary ?? (text.length > 200 ? text.slice(0, 197) + "..." : text);
     const references = opts.references ? opts.references.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
     const authors = opts.person ? opts.person.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
-    const changelogPath = join76(root, "core", "CHANGELOG.json");
+    const changelogPath = join77(root, "core", "CHANGELOG.json");
     const entry = {
       date: today(),
       type: opts.type ?? "note",
@@ -50111,8 +50559,8 @@ function registerMemoryCommand(program2) {
   memory.command("update").argument("<slug>", "Knowledge file slug (without .md)").option("-d, --description <desc>", "New description (replaces existing)").option("-t, --tags <tags>", "New tags (comma-separated, replaces existing)").option("-c, --content <content>", "New body content (replaces existing)").option("--append <text>", "Append text to body (preserves existing content)").option("--pin", "Set pinned: true").option("--unpin", "Set pinned: false").description("Update a knowledge file (frontmatter and/or body)").action(
     async (slug, opts) => {
       const root = ensureContextRoot();
-      const filePath = join76(root, "knowledge", `${slug}.md`);
-      if (!existsSync86(filePath)) {
+      const filePath = join77(root, "knowledge", `${slug}.md`);
+      if (!existsSync87(filePath)) {
         error(`Knowledge file not found: ${slug}.md`);
         return;
       }
@@ -50159,8 +50607,8 @@ ${opts.append}
   );
   memory.command("delete").argument("<slug>", "Knowledge file slug to delete (without .md)").option("-f, --force", "Skip confirmation prompt").description("Delete a knowledge file (irreversible; use git to recover)").action(async (slug, opts) => {
     const root = ensureContextRoot();
-    const filePath = join76(root, "knowledge", `${slug}.md`);
-    if (!existsSync86(filePath)) {
+    const filePath = join77(root, "knowledge", `${slug}.md`);
+    if (!existsSync87(filePath)) {
       error(`Knowledge file not found: ${slug}.md`);
       return;
     }
@@ -50268,13 +50716,13 @@ var init_memory = __esm({
 
 // src/cli/commands/upgrade.ts
 import { execFileSync as execFileSync8 } from "child_process";
-import { dirname as dirname46 } from "path";
+import { dirname as dirname47 } from "path";
 function defaultInstaller(args) {
   execFileSync8("npm", args, { stdio: "inherit" });
 }
 function projectRootForCache() {
   const contextDir = resolveContextRoot();
-  return contextDir ? dirname46(contextDir) : process.cwd();
+  return contextDir ? dirname47(contextDir) : process.cwd();
 }
 function defaultLiveLatest() {
   let latest = null;
@@ -50597,9 +51045,9 @@ var init_vaults3 = __esm({
 });
 
 // src/cli/commands/connections.ts
-import { dirname as dirname47 } from "path";
+import { dirname as dirname48 } from "path";
 function currentVaultName2(contextRoot) {
-  return currentVaultTarget(dirname47(contextRoot)).name;
+  return currentVaultTarget(dirname48(contextRoot)).name;
 }
 function registerConnectionsCommand(program2) {
   program2.command("connect <vault>").description("Connect this vault to a peer for federation (out|in|both)").option("-d, --direction <direction>", "Connection direction: out | in | both", "both").option("--topics <list>", "Comma-separated topic filter (default: all topics)").action((vault, opts) => {
@@ -50681,17 +51129,17 @@ var init_connections3 = __esm({
 });
 
 // src/lib/federation-ingest.ts
-import { existsSync as existsSync87, mkdirSync as mkdirSync37 } from "fs";
-import { join as join77 } from "path";
+import { existsSync as existsSync88, mkdirSync as mkdirSync38 } from "fs";
+import { join as join78 } from "path";
 function ingestEntry(contextRoot, entry) {
-  const knowledgeDir = join77(contextRoot, "knowledge");
-  mkdirSync37(knowledgeDir, { recursive: true });
+  const knowledgeDir = join78(contextRoot, "knowledge");
+  mkdirSync38(knowledgeDir, { recursive: true });
   const baseSlug = slugFromTitle(entry.title);
-  const canonicalPath = join77(knowledgeDir, `${baseSlug}.md`);
-  const collided = existsSync87(canonicalPath);
+  const canonicalPath = join78(knowledgeDir, `${baseSlug}.md`);
+  const collided = existsSync88(canonicalPath);
   const slug = collided ? `${baseSlug}--from-${sanitizeVault(entry.origin.vault)}` : baseSlug;
-  const targetPath = join77(knowledgeDir, `${slug}.md`);
-  if (!existsSync87(targetPath)) {
+  const targetPath = join78(knowledgeDir, `${slug}.md`);
+  if (!existsSync88(targetPath)) {
     writeFrontmatter(
       targetPath,
       {
@@ -50767,9 +51215,9 @@ var init_federation_ingest = __esm({
 });
 
 // src/cli/commands/federation.ts
-import { dirname as dirname48 } from "path";
+import { dirname as dirname49 } from "path";
 function currentVaultName3(contextRoot) {
-  return currentVaultTarget(dirname48(contextRoot)).name;
+  return currentVaultTarget(dirname49(contextRoot)).name;
 }
 function outboundConnections(contextRoot) {
   return listConnections(contextRoot).filter(
@@ -50982,12 +51430,12 @@ var init_people = __esm({
 });
 
 // src/cli/commands/config.ts
-import { dirname as dirname49 } from "path";
-import { existsSync as existsSync88, readFileSync as readFileSync64, writeFileSync as writeFileSync43 } from "fs";
-import { join as join78 } from "path";
+import { dirname as dirname50 } from "path";
+import { existsSync as existsSync89, readFileSync as readFileSync65, writeFileSync as writeFileSync44 } from "fs";
+import { join as join79 } from "path";
 function resolveProjectRoot() {
   const contextRoot = resolveContextRoot();
-  return contextRoot ? dirname49(contextRoot) : null;
+  return contextRoot ? dirname50(contextRoot) : null;
 }
 function requireProjectRoot() {
   const projectRoot = resolveProjectRoot();
@@ -51146,7 +51594,7 @@ function registerConfigCommand(program2) {
         const liveToken = resolveClickUpToken(projectRoot);
         let connected = false;
         if (liveToken) {
-          const contextRoot = join78(projectRoot, "_dream_context");
+          const contextRoot = join79(projectRoot, "_dream_context");
           const probe = createClickUpBackend(contextRoot, readSetupConfig(projectRoot));
           const test = await probe.testConnection();
           if (test.ok) {
@@ -51189,7 +51637,7 @@ function registerConfigCommand(program2) {
           cfgNow = readSetupConfig(projectRoot);
         }
         if (connected && cfgNow?.clickup?.listId) {
-          const contextRoot = join78(projectRoot, "_dream_context");
+          const contextRoot = join79(projectRoot, "_dream_context");
           const backend2 = createClickUpBackend(contextRoot, cfgNow);
           if (await esm_default4({ message: "Create the recommended custom fields on the list (urgency, summary, RICE, \u2026)?", default: true })) {
             const result = await backend2.provisionRemote();
@@ -51244,13 +51692,13 @@ function registerConfigCommand(program2) {
     const contextRoot = resolveContextRoot();
     let userMdSynced = false;
     if (contextRoot) {
-      const userMdPath = join78(contextRoot, "core", "1.user.md");
-      if (existsSync88(userMdPath)) {
+      const userMdPath = join79(contextRoot, "core", "1.user.md");
+      if (existsSync89(userMdPath)) {
         try {
-          const before = readFileSync64(userMdPath, "utf-8");
+          const before = readFileSync65(userMdPath, "utf-8");
           const after = ensurePeopleSection(before, roster);
           if (after !== before) {
-            writeFileSync43(userMdPath, after, "utf-8");
+            writeFileSync44(userMdPath, after, "utf-8");
             userMdSynced = true;
           }
         } catch (err) {
@@ -51294,7 +51742,7 @@ function registerConfigCommand(program2) {
   config.command("clickup-list <teamId> <spaceId> <listId>").description("Set the ClickUp team/space/list the tasks sync against").option("--migrate", "When changing lists: reset the sync ledger so the next sync recreates every local task in the NEW list").option("--keep", "When changing lists: keep existing task mappings (tasks were moved in ClickUp itself)").action(async (teamId, spaceId, listId, opts) => {
     const projectRoot = requireProjectRoot();
     if (!projectRoot) return;
-    const contextRoot = join78(projectRoot, "_dream_context");
+    const contextRoot = join79(projectRoot, "_dream_context");
     const existing = readSetupConfig(projectRoot)?.clickup ?? {};
     const ledger = new SyncLedger(contextRoot);
     const changingList = !!existing.listId && existing.listId !== listId && ledger.readMap().length > 0;
@@ -51335,8 +51783,8 @@ function registerConfigCommand(program2) {
     if (!value) {
       if (!process.stdin.isTTY) {
         try {
-          const { readFileSync: readFileSync65 } = await import("fs");
-          value = readFileSync65(0, "utf-8").trim();
+          const { readFileSync: readFileSync66 } = await import("fs");
+          value = readFileSync66(0, "utf-8").trim();
         } catch {
           value = "";
         }
@@ -51695,12 +52143,12 @@ var init_feedback2 = __esm({
 });
 
 // src/cli/commands/migrations.ts
-import { dirname as dirname50 } from "path";
+import { dirname as dirname51 } from "path";
 function registerMigrationsCommand(program2) {
   const migrations = program2.command("migrations").description("Inspect and record brain structure migrations");
   migrations.command("pending").description("Print pending agent task instructions for any unfinished migrations").action(() => {
     const root = ensureContextRoot();
-    const projectRoot = dirname50(root);
+    const projectRoot = dirname51(root);
     const config = readSetupConfig(projectRoot);
     const fromVersion = config?.setupVersion ?? "0.0.0";
     const toVersion = dreamcontextVersion();