mover-os 4.7.6 → 4.7.8

package/src/dashboard/lib/suggested-now.js

@@ -0,0 +1,254 @@
+"use strict";
+
+// Pure scoring engine. Ports the workflow-router proactive triggers to JS.
+// Input: { now, ac, manifest, daily, engineHealth, strategy, projects }
+// Output: Array<{ workflow, reason, score, urgency, signal, time }> sorted by score desc, top N.
+
+const SIGNAL_TABLE = [
+  // Each entry returns null OR { workflow, reason, score, urgency }
+  function staleACRed({ now, ac }) {
+    if (!ac || !ac.lastUpdated) return null;
+    const days = ageDays(now, ac.lastUpdated);
+    if (days >= 7) return { workflow: "/reboot", reason: `Active_Context.md hasn't been updated in ${days} days. Recovery needed.`, score: 100, urgency: "RED" };
+    return null;
+  },
+  function staleACYellow({ now, ac }) {
+    if (!ac || !ac.lastUpdated) return null;
+    const days = ageDays(now, ac.lastUpdated);
+    if (days >= 3 && days < 7) return { workflow: "/log", reason: `Active_Context.md is ${days} days stale. Capture session state.`, score: 70, urgency: "YELLOW" };
+    return null;
+  },
+  function noDailyNoteEarly({ now, daily }) {
+    if (!daily) return null;
+    const hour = now.getHours();
+    if (hour < 12 && daily.today && !daily.today.exists) {
+      return { workflow: "/plan-tomorrow", reason: `It's ${formatTime(now)} and you don't have a Daily Note yet. Set today's plan.`, score: 95, urgency: "AMBER" };
+    }
+    return null;
+  },
+  function lateAfternoonNoLog({ now, ac }) {
+    if (!ac) return null;
+    const hour = now.getHours();
+    if (hour < 17 || hour > 21) return null;
+    const lastLog = ac.workflowState && ac.workflowState.log_last_run;
+    if (!lastLog) return { workflow: "/log", reason: `It's ${formatTime(now)} and no /log run today. Capture session before context drifts.`, score: 85, urgency: "AMBER" };
+    if (!isSameDay(parseDate(lastLog), now)) {
+      return { workflow: "/log", reason: `It's ${formatTime(now)} and /log hasn't run today. Capture before context drifts.`, score: 85, urgency: "AMBER" };
+    }
+    return null;
+  },
+  function eveningNoAnalyseDay({ now, ac }) {
+    if (!ac) return null;
+    const hour = now.getHours();
+    if (hour < 21) return null;
+    const lastAd = ac.workflowState && ac.workflowState.analyse_day_last_run;
+    if (!lastAd || !isSameDay(parseDate(lastAd), now)) {
+      return { workflow: "/analyse-day", reason: `It's past ${formatTime(now)}. Brutal day audit before sleep.`, score: 90, urgency: "AMBER" };
+    }
+    return null;
+  },
+  function strategyStaleYellow({ now, engineHealth }) {
+    if (!engineHealth) return null;
+    const item = engineHealth.items && engineHealth.items.find(i => i.file === "Strategy");
+    if (!item || !item.ageDays) return null;
+    if (item.ageDays >= 14 && item.ageDays < 60) {
+      return { workflow: "/pivot-strategy", reason: `Strategy.md is ${item.ageDays} days old. Hypothesis may be drifting from reality.`, score: 60, urgency: "YELLOW" };
+    }
+    return null;
+  },
+  function strategyStaleRed({ now, engineHealth }) {
+    if (!engineHealth) return null;
+    const item = engineHealth.items && engineHealth.items.find(i => i.file === "Strategy");
+    if (!item || !item.ageDays) return null;
+    if (item.ageDays >= 60) {
+      return { workflow: "/pivot-strategy", reason: `Strategy.md is ${item.ageDays} days stale. Workflows will block, pivot or confirm now.`, score: 100, urgency: "RED" };
+    }
+    return null;
+  },
+  function reviewDay({ now, ac, engineHealth }) {
+    const reviewDay = (ac && ac.workflowState && ac.workflowState.review_week_day) || "Sunday";
+    const dayName = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"][now.getDay()];
+    if (dayName !== reviewDay) return null;
+    const lastWr = ac.workflowState && ac.workflowState.weekly_review_last_run;
+    if (!lastWr) return { workflow: "/review-week", reason: `It's ${dayName}. Weekly review hasn't run yet.`, score: 80, urgency: "AMBER" };
+    const lastDt = parseDate(lastWr);
+    if (lastDt && (now.getTime() - lastDt.getTime()) > 3 * 86400000) {
+      return { workflow: "/review-week", reason: `It's ${dayName} and the last weekly review was ${ageDays(now, lastDt)}d ago.`, score: 80, urgency: "AMBER" };
+    }
+    return null;
+  },
+  function zombieTask({ manifest }) {
+    if (!manifest || !manifest.zombieCount) return null;
+    if (manifest.zombieCount > 0) {
+      const taskName = manifest.zombieTasks && manifest.zombieTasks[0] ? manifest.zombieTasks[0] : "a task";
+      return { workflow: "/debug-resistance", reason: `${manifest.zombieCount} zombie task${manifest.zombieCount > 1 ? "s" : ""}: "${taskName}" stuck 3+ days.`, score: 75, urgency: "AMBER" };
+    }
+    return null;
+  },
+  function frictionEscalated({ manifest, engineHealth }) {
+    if (!manifest) return null;
+    const level = manifest.frictionLevel || "L0";
+    const num = parseInt(String(level).replace(/[^\d]/g, ""), 10) || 0;
+    if (num < 2) return null;
+    const stratItem = engineHealth && engineHealth.items && engineHealth.items.find(i => i.file === "Strategy");
+    const stratStale = stratItem && stratItem.ageDays && stratItem.ageDays > 10;
+    if (stratStale) {
+      return { workflow: "/pivot-strategy", reason: `Friction at ${level} AND Strategy ${stratItem.ageDays}d stale. Confirm strategy before enforcing.`, score: 95, urgency: "RED" };
+    }
+    return null;
+  },
+  function firstLoadNoMorning({ now, ac }) {
+    const hour = now.getHours();
+    if (hour >= 11) return null;
+    const today = formatDate(now);
+    const lastLog = ac && ac.workflowState && ac.workflowState.log_last_run;
+    const lastLogDate = lastLog ? parseDate(lastLog) : null;
+    if (lastLogDate && isSameDay(lastLogDate, now)) return null;
+    return { workflow: "/morning", reason: `Morning primer, set energy, focus, single test for today.`, score: 70, urgency: "INFO" };
+  },
+  function noDailyStreakBroken({ now, daily }) {
+    if (!daily) return null;
+    if (daily.streak === 0 && daily.recentNotes) {
+      const lastNote = daily.recentNotes.find(n => n.exists);
+      if (lastNote) {
+        const lastDt = parseDate(lastNote.date);
+        const days = ageDays(now, lastDt);
+        if (days >= 3) {
+          return { workflow: "/reboot", reason: `${days} days since last Daily Note. Recovery + minimum viable action.`, score: 100, urgency: "RED" };
+        }
+      }
+    }
+    return null;
+  },
+  function expiredGoal({ engineHealth }) {
+    if (!engineHealth || !engineHealth.expiredGoals || engineHealth.expiredGoals.length === 0) return null;
+    const exp = engineHealth.expiredGoals[0];
+    return { workflow: "/review-week", reason: `Goal expired ${exp.expiredDays} days ago (target: ${exp.targetDate}). Revise or kill.`, score: 65, urgency: "YELLOW" };
+  }
+];
+
+function computeSuggestions(input, options = {}) {
+  const ctx = {
+    now: input.now || new Date(),
+    ac: input.ac || null,
+    manifest: input.manifest || null,
+    daily: input.daily || null,
+    engineHealth: input.engineHealth || null,
+    strategy: input.strategy || null,
+    projects: input.projects || null
+  };
+
+  // Fresh-vault gate (sandbox catch, 2026-07-07): a day-zero vault has no
+  // sessions to capture and no day to audit — every time-of-day nag ("/log
+  // hasn't run today") would be a fabricated errand for a user who just
+  // arrived. Until any workflow has ever run or any note exists, the only
+  // honest suggestion is starting: /setup (no Engine yet) or /morning
+  // (Engine written, first day not started).
+  // The shipped Active_Context template writes literal "never" values — a
+  // truthy string is NOT evidence a workflow ever ran. Only a parseable
+  // date counts.
+  const ws = (ctx.ac && ctx.ac.workflowState) || {};
+  const anyRun = ["log_last_run", "analyse_day_last_run", "weekly_review_last_run", "pivot_strategy_last_run"]
+    .some(k => ws[k] && parseDate(String(ws[k])));
+  const anyNote = !!(ctx.daily && ((ctx.daily.streak || 0) > 0 || (ctx.daily.recentNotes || []).some(n => n && n.exists)));
+  if (!anyRun && !anyNote) {
+    const strategyWritten = !!(ctx.strategy && (ctx.strategy.available || ctx.strategy.primeObjective));
+    return [{
+      workflow: strategyWritten ? "/morning" : "/setup",
+      reason: strategyWritten
+        ? "Your Engine is built but no day is on the record yet. /morning starts the first one."
+        : "Nothing is on the record yet. /setup builds your Identity, Strategy, and Goals, the Engine everything here runs on.",
+      score: 100,
+      urgency: "INFO",
+      signal: "freshVault",
+      time: formatTime(ctx.now)
+    }];
+  }
+
+  const candidates = [];
+  for (const fn of SIGNAL_TABLE) {
+    try {
+      const sig = fn(ctx);
+      if (sig) {
+        sig.signal = fn.name;
+        sig.time = formatTime(ctx.now);
+        candidates.push(sig);
+      }
+    } catch (e) {
+      // Per-signal try/catch: bad parser data shouldn't kill the engine
+    }
+  }
+
+  // Deduplicate by workflow — keep highest-score per workflow
+  const byWorkflow = {};
+  for (const c of candidates) {
+    if (!byWorkflow[c.workflow] || byWorkflow[c.workflow].score < c.score) {
+      byWorkflow[c.workflow] = c;
+    }
+  }
+
+  let merged = Object.values(byWorkflow);
+
+  // Audit pass 2 (find-bugs #4): drop any workflow whose snooze.until is
+  // still in the future. Snooze button on the Action Panel writes
+  // ~/.mover/dashboard/snoozes.json then triggers a rebuild — without
+  // this filter, the snoozed workflow re-surfaces at the top until the
+  // snooze expires, defeating the click.
+  const snoozes = Array.isArray(input.snoozes) ? input.snoozes : [];
+  if (snoozes.length) {
+    const nowMs = ctx.now.getTime();
+    // Pass 3 #9 regression: corrupt `until` (typo'd ISO, empty string)
+    // returns NaN from Date.parse — falls through the filter silently,
+    // un-snoozing the workflow without telling the user their click
+    // didn't stick. Warn once per build so the server log surfaces the
+    // bad entry without spamming.
+    const active = new Set();
+    for (const s of snoozes) {
+      if (!s || !s.workflow) continue;
+      const t = s.until ? Date.parse(s.until) : NaN;
+      if (Number.isNaN(t)) {
+        console.warn(`[suggested-now] snooze entry has invalid until: ${JSON.stringify(s).slice(0, 120)}`);
+        continue;
+      }
+      if (t > nowMs) active.add(s.workflow);
+    }
+    if (active.size) {
+      merged = merged.filter(c => !active.has(c.workflow));
+    }
+  }
+
+  merged.sort((a, b) => b.score - a.score);
+
+  const top = merged.slice(0, options.limit || 3);
+  return top;
+}
+
+function ageDays(now, then) {
+  if (!then) return null;
+  const t = then instanceof Date ? then : new Date(then);
+  if (isNaN(t.getTime())) return null;
+  return Math.floor((now.getTime() - t.getTime()) / (24 * 60 * 60 * 1000));
+}
+
+function isSameDay(a, b) {
+  if (!a || !b) return false;
+  return a.getFullYear() === b.getFullYear() &&
+    a.getMonth() === b.getMonth() &&
+    a.getDate() === b.getDate();
+}
+
+function parseDate(s) {
+  if (!s) return null;
+  const d = new Date(s);
+  return isNaN(d.getTime()) ? null : d;
+}
+
+function formatTime(d) {
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+
+function formatDate(d) {
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+
+module.exports = { computeSuggestions };

package/src/dashboard/lib/tool-awareness.js

@@ -0,0 +1,125 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { execFileSync } = require("child_process");
+
+// tool-awareness.js — the awareness half of the recommend layer (owner ruling
+// 2026-07-07: bundled skills install ALL; recommendations are for EXTERNAL
+// things only — MCP connectors + CLI tools). This module answers two honest
+// questions from the machine itself, never from assumption:
+//   1. Which useful CLI tools are already installed? (command -v sweep)
+//   2. Which MCP connectors are already attached? (the agent's own config)
+// Catalogues live in src/system/{cli,connector}-catalogue.json and ship with
+// the bundle; the funnel matches them against the setup profile and marks
+// what the user already has instead of recommending it.
+
+const SYSTEM_DIR = path.join(__dirname, "..", "..", "system");
+
+function readCatalogue(file, key) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(path.join(SYSTEM_DIR, file), "utf8"));
+    return Array.isArray(raw[key]) ? raw[key] : [];
+  } catch (_) {
+    return [];
+  }
+}
+
+function cliCatalogue() { return readCatalogue("cli-catalogue.json", "tools"); }
+function connectorCatalogue() { return readCatalogue("connector-catalogue.json", "connectors"); }
+
+// which(bin) — true when the binary resolves on PATH. execFileSync (no shell)
+// so a hostile catalogue entry can't smuggle commands.
+function which(bin) {
+  if (!/^[A-Za-z0-9._-]+$/.test(String(bin || ""))) return false;
+  try {
+    execFileSync(process.platform === "win32" ? "where" : "which", [bin], { stdio: "pipe", timeout: 3000 });
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+// detectCli() — the catalogue with an installed flag per entry.
+function detectCli() {
+  return cliCatalogue().map((t) => ({ ...t, installed: which(t.bin) }));
+}
+
+// attachedMcpServers() — names of MCP servers the user's Claude config already
+// carries. Reads config files directly (fast, no agent spawn): ~/.claude.json
+// top-level mcpServers + per-project entries, plus .mcp.json in the vault if
+// one exists. Missing/unparseable files are honest empties, never errors.
+function attachedMcpServers({ vault } = {}) {
+  const names = new Set();
+  const home = os.homedir();
+  const eat = (obj) => {
+    if (obj && typeof obj.mcpServers === "object" && obj.mcpServers) {
+      Object.keys(obj.mcpServers).forEach((k) => names.add(k.toLowerCase()));
+    }
+  };
+  try {
+    const cfg = JSON.parse(fs.readFileSync(path.join(home, ".claude.json"), "utf8"));
+    eat(cfg);
+    if (cfg && typeof cfg.projects === "object" && cfg.projects) {
+      Object.values(cfg.projects).forEach(eat);
+    }
+  } catch (_) { /* no global claude config — fine */ }
+  if (vault) {
+    try { eat(JSON.parse(fs.readFileSync(path.join(vault, ".mcp.json"), "utf8"))); } catch (_) { /* none */ }
+  }
+  return Array.from(names);
+}
+
+// detectConnectors() — the catalogue with an attached flag per entry (matched
+// by id against the user's configured MCP server names, substring-tolerant:
+// "slack" matches "slack-mcp" etc.).
+function detectConnectors({ vault } = {}) {
+  const attached = attachedMcpServers({ vault });
+  return connectorCatalogue().map((c) => ({
+    ...c,
+    attached: attached.some((n) => n.includes(c.id) || c.id.includes(n)),
+  }));
+}
+
+// matchByProfile(entries, profile) — same keyword engine shape as
+// skill-recommender: every profile string is tokenized and matched against
+// each entry's keywords; score = distinct keyword hits. Returns entries with
+// score > 0, ranked, un-matched entries dropped (the funnel shows a "show
+// everything" affordance backed by the raw catalogue instead).
+function matchByProfile(entries, profile) {
+  const text = []
+    .concat(profile && profile.work ? [profile.work] : [])
+    .concat(Array.isArray(profile && profile.domain) ? profile.domain : [])
+    .concat(Array.isArray(profile && profile.tools) ? profile.tools : [])
+    .concat(Array.isArray(profile && profile.goals) ? profile.goals : [])
+    .join(" ")
+    .toLowerCase();
+  if (!text.trim()) return [];
+  return entries
+    .map((e) => {
+      const hits = (e.keywords || []).filter((k) => text.includes(k)).length;
+      return { entry: e, score: hits };
+    })
+    .filter((x) => x.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .map((x) => ({ ...x.entry, confidence: Math.min(1, x.score / 3) }));
+}
+
+// awareness(profile, {vault}) — the full recommend-layer payload:
+//   cliTools:    profile-matched catalogue entries, installed flagged
+//   connectors:  profile-matched catalogue entries, attached flagged
+//   installedCli / attachedConnectors: the full awareness sweep (for the
+//                Configure surface and the co-founder's context)
+function awareness(profile, { vault } = {}) {
+  const cli = detectCli();
+  const conn = detectConnectors({ vault });
+  return {
+    cliTools: matchByProfile(cli, profile),
+    connectors: matchByProfile(conn, profile),
+    installedCli: cli.filter((t) => t.installed).map((t) => t.id),
+    attachedConnectors: conn.filter((c) => c.attached).map((c) => c.id),
+  };
+}
+
+module.exports = { awareness, detectCli, detectConnectors, attachedMcpServers, matchByProfile, cliCatalogue, connectorCatalogue };