mover-os 4.7.7 → 4.7.9

package/src/dashboard/lib/approval-registry.js

@@ -0,0 +1,170 @@
+"use strict";
+
+/**
+ * approval-registry.js — packet #2 rider: dashboard-owned Engine-write
+ * approval (OWNER-DECISIONS.md, "Packet #2 VERIFICATION VERDICT").
+ *
+ * WHY: Codex/Gemini PreToolUse "ask" on a core Engine file currently converts
+ * to a hard deny in mover-hook-adapter.js (isPermissionDecision branch),
+ * because neither agent supports an interactive terminal prompt. The owner's
+ * rider: for a DASHBOARD-launched run, Mover Studio owns the UI, so the
+ * daemon can hold a real pending approval and let the user answer it from
+ * the browser instead of always denying.
+ *
+ * This registry is the server-held half of that flow: create a pending
+ * approval (tokened POST from the hook adapter), poll its status (tokened
+ * GET, the hook's poll loop), list pending ones (GET, dashboard UI), and
+ * resolve one (tokened POST, dashboard UI click). In-memory only, mirrors
+ * RunRegistry / AgentSessionManager: a daemon restart clears everything,
+ * which is correct — a pending approval only makes sense against a live run.
+ *
+ * TTL expiry resolves as DENY (fail closed), same contract as the hook
+ * adapter's existing unconditional deny it is meant to soften, never worsen.
+ *
+ * NOTE (2026-07-11): nothing currently calls request() in production. The
+ * hook-adapter wiring that would create these (mover-hook-adapter.js's
+ * ask->deny conversion) was evaluated and NOT changed — the Codex/Gemini
+ * host hook timeout (5s, ~/.codex/hooks.json PreToolUse Edit|Write|apply_patch
+ * / install.js generateGeminiHooks BeforeTool write_file|replace) leaves no
+ * safety-margin room for a human-reviewable wait; see dev/plan.md
+ * T-PACKET2-RIDER-1 for the full evidence trail. This module is real,
+ * tested, standalone infrastructure ready for that follow-up.
+ */
+
+const crypto = require("crypto");
+
+const DEFAULTS = {
+  ttlMs: 60 * 1000,           // ask (owner rider): TTL expiry resolves as deny
+  maxPending: 50,             // bound memory; evict oldest non-pending first
+  sweepMs: 30 * 1000,         // periodic cleanup cadence
+  graceMs: 5 * 60 * 1000,     // keep a decided/expired record this long so a
+                               // late poll still reads the real outcome
+};
+
+const MAX_LEN = { agent: 32, file: 1024, tool: 64, excerpt: 4000 };
+
+function capString(v, max, field) {
+  const s = String(v == null ? "" : v);
+  if (!s.trim()) throw new Error(`${field} is required`);
+  return s.length > max ? s.slice(0, max) : s;
+}
+
+class ApprovalRegistry {
+  constructor(opts = {}) {
+    this.opt = { ...DEFAULTS, ...opts };
+    this.pending = new Map(); // id -> record
+    this._sweep = setInterval(() => this._evict(), this.opt.sweepMs);
+    if (this._sweep.unref) this._sweep.unref();
+  }
+
+  /**
+   * Create a pending approval. spec: { agent, file, tool, excerpt }.
+   * Returns the record (id, expiresAt, status:"pending").
+   */
+  request(spec) {
+    const s = spec || {};
+    const agent = capString(s.agent, MAX_LEN.agent, "agent");
+    const file = capString(s.file, MAX_LEN.file, "file");
+    const tool = String(s.tool == null ? "" : s.tool).slice(0, MAX_LEN.tool);
+    const excerpt = String(s.excerpt == null ? "" : s.excerpt).slice(0, MAX_LEN.excerpt);
+
+    this._trimCount();
+
+    const id = crypto.randomBytes(16).toString("hex");
+    const createdAt = Date.now();
+    const rec = {
+      id,
+      agent,
+      file,
+      tool,
+      excerpt,
+      createdAt,
+      expiresAt: createdAt + this.opt.ttlMs,
+      status: "pending",
+      decidedAt: null,
+      decidedReason: null,
+    };
+    this.pending.set(id, rec);
+    return rec;
+  }
+
+  /**
+   * Look up a record and resolve TTL expiry lazily (a poll after the TTL
+   * elapsed sees "denied", even if no sweep has run yet). Returns null if
+   * the id was never issued or has aged out of the grace window.
+   */
+  get(id) {
+    const rec = this.pending.get(String(id || ""));
+    if (!rec) return null;
+    if (rec.status === "pending" && Date.now() > rec.expiresAt) {
+      rec.status = "denied";
+      rec.decidedAt = Date.now();
+      rec.decidedReason = "timeout";
+    }
+    return rec;
+  }
+
+  /** All currently PENDING (not yet decided, not yet expired) approvals. */
+  listPending() {
+    const out = [];
+    for (const id of this.pending.keys()) {
+      const rec = this.get(id); // applies TTL-expiry lazily
+      if (rec && rec.status === "pending") out.push({ ...rec });
+    }
+    return out;
+  }
+
+  /**
+   * Resolve a pending approval. Returns { ok, code, status, error }.
+   * - unknown/aged-out id -> { ok:false, code:404 }
+   * - already decided (approved/denied/timeout) -> { ok:false, code:409 }
+   * - success -> { ok:true, status: "approved"|"denied" }
+   */
+  respond(id, approve) {
+    const rec = this.get(id);
+    if (!rec) return { ok: false, code: 404, error: "no such approval" };
+    if (rec.status !== "pending") {
+      return { ok: false, code: 409, error: `already ${rec.status}` };
+    }
+    rec.status = approve === true ? "approved" : "denied";
+    rec.decidedAt = Date.now();
+    rec.decidedReason = "response";
+    return { ok: true, status: rec.status };
+  }
+
+  /** Cap the number of retained records: drop the oldest DECIDED ones first,
+   *  never a live pending one, so a burst of writes can't push out a request
+   *  a human hasn't answered yet. */
+  _trimCount() {
+    if (this.pending.size < this.opt.maxPending) return;
+    const decided = [...this.pending.values()]
+      .filter((r) => r.status !== "pending")
+      .sort((a, b) => a.createdAt - b.createdAt);
+    while (this.pending.size >= this.opt.maxPending && decided.length) {
+      this.pending.delete(decided.shift().id);
+    }
+    // Degenerate case: still at cap and every record is genuinely pending
+    // (a flood). Drop the oldest pending rather than grow unbounded; it
+    // will read as a denial to whichever caller is waiting on it, which is
+    // the fail-closed outcome anyway.
+    if (this.pending.size >= this.opt.maxPending) {
+      const oldest = [...this.pending.values()].sort((a, b) => a.createdAt - b.createdAt)[0];
+      if (oldest) this.pending.delete(oldest.id);
+    }
+  }
+
+  _evict() {
+    const now = Date.now();
+    for (const rec of [...this.pending.values()]) {
+      const decidedAt = rec.status === "pending" ? null : (rec.decidedAt || rec.expiresAt);
+      if (decidedAt && now - decidedAt > this.opt.graceMs) this.pending.delete(rec.id);
+    }
+  }
+
+  /** Test/shutdown hygiene: stop the sweep timer. */
+  stop() {
+    if (this._sweep) { clearInterval(this._sweep); this._sweep = null; }
+  }
+}
+
+module.exports = { ApprovalRegistry, DEFAULTS };

package/src/dashboard/lib/auto-learnings-parser.js

@@ -0,0 +1,183 @@
+"use strict";
+
+const { autoLearningsPath, safeRead, safeStat } = require("./paths");
+
+// Parse Auto_Learnings.md — splits on `## (PATTERN|CORRECTION|BELIEF SHIFT|REFLEXION): Name` headers.
+// REFLEXION (C3) is the AI's own error→recovery post-mortem, distinct from a user CORRECTION.
+// Returns {available, entries: [...], stats: {patterns, corrections, beliefShifts, reflexions, byConfidence}}
+
+function parseAutoLearnings(vault) {
+  const filePath = autoLearningsPath(vault);
+  const text = safeRead(filePath);
+  const stat = safeStat(filePath);
+  if (!text) return { available: false, error: "Auto_Learnings.md not found", entries: [], stats: emptyStats() };
+
+  const lines = text.split("\n");
+  const entries = [];
+  let current = null;
+  let buf = [];
+  // Track current section context so we can tag entries with polarity
+  // when authored under `## Anti-Patterns` / `## Positive Patterns`
+  // sectional headers. Defaults to null (use heuristic).
+  let sectionPolarity = null;
+
+  for (const line of lines) {
+    // Section-context header (Anti-Patterns / Positive Patterns)
+    const sec = line.match(/^##\s+(Anti-Patterns?|Positive Patterns?|Strengths?|Rituals?)\s*$/i);
+    if (sec) {
+      if (current) {
+        current.body = buf.join("\n");
+        entries.push(finalizeEntry(current, sectionPolarity));
+        current = null;
+        buf = [];
+      }
+      const tok = sec[1].toLowerCase();
+      sectionPolarity = /anti|leak/.test(tok) ? "anti"
+        : /positive|strength/.test(tok) ? "lift"
+        : /ritual/.test(tok) ? "ritual"
+        : null;
+      continue;
+    }
+
+    const m = line.match(/^##\s+(PATTERN|CORRECTION|BELIEF SHIFT|REFLEXION):\s*(.+?)\s*$/i);
+    if (m) {
+      if (current) {
+        current.body = buf.join("\n");
+        entries.push(finalizeEntry(current, sectionPolarity));
+      }
+      current = { type: m[1].toUpperCase(), name: m[2].trim() };
+      buf = [];
+    } else if (current) {
+      buf.push(line);
+    }
+  }
+  if (current) {
+    current.body = buf.join("\n");
+    entries.push(finalizeEntry(current, sectionPolarity));
+  }
+
+  const stats = computeStats(entries);
+
+  return {
+    available: true,
+    filePath,
+    lastUpdated: stat ? stat.mtime : null,
+    entries,
+    stats,
+    activePatternsConf3Plus: entries.filter(e =>
+      e.type === "PATTERN" &&
+      typeof e.confidence === "number" &&
+      e.confidence >= 3 &&
+      !["RESOLVED", "AUTOMATIC"].includes((e.status || "").toUpperCase())
+    ),
+    growingPatterns: entries.filter(e =>
+      e.type === "PATTERN" && (e.status || "").toUpperCase() === "GROWING"
+    ),
+    escalatedPatterns: entries.filter(e =>
+      e.type === "PATTERN" && (e.status || "").toUpperCase() === "ESCALATED"
+    ),
+    recentBeliefShifts: entries.filter(e => e.type === "BELIEF SHIFT").slice(0, 5),
+    recentCorrections: entries.filter(e => e.type === "CORRECTION").slice(-10).reverse(),
+    recentReflexions: entries.filter(e => e.type === "REFLEXION").slice(-10).reverse()
+  };
+}
+
+function finalizeEntry(entry, sectionPolarity) {
+  const body = entry.body || "";
+  const fields = parseBoldFields(body);
+  const evidence = parseEvidence(body);
+
+  const severity = (fields.severity || "").toUpperCase() || null;
+  const status = (fields.status || "").toUpperCase().replace(/\s+/g, "_") || null;
+  // Polarity: explicit section context > severity heuristic
+  let polarity = sectionPolarity;
+  if (!polarity) {
+    if (severity && /POSITIVE/.test(severity)) polarity = "lift";
+    else if (severity === "HIGH" || severity === "CRIT" || severity === "CRITICAL") polarity = "anti";
+    else if (status === "GROWING" || status === "BAKED_INTO_STRATEGY_MD") polarity = "watching";
+    else polarity = "neutral";
+  }
+  // 5-type taxonomy mapping (LEAK / DRIFT / STRENGTH / RECOVERY / RITUAL)
+  let category = "watching";
+  if (polarity === "anti") {
+    if (/distribution|gap|spree|avoidance|procrastinat|phantom/i.test(entry.name)) category = "drift";
+    else category = "leak";
+  } else if (polarity === "lift" || polarity === "strength") category = "strength";
+  else if (polarity === "ritual") category = "ritual";
+  else if (status === "GROWING") category = "recovery";
+
+  return {
+    type: entry.type,
+    name: entry.name,
+    body,
+    fields,
+    evidence,
+    confidence: parseInt(fields.confidence || "0", 10) || null,
+    status,
+    severity,
+    polarity,
+    category,
+    domain: fields.domain || null,
+    type_subtype: fields.type || null,
+    firstDetected: fields.first_detected || null,
+    lastUpdated: fields.last_updated || null,
+    lastValidated: fields.last_validated || null,
+    confrontationCount: parseInt(fields.confrontation_count || "0", 10) || null,
+    trigger: fields.trigger || null,
+    counterAction: fields.counter_action || null,
+    suspectedVariable: fields.suspected_variable || null,
+    hypothesis: fields.hypothesis || null,
+    resistanceForm: fields.resistance_form || null,
+    beliefTier: fields.belief_tier || null,
+    previousBelief: fields.previous_belief || null,
+    newBelief: fields.new_belief || null,
+    error: fields.error || null,
+    fix: fields.fix || null
+  };
+}
+
+function parseBoldFields(body) {
+  const fields = {};
+  const re = /\*\*([^*]+):\*\*\s*([^\n]+)/g;
+  let m;
+  while ((m = re.exec(body)) !== null) {
+    const k = m[1].trim().toLowerCase().replace(/[^a-z0-9_]+/g, "_").replace(/^_|_$/g, "");
+    fields[k] = m[2].trim();
+  }
+  return fields;
+}
+
+function parseEvidence(body) {
+  const evidence = [];
+  const lines = body.split("\n");
+  let inEvidence = false;
+  for (const line of lines) {
+    if (/^###\s+Evidence/i.test(line)) { inEvidence = true; continue; }
+    if (inEvidence && /^###\s+/.test(line)) inEvidence = false;
+    if (inEvidence) {
+      const m = line.match(/^[-*]\s+(.+)$/);
+      if (m) evidence.push(m[1].trim());
+    }
+  }
+  return evidence;
+}
+
+function emptyStats() {
+  return { total: 0, patterns: 0, corrections: 0, beliefShifts: 0, reflexions: 0, byConfidence: { 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 }, byStatus: {} };
+}
+
+function computeStats(entries) {
+  const stats = emptyStats();
+  stats.total = entries.length;
+  for (const e of entries) {
+    if (e.type === "PATTERN") stats.patterns++;
+    else if (e.type === "CORRECTION") stats.corrections++;
+    else if (e.type === "BELIEF SHIFT") stats.beliefShifts++;
+    else if (e.type === "REFLEXION") stats.reflexions++;
+    if (e.confidence && e.confidence >= 1 && e.confidence <= 5) stats.byConfidence[e.confidence]++;
+    if (e.status) stats.byStatus[e.status] = (stats.byStatus[e.status] || 0) + 1;
+  }
+  return stats;
+}
+
+module.exports = { parseAutoLearnings };

package/src/dashboard/lib/cli-usage-parser.js

@@ -0,0 +1,92 @@
+"use strict";
+
+const { safeReadJson, moverConfigPath } = require("./paths");
+
+// Parse moveros CLI usage from ~/.mover/config.json cfg.cli_usage map.
+// Cross-references with the 17-entry CLI_COMMANDS registry the server
+// exposes at /api/cli/index so the dashboard can show:
+//   - count: how many times this command has been run
+//   - lastRun: ISO timestamp of last invocation
+//   - ageDays: days since lastRun
+
+// Canonical command list from the moveros CLI install.js. Mirror of
+// /api/cli/index — kept in sync via the install package's CLI_COMMANDS.
+const COMMANDS = [
+  { name: "install",   description: "Fresh install wizard" },
+  { name: "update",    description: "Comprehensive update: agents, rules, skills" },
+  { name: "uninstall", description: "Remove Mover OS from vault and agents" },
+  { name: "doctor",    description: "Health check across all installed agents" },
+  { name: "pulse",     description: "Terminal dashboard: energy, tasks, streaks" },
+  { name: "capture",   description: "Quick capture: tasks, links, ideas" },
+  { name: "who",       description: "Entity memory lookup" },
+  { name: "diff",      description: "Engine file evolution viewer" },
+  { name: "sync",      description: "Cross-agent synchronization" },
+  { name: "replay",    description: "Session replay from Daily Notes" },
+  { name: "context",   description: "Debug what each agent sees" },
+  { name: "settings",  description: "View/edit config" },
+  { name: "backup",    description: "Manual backup wizard" },
+  { name: "restore",   description: "Restore from backup" },
+  { name: "prayer",    description: "Manage prayer times" },
+  { name: "status",    description: "Full system state (vault, agents, version)" },
+  { name: "help",      description: "Interactive guide to Mover OS" },
+];
+
+function parseCliUsage() {
+  // False-zero discipline (T261): distinguish "config absent / never tracked"
+  // from "tracked, genuinely zero runs". A present cfg.cli_usage map — even
+  // all-zero — is real telemetry and stays available:true. Only true ABSENCE
+  // (no config file, or no cli_usage key at all) flips available:false so the
+  // consumer renders "—"/"calibrating" instead of a fabricated 0-usage table.
+  const cfg = safeReadJson(moverConfigPath());
+  if (cfg == null) {
+    return {
+      available: false,
+      unavailableReason: "file_missing",
+      commands: [],
+      totalUsage: null,
+      everUsedCount: null,
+    };
+  }
+  if (cfg.cli_usage == null || typeof cfg.cli_usage !== "object") {
+    return {
+      available: false,
+      unavailableReason: "no_data",
+      commands: [],
+      totalUsage: null,
+      everUsedCount: null,
+    };
+  }
+  const usage = cfg.cli_usage;
+
+  const commands = COMMANDS.map(c => {
+    const u = usage[c.name] || {};
+    const count = typeof u.count === "number" ? u.count : 0;
+    const last = u.last || null;
+    let ageDays = null;
+    if (last) {
+      try {
+        const t = new Date(last).getTime();
+        if (!isNaN(t)) ageDays = Math.floor((Date.now() - t) / 86400000);
+      } catch (_) { /* skip */ }
+    }
+    return {
+      name: c.name,
+      description: c.description,
+      count,
+      lastRun: last,
+      ageDays,
+    };
+  });
+
+  const totalUsage = commands.reduce((sum, c) => sum + c.count, 0);
+  const everUsed = commands.filter(c => c.count > 0).length;
+
+  return {
+    available: true,
+    commands,
+    totalUsage,
+    everUsedCount: everUsed,
+  };
+}
+
+module.exports = { parseCliUsage };

package/src/dashboard/lib/config-parser.js

@@ -0,0 +1,109 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+// config-parser.js — Read/write ~/.mover/config.json. Used by Settings mode +
+// agent-detector (preferredAgent) + first-run UX (vaultPath resolution).
+
+const CONFIG_PATH = path.join(os.homedir(), ".mover", "config.json");
+
+const DEFAULTS = Object.freeze({
+  vaultPath: null,
+  preferredAgent: null,
+  // Onboarding basic-info (captured on first run, editable in Configure):
+  userName: null,                                  // what to call the user
+  vaultName: null,                                 // friendly label for their vault/system
+  osName: null,                                    // dashboard + desktop-shortcut display name (shortcut.js reads os_name/osName)
+  lens: "everyday",                                // worldview "lingo": everyday | founder | muslim | secular | custom
+  lensCustom: { bet: "", seal: "", receipts: "" }, // the custom-lens term overrides
+  reviewDay: "Sunday",
+  eveningZoneStart: 17,
+  midnightCutoff: 5,
+  deepWorkHours: [9, 12],
+  sleepTarget: 7,
+  frictionSensitivity: "normal",
+  // #112: per-provider run tuning. null model/effort = the provider's own
+  // default (flag omitted). These are "what the Run picker starts on", not a
+  // hidden default — the picker writes back the user's last choice.
+  providerPrefs: {
+    "claude-code": { model: null, effort: null },
+    codex: { model: null, effort: null },
+    gemini: { model: null, approvalMode: "yolo" },
+  },
+  redaction: {
+    names: true,
+    faith: true,
+    weight: true,
+    money: true,
+    projectNames: true,
+    exactDates: false,
+    fileNames: true,
+  },
+  studio: {
+    density: "comfortable",
+    mono: false,
+    accent: "#d97a3c",
+    showAgentsInTopStrip: true,
+    autoOpenBrowser: true,
+  }
+});
+
+// two-level merge: per-provider objects merge key-by-key so a stored
+// { codex: { effort } } keeps the default gemini approvalMode intact.
+function mergeProviderPrefs(base, raw) {
+  const out = {};
+  for (const k of Object.keys(base)) out[k] = { ...base[k] };
+  for (const k of Object.keys(raw || {})) {
+    const next = raw[k];
+    out[k] = next && typeof next === "object" ? { ...(out[k] || {}), ...next } : next;
+  }
+  return out;
+}
+
+function read() {
+  try {
+    if (!fs.existsSync(CONFIG_PATH)) return { ...DEFAULTS, exists: false, path: CONFIG_PATH };
+    const text = fs.readFileSync(CONFIG_PATH, "utf8");
+    const raw = JSON.parse(text);
+    return {
+      ...DEFAULTS,
+      ...raw,
+      // Deep-merge for nested objects
+      redaction: { ...DEFAULTS.redaction, ...(raw.redaction || {}) },
+      studio: { ...DEFAULTS.studio, ...(raw.studio || {}) },
+      lensCustom: { ...DEFAULTS.lensCustom, ...(raw.lensCustom || {}) },
+      providerPrefs: mergeProviderPrefs(DEFAULTS.providerPrefs, raw.providerPrefs),
+      exists: true,
+      path: CONFIG_PATH,
+    };
+  } catch (e) {
+    return { ...DEFAULTS, exists: false, path: CONFIG_PATH, parseError: e.message };
+  }
+}
+
+function write(updates) {
+  // Merge with existing — never overwrite full file
+  const current = read();
+  delete current.exists;
+  delete current.path;
+  delete current.parseError;
+  const next = {
+    ...current,
+    ...updates,
+    redaction: { ...current.redaction, ...(updates.redaction || {}) },
+    studio: { ...current.studio, ...(updates.studio || {}) },
+    lensCustom: { ...current.lensCustom, ...(updates.lensCustom || {}) },
+  };
+  try {
+    const dir = path.dirname(CONFIG_PATH);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(next, null, 2) + "\n", "utf8");
+    return { ok: true, written: next };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+module.exports = { read, write, DEFAULTS, CONFIG_PATH };

package/src/dashboard/lib/connect-recommender.js

@@ -0,0 +1,131 @@
+"use strict";
+
+/**
+ * connect-recommender.js — from a setup-interview profile, build a personalized,
+ * domain-grouped "what to feed/connect me" plan. This is the fix for the cold-start gap
+ * ("if you don't feed it your day-to-day data it takes a while to pick up"): on day one we
+ * tell the user EXACTLY what to feed Mover OS, grouped by domain, in their own context —
+ * instead of a generic "upload your notes."
+ *
+ * Deterministic + zero-dep (mirrors skill-recommender.js). HONESTY CONTRACT: a source is
+ * `status:'ready'` ONLY if we can act on it right now — i.e. a file UPLOAD, wired to the real
+ * /api/session/ingest. Live OAuth connectors we have NOT built (Slack/Drive/calendar) are
+ * `status:'planned'` — an honest recommendation, never a fake "Connect" button. There is always
+ * ≥1 ready action so the user can do something real immediately.
+ *
+ * @param {object} profile  free-text setup answers ({work, tools, vitality, faith, goals, ...})
+ * @returns {{ diagnosis: string,
+ *             groups: Array<{ key:string, label:string,
+ *               sources: Array<{ id, label, why, action:'upload'|'connect', status:'ready'|'planned' }> }> }}
+ */
+
+// action 'upload' → we can ingest a file today (status ready). 'connect' → live OAuth we have
+// NOT built (status planned). `universal:true` is always offered (the baseline cold-start fix).
+const WORK_SOURCES = [
+  { id: "notes-docs", action: "upload", universal: true,
+    label: "Upload your key docs & notes",
+    why: "the docs, notes and trackers you already have, so Mover reads them instead of asking you to re-explain." },
+  { id: "clients-leads", action: "upload",
+    signals: ["client", "clients", "lead", "leads", "sales", "crm", "customer", "customers", "deal", "pipeline", "prospect"],
+    label: "Upload your leads / client list",
+    why: "your pipeline, so Mover tracks who's waiting on what." },
+  { id: "whatsapp", action: "upload", signals: ["whatsapp"],
+    label: "Upload a WhatsApp export",
+    why: "export a key chat. Mover pulls the decisions and commitments out of it." },
+  { id: "slack", action: "connect", signals: ["slack", "team", "teammate", "coworker", "co-worker", "channel"],
+    label: "Connect Slack",
+    why: "your team's back-and-forth, so Mover sees what's actually in flight." },
+  { id: "gdrive", action: "connect", signals: ["drive", "google doc", "gdoc", "docs", "document", "sheet", "spreadsheet"],
+    label: "Connect Google Drive",
+    why: "your working docs in one place, instead of scattered." },
+  { id: "calendar", action: "connect", signals: ["calendar", "meeting", "meetings", "schedule", "gcal", "appointment"],
+    label: "Connect your calendar",
+    why: "so /plan-tomorrow plans around your real day, not a blank one." },
+];
+
+const VITALITY_SOURCES = [
+  { id: "health-export", action: "upload",
+    signals: ["gym", "fitness", "sleep", "health", "fitbit", "whoop", "oura", "workout", "training", "run", "running", "diet", "calorie", "calories", "steps", "exercise"],
+    label: "Upload a health export",
+    why: "your sleep/training data, so the battery and floors are real, not guessed." },
+];
+
+const FAITH_SOURCES = [
+  { id: "faith-notes", action: "upload",
+    signals: ["faith", "prayer", "pray", "quran", "qur'an", "salah", "salat", "spiritual", "deen", "ibadah", "worship", "scripture", "church", "mosque", "masjid"],
+    label: "Add your practice / reflection notes",
+    why: "your reflections, so the faith domain isn't a placeholder." },
+];
+
+const statusFor = (action) => (action === "upload" ? "ready" : "planned");
+
+function profileBlob(profile) {
+  const parts = [];
+  const walk = (v) => {
+    if (v == null) return;
+    if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+      parts.push(String(v));
+    } else if (Array.isArray(v)) {
+      v.forEach(walk);
+    } else if (typeof v === "object") {
+      Object.values(v).forEach(walk);
+    }
+  };
+  for (const v of Object.values(profile || {})) {
+    walk(v);
+  }
+  return parts.join(" ").toLowerCase();
+}
+
+const matches = (text, signals) => (signals || []).some((s) => text.includes(s));
+
+function pickSources(catalogue, text, cap) {
+  const out = [];
+  for (const src of catalogue) {
+    if (src.universal || matches(text, src.signals)) {
+      out.push({ id: src.id, label: src.label, why: src.why, action: src.action, status: statusFor(src.action) });
+    }
+    if (out.length >= cap) break;
+  }
+  return out;
+}
+
+function diagnose(profile) {
+  let work = String((profile && profile.work) || "").replace(/```[\s\S]*?```/g, "").trim();
+  // Strip a first-person lead-in ("I run …", "I'm building …", "my …") so the line reads
+  // cleanly after "You're running …" instead of echoing "You're running I run a marketing agency."
+  work = work.replace(
+    /^(i['’]?m\s+building\s+|i\s+am\s+building\s+|i['’]?m\s+running\s+|i\s+am\s+running\s+|i\s+run\s+|i\s+build\s+|i\s+do\s+|i\s+lead\s+|i\s+manage\s+|i\s+operate\s+|i\s+own\s+|i\s+work\s+on\s+|i['’]?m\s+a\s+|i\s+am\s+a\s+|i['’]?m\s+|i\s+am\s+|my\s+|we\s+|currently\s+)/i,
+    ""
+  ).trim();
+  if (work) {
+    const words = work.split(/\s+/);
+    const summary = words.slice(0, 14).join(" ") + (words.length > 14 ? "…" : "");
+    return `You're running ${summary}. Mover OS is sharpest once it can see your real work. ` +
+      `here's what to feed it first, so day one isn't a blank slate.`;
+  }
+  return "Mover OS gets sharper the more of your real work it can see. " +
+    "Here's what to feed it first so day one isn't a blank slate.";
+}
+
+function connectPlan(profile = {}) {
+  const text = profileBlob(profile);
+  const groups = [{ key: "work", label: "Work", sources: pickSources(WORK_SOURCES, text, 6) }];
+
+  const vitality = pickSources(VITALITY_SOURCES, text, 3);
+  if (vitality.length) groups.push({ key: "vitality", label: "Vitality", sources: vitality });
+
+  const faith = pickSources(FAITH_SOURCES, text, 3);
+  if (faith.length) groups.push({ key: "faith", label: "Faith", sources: faith });
+
+  // Total cap — overwhelm is the enemy. Trim from the LAST group inward; never drop a group's
+  // first source (Work's first is the universal upload, the one always-real action).
+  let total = groups.reduce((n, g) => n + g.sources.length, 0);
+  for (let i = groups.length - 1; i >= 0 && total > 8; i--) {
+    while (groups[i].sources.length > 1 && total > 8) { groups[i].sources.pop(); total--; }
+  }
+
+  return { diagnosis: diagnose(profile), groups };
+}
+
+module.exports = { connectPlan, WORK_SOURCES, VITALITY_SOURCES, FAITH_SOURCES };