mover-os 4.7.7 → 4.7.9

package/src/dashboard/lib/library-indexer.js

@@ -0,0 +1,105 @@
+"use strict";
+
+const path = require("path");
+const fs = require("fs");
+const {
+  libraryDir,
+  libraryCheatsheetsDir,
+  libraryPrinciplesDir,
+  librarySopsDir,
+  libraryEntitiesDir,
+  libraryEntitiesPeopleDir,
+  libraryEntitiesOrgsDir,
+  libraryEntitiesPlacesDir,
+  libraryEntitiesDecisionsDir,
+  libraryInputsDir,
+  libraryScriptsDir,
+  libraryMocsDir,
+  safeListDir,
+  safeStat,
+  exists
+} = require("./paths");
+
+// Index 03_Library/* — counts + recent items per subdirectory.
+
+function indexLibrary(vault) {
+  if (!exists(libraryDir(vault))) return { available: false };
+
+  const sections = [
+    { name: "Cheatsheets", dir: libraryCheatsheetsDir(vault) },
+    { name: "Principles", dir: libraryPrinciplesDir(vault) },
+    { name: "SOPs", dir: librarySopsDir(vault) },
+    { name: "MOCs", dir: libraryMocsDir(vault) },
+    { name: "Scripts", dir: libraryScriptsDir(vault) }
+  ];
+
+  const out = { available: true, sections: [], recent: [], counts: { total: 0 } };
+
+  for (const sec of sections) {
+    if (!exists(sec.dir)) {
+      out.sections.push({ name: sec.name, count: 0, recent: [] });
+      continue;
+    }
+    const entries = walkMarkdown(sec.dir);
+    entries.sort((a, b) => b.mtime - a.mtime);
+    const recent = entries.slice(0, 3).map(e => ({
+      name: e.name.replace(/\.md$/, ""),
+      mtime: e.mtime,
+      ageDays: Math.floor((Date.now() - e.mtime) / 86400000)
+    }));
+    out.sections.push({ name: sec.name, count: entries.length, recent });
+    out.counts[sec.name.toLowerCase()] = entries.length;
+    out.counts.total += entries.length;
+  }
+
+  // Entities
+  const entitySubs = [
+    { name: "People", dir: libraryEntitiesPeopleDir(vault) },
+    { name: "Orgs", dir: libraryEntitiesOrgsDir(vault) },
+    { name: "Places", dir: libraryEntitiesPlacesDir(vault) },
+    { name: "Decisions", dir: libraryEntitiesDecisionsDir(vault) }
+  ];
+  out.entities = entitySubs.map(s => {
+    const entries = exists(s.dir) ? walkMarkdown(s.dir) : [];
+    entries.sort((a, b) => b.mtime - a.mtime);
+    return {
+      name: s.name,
+      count: entries.length,
+      recent: entries.slice(0, 5).map(e => ({
+        name: e.name.replace(/\.md$/, ""),
+        mtime: e.mtime,
+        ageDays: Math.floor((Date.now() - e.mtime) / 86400000)
+      }))
+    };
+  });
+
+  // Inputs (Articles, Books, Videos)
+  if (exists(libraryInputsDir(vault))) {
+    const inputSubs = safeListDir(libraryInputsDir(vault), { dirsOnly: true });
+    out.inputs = inputSubs.map(sub => {
+      const entries = walkMarkdown(sub.path);
+      return { name: sub.name, count: entries.length };
+    });
+  } else {
+    out.inputs = [];
+  }
+
+  return out;
+}
+
+function walkMarkdown(dir, depth = 0) {
+  if (depth > 3) return [];
+  const out = [];
+  const entries = safeListDir(dir);
+  for (const e of entries) {
+    if (e.isFile && e.name.endsWith(".md") && !e.name.startsWith("_")) {
+      const stat = safeStat(e.path);
+      if (stat) out.push({ name: e.name, path: e.path, mtime: stat.mtime.getTime() });
+    } else if (e.isDir && !e.name.startsWith("_") && !e.name.startsWith(".")) {
+      out.push(...walkMarkdown(e.path, depth + 1));
+    }
+  }
+  return out;
+}
+
+module.exports = { indexLibrary };

package/src/dashboard/lib/library-search.js

@@ -0,0 +1,290 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+// library-search.js — ONE truthful search index for the Library route.
+//
+// Sol full product review (2026-07-11, Library 5.0/10): the "EVERYTHING"
+// search box indexed only the libraryV2 subset while the other shelves were
+// counts with no rows behind them. This module makes the coverage equal the
+// advertised shelves: every shelf the bento names is either content-searchable
+// here or explicitly reported as notIndexable with the reason (CLI commands
+// are usage counts, not files).
+//
+// Contract:
+//   - Read-only. Never writes. Never leaves the declared shelf roots.
+//   - Bounded: per-file size cap, per-shelf file cap, result cap, passage cap.
+//   - Results carry root + vault-relative (or root-relative) path + a 1-based
+//     line anchor + the matched passage, so the UI can open the real file AT
+//     the passage in the existing viewer.
+//   - Honest coverage: shelves whose directory does not exist are reported in
+//     coverage.missing; shelves with nothing to read are in
+//     coverage.notIndexable. Nothing is silently skipped.
+//   - Non-text files (PDFs, images) match by NAME only and say so
+//     (nameOnly: true, line/passage null) — never implied content coverage.
+
+const MAX_FILE_BYTES = 256 * 1024;      // matches /api/file/read cap
+const MAX_FILES_PER_SHELF = 2000;
+const MAX_DEPTH = 6;
+const MAX_LIMIT = 100;
+const DEFAULT_LIMIT = 40;
+const PASSAGE_CAP = 240;
+const EXCLUDED_DIRS = new Set([
+  "node_modules", "dist", ".git", ".obsidian", ".trash", "coverage",
+]);
+
+// Extensions whose CONTENT we read as text. Everything else is name-only.
+const TEXT_EXTS = new Set([".md", ".txt", ".sh", ".js", ".mjs", ".ps1", ".canvas", ".json"]);
+
+// ── shelf definitions — ids are stable API; labels mirror the bento ─────────
+// dirs(ctx) returns the roots to walk for that shelf, each tagged with the
+// serving root id the file-read endpoint understands (vault|skills|workflows|hooks).
+const SHELVES = [
+  {
+    id: "engine", label: "Engine files",
+    dirs: (ctx) => [{ root: "vault", dir: path.join(ctx.vault, "02_Areas", "Engine"), depth: 1 }],
+  },
+  {
+    id: "projects", label: "Projects",
+    dirs: (ctx) => [{ root: "vault", dir: path.join(ctx.vault, "01_Projects"), depth: MAX_DEPTH }],
+  },
+  {
+    id: "library", label: "Library notes",
+    dirs: (ctx) => [
+      { root: "vault", dir: path.join(ctx.vault, "03_Library", "MOCs"), depth: 3 },
+      { root: "vault", dir: path.join(ctx.vault, "03_Library", "Principles"), depth: 3 },
+      { root: "vault", dir: path.join(ctx.vault, "03_Library", "SOPs"), depth: 3 },
+      { root: "vault", dir: path.join(ctx.vault, "03_Library", "Cheatsheets"), depth: 3 },
+      { root: "vault", dir: path.join(ctx.vault, "03_Library", "Scripts"), depth: 3 },
+      { root: "vault", dir: path.join(ctx.vault, "03_Library", "Entities", "Decisions"), depth: 3 },
+    ],
+  },
+  {
+    id: "skills", label: "Skills",
+    dirs: (ctx) => [{ root: "skills", dir: path.join(ctx.claudeDir, "skills"), depth: 3 }],
+  },
+  {
+    id: "hooks", label: "Hooks",
+    dirs: (ctx) => [{ root: "hooks", dir: path.join(ctx.bundleRoot, "src", "hooks"), depth: 2 }],
+  },
+  {
+    id: "workflows", label: "Workflows",
+    dirs: (ctx) => [{ root: "workflows", dir: path.join(ctx.bundleRoot, "src", "workflows"), depth: 1 }],
+  },
+  {
+    id: "cli", label: "CLI commands",
+    notIndexable: "CLI commands are usage counts stored in your config, not files. There is no text to search.",
+  },
+  {
+    id: "people", label: "People",
+    dirs: (ctx) => [
+      { root: "vault", dir: path.join(ctx.vault, "03_Library", "Entities", "People"), depth: 2 },
+      { root: "vault", dir: path.join(ctx.vault, "03_Library", "Entities", "Organizations"), depth: 2 },
+      { root: "vault", dir: path.join(ctx.vault, "03_Library", "Entities", "Places"), depth: 2 },
+    ],
+  },
+  {
+    id: "captures", label: "Captures",
+    dirs: (ctx) => [{ root: "vault", dir: path.join(ctx.vault, "03_Library", "Inputs"), depth: 3 }],
+  },
+  {
+    id: "archives", label: "Archives",
+    dirs: (ctx) => [{ root: "vault", dir: path.join(ctx.vault, "04_Archives"), depth: MAX_DEPTH }],
+  },
+];
+
+/** Map a serving-root id to its absolute directory. Used by the file-read
+ *  endpoint to resolve non-vault results with the same realpath containment
+ *  it already applies to the vault. Returns null for unknown roots. */
+function rootDirFor(ctx, root) {
+  if (root === "vault") return ctx.vault;
+  if (root === "skills") return path.join(ctx.claudeDir, "skills");
+  if (root === "workflows") return path.join(ctx.bundleRoot, "src", "workflows");
+  if (root === "hooks") return path.join(ctx.bundleRoot, "src", "hooks");
+  return null;
+}
+
+function walkFiles(dir, maxDepth, out, state) {
+  if (state.count >= MAX_FILES_PER_SHELF) return;
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (_e) { return; }
+  for (const ent of entries) {
+    if (state.count >= MAX_FILES_PER_SHELF) return;
+    if (ent.name.startsWith(".")) continue;
+    const full = path.join(dir, ent.name);
+    if (ent.isDirectory()) {
+      if (EXCLUDED_DIRS.has(ent.name)) continue;
+      if (maxDepth > 1) walkFiles(full, maxDepth - 1, out, state);
+      continue;
+    }
+    if (!ent.isFile()) continue; // symlinks are not followed — containment stays real
+    out.push(full);
+    state.count += 1;
+  }
+}
+
+/** Collect the files behind one shelf. Returns { files: [{abs, root, rootDir}], missing } */
+function shelfFiles(shelf, ctx) {
+  const roots = shelf.dirs ? shelf.dirs(ctx) : [];
+  const files = [];
+  let anyDirExists = false;
+  const state = { count: 0 };
+  for (const r of roots) {
+    let stat = null;
+    try { stat = fs.statSync(r.dir); } catch (_e) { /* absent */ }
+    if (!stat || !stat.isDirectory()) continue;
+    anyDirExists = true;
+    const abs = [];
+    walkFiles(r.dir, r.depth || 1, abs, state);
+    for (const a of abs) files.push({ abs: a, root: r.root, rootDir: rootDirFor(ctx, r.root) });
+  }
+  return { files, missing: roots.length > 0 && !anyDirExists };
+}
+
+/** Build the passage around the first match inside a line, capped. */
+function passageFrom(line, matchIdx, qLen) {
+  const trimmed = line.trim();
+  if (trimmed.length <= PASSAGE_CAP) return trimmed;
+  // center the window on the match
+  const lead = Math.max(0, matchIdx - Math.floor((PASSAGE_CAP - qLen) / 2));
+  const slice = line.slice(lead, lead + PASSAGE_CAP).trim();
+  return slice;
+}
+
+/**
+ * searchLibrary(ctx, opts) — the one index.
+ *   ctx  = { vault, bundleRoot, claudeDir }
+ *   opts = { q, shelf, limit }
+ *     q     — case-insensitive substring; empty q + shelf = browse listing
+ *     shelf — shelf id to scope to ("" = every indexed shelf)
+ *     limit — max results (1..100)
+ * Returns { q, shelf, results, truncated, scanned, coverage }.
+ */
+function searchLibrary(ctx, opts = {}) {
+  const q = String(opts.q || "").slice(0, 200);
+  const scope = String(opts.shelf || "");
+  const limit = Math.max(1, Math.min(MAX_LIMIT, Number(opts.limit) || DEFAULT_LIMIT));
+  const lc = q.toLowerCase();
+
+  const coverage = { indexed: [], notIndexable: [], missing: [] };
+  const results = [];
+  let scannedFiles = 0;
+  let skippedLarge = 0;
+  let truncated = false;
+
+  for (const shelf of SHELVES) {
+    if (shelf.notIndexable) {
+      coverage.notIndexable.push({ id: shelf.id, label: shelf.label, reason: shelf.notIndexable });
+      continue;
+    }
+    const { files, missing } = shelfFiles(shelf, ctx);
+    if (missing) {
+      coverage.missing.push({ id: shelf.id, label: shelf.label });
+      continue;
+    }
+    coverage.indexed.push({ id: shelf.id, label: shelf.label, files: files.length });
+
+    if (scope && scope !== shelf.id) continue; // counted for coverage, never searched
+
+    for (const f of files) {
+      // Every skill's file is literally named SKILL.md — the skill's actual
+      // name is its folder. Rendering the basename made the whole Skills
+      // shelf read "SKILL.md, SKILL.md, ..." (owner report + terra CONFIRMED
+      // #1, 2026-07-12). Same rule for any convention-named container file.
+      const base = path.basename(f.abs);
+      let name = base;
+      if (/^(SKILL|README|INDEX)\.md$/i.test(base)) {
+        const folder = path.basename(path.dirname(f.abs));
+        if (folder && folder !== "." && folder !== path.basename(f.rootDir)) name = folder;
+      }
+      const relPath = path.relative(f.rootDir, f.abs).split(path.sep).join("/");
+      // ext/textReadable ALWAYS derive from the real file, never the display
+      // name — a folder-derived name has no extension and would silently
+      // demote the file to name-only search.
+      const ext = path.extname(base).toLowerCase();
+      const textReadable = TEXT_EXTS.has(ext);
+
+      let mtime = null;
+      let size = 0;
+      try { const st = fs.statSync(f.abs); mtime = st.mtime.toISOString(); size = st.size; } catch (_e) { continue; }
+
+      // Browse mode: empty query + a shelf scope lists the shelf's real files.
+      if (!lc) {
+        if (!scope) continue; // browsing "everything" is the catalog's job
+        results.push({
+          shelf: shelf.id, shelfLabel: shelf.label, name, relPath, root: f.root,
+          line: null, passage: null, matches: 0, nameOnly: !textReadable, mtime,
+        });
+        continue;
+      }
+
+      const nameHit = name.toLowerCase().includes(lc);
+
+      if (!textReadable) {
+        // Content is not text — a name match is the only honest match.
+        if (nameHit) {
+          results.push({
+            shelf: shelf.id, shelfLabel: shelf.label, name, relPath, root: f.root,
+            line: null, passage: null, matches: 0, nameOnly: true, mtime,
+          });
+        }
+        continue;
+      }
+
+      if (size > MAX_FILE_BYTES) { skippedLarge += 1; continue; }
+
+      let content = "";
+      try { content = fs.readFileSync(f.abs, "utf8"); } catch (_e) { continue; }
+      scannedFiles += 1;
+
+      let firstLine = null;
+      let firstPassage = null;
+      let matches = 0;
+      const lines = content.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const idx = lines[i].toLowerCase().indexOf(lc);
+        if (idx === -1) continue;
+        matches += 1;
+        if (firstLine === null) {
+          firstLine = i + 1;
+          firstPassage = passageFrom(lines[i], idx, lc.length);
+        }
+      }
+
+      if (!nameHit && matches === 0) continue;
+      results.push({
+        shelf: shelf.id, shelfLabel: shelf.label, name, relPath, root: f.root,
+        line: firstLine, passage: firstPassage, matches,
+        nameOnly: matches === 0, mtime,
+      });
+    }
+  }
+
+  // Rank: name matches first, then by match density, then recency.
+  if (lc) {
+    results.sort((a, b) => {
+      const an = a.name.toLowerCase().includes(lc) ? 1 : 0;
+      const bn = b.name.toLowerCase().includes(lc) ? 1 : 0;
+      if (an !== bn) return bn - an;
+      if (a.matches !== b.matches) return b.matches - a.matches;
+      return String(b.mtime || "").localeCompare(String(a.mtime || ""));
+    });
+  } else {
+    results.sort((a, b) => String(b.mtime || "").localeCompare(String(a.mtime || "")));
+  }
+
+  if (results.length > limit) {
+    results.length = limit;
+    truncated = true;
+  }
+
+  return {
+    q, shelf: scope || "all",
+    results, truncated,
+    scanned: { files: scannedFiles, skippedLarge },
+    coverage,
+  };
+}
+
+module.exports = { searchLibrary, rootDirFor, SHELVES };

package/src/dashboard/lib/log-activation.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# log-activation.sh — POSTs a V5.0 activation event to a running dashboard.
+#
+# Usage:
+#   log-activation.sh <event_type> [meta_json]
+#
+# Examples:
+#   log-activation.sh log_completed
+#   log-activation.sh referral_mentioned '{"source":"twitter"}'
+#   log-activation.sh onboarding_finished
+#
+# Exits silently (best-effort) if:
+#   - No token file at ~/.mover/dashboard/.token (server not running)
+#   - curl missing
+#   - HTTP failure
+#
+# Used by workflow Bash steps (log.md, capture.md, pivot-strategy.md)
+# and Stop hooks. Phase 41.0.7 of V5 backlog.
+
+set -e
+
+EVENT_TYPE="${1:-}"
+META="${2:-}"
+
+if [ -z "$EVENT_TYPE" ]; then
+  exit 0  # silent — no-op when invoked without args
+fi
+
+TOKEN_FILE="$HOME/.mover/dashboard/.token"
+if [ ! -f "$TOKEN_FILE" ]; then
+  exit 0  # silent — server not running
+fi
+
+# Extract token + url with minimal JSON parsing
+TOKEN=$(grep -o '"token"[[:space:]]*:[[:space:]]*"[^"]*"' "$TOKEN_FILE" | head -1 | sed 's/.*: *"//;s/"//')
+URL=$(grep -o '"url"[[:space:]]*:[[:space:]]*"[^"]*"' "$TOKEN_FILE" | head -1 | sed 's/.*: *"//;s/"//')
+
+if [ -z "$TOKEN" ] || [ -z "$URL" ]; then
+  exit 0
+fi
+
+# Build body
+if [ -n "$META" ]; then
+  BODY=$(printf '{"type":"%s","meta":%s}' "$EVENT_TYPE" "$META")
+else
+  BODY=$(printf '{"type":"%s"}' "$EVENT_TYPE")
+fi
+
+# Best-effort POST. Suppress all output — workflow logs shouldn't show this.
+# Timeout = 2s so a hung server can't stall a workflow.
+if command -v curl >/dev/null 2>&1; then
+  curl -s -m 2 \
+    -X POST \
+    -H "Content-Type: application/json" \
+    -H "X-Mover-Token: $TOKEN" \
+    -H "Origin: $URL" \
+    -d "$BODY" \
+    "$URL/api/event" >/dev/null 2>&1 || true
+fi
+
+exit 0

package/src/dashboard/lib/memory-curator.js

@@ -0,0 +1,97 @@
+"use strict";
+
+// memory-curator.js — Mover memory engine, Layer 5 (curator lifecycle + reflection loop).
+//
+// curate(): ages every indexed session active -> stale (30d) -> archived (90d) and decays its
+//   trust so recall naturally favours fresh context. It NEVER deletes — old sessions stay
+//   searchable, just lower-weighted (the Curator pattern: forget gracefully, lose nothing).
+//
+// reflect(): drafts the DATA half of /analyse-day from the index (recent arcs + trending
+//   entities) for the owner to ENGAGE with. Auto-analysis nobody reads is theatre — the
+//   judgment half stays human. Writes nothing.
+
+const fs = require("fs");
+const path = require("path");
+const { moverDir, safeReadJson } = require("./paths");
+const { parseSessionLogs } = require("./session-log-parser");
+
+const MEM_DIR = process.env.MOVER_MEMORY_DIR || path.join(moverDir(), "memory");
+const SEG_DIR = path.join(MEM_DIR, "segments");
+const MANIFEST = path.join(MEM_DIR, "manifest.json");
+
+const ACTIVE_DAYS = 30, ARCHIVE_DAYS = 90;
+const TRUST = { active: 1.0, stale: 0.85, archived: 0.6 };
+
+function loadManifest() { return safeReadJson(MANIFEST); }
+function loadSeg(n) { return safeReadJson(path.join(SEG_DIR, n + ".json")); }
+function atomicWrite(file, obj) { const t = file + ".tmp"; fs.writeFileSync(t, JSON.stringify(obj)); fs.renameSync(t, file); }
+
+function tier(ts) {
+  const t = ts ? Date.parse(ts) : NaN;
+  if (!Number.isFinite(t)) return "active";
+  const days = (Date.now() - t) / 86400000;
+  if (days > ARCHIVE_DAYS) return "archived";
+  if (days > ACTIVE_DAYS) return "stale";
+  return "active";
+}
+
+// Age sessions + write trust weights into the manifest (consumed by memory-index query()).
+function curate(opts = {}) {
+  const man = loadManifest();
+  if (!man) return { available: false, active: 0, stale: 0, archived: 0, adjusted: 0, written: 0 };
+  man.trust = man.trust || {};
+  const counts = { active: 0, stale: 0, archived: 0 };
+  let adjusted = 0;
+  for (const seg of (man.segments || []).filter((s) => s.startsWith("raw-"))) {
+    const s = loadSeg(seg);
+    if (!s) continue;
+    for (const id in s.docs) {
+      const tr = tier(s.docs[id].ts);
+      counts[tr]++;
+      const w = TRUST[tr];
+      if (w !== 1.0) {
+        if (man.trust[id] !== w) { man.trust[id] = w; adjusted++; }
+      } else if (man.trust[id] != null && man.trust[id] !== 1.0) {
+        delete man.trust[id]; adjusted++; // a session refreshed back into the active window
+      }
+    }
+  }
+  man.curatedAt = new Date().toISOString();
+  atomicWrite(MANIFEST, man);
+  return { available: true, ...counts, adjusted, total: counts.active + counts.stale + counts.archived, written: adjusted };
+}
+
+// Draft a reflection from the index: recent arcs + entities trending across sessions.
+function reflect(opts = {}) {
+  const man = loadManifest();
+  if (!man) return { available: false, draft: "", trendingEntities: [], recentArcs: [], written: 0 };
+  const N = Object.keys(man.indexedSessions || {}).length || 1;
+
+  const trendingEntities = Object.keys(man.linkFreq || {})
+    .map((note) => { const f = man.linkFreq[note]; const idf = Math.log(N / Math.max(1, f)); return { note, sessions: f, score: +(f * idf).toFixed(2) }; })
+    .filter((x) => x.sessions / N <= 0.6) // drop the ubiquitous (Engine files etc.)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, opts.limit || 10);
+
+  let recentArcs = [];
+  try {
+    const vault = opts.vault || man.vault;
+    if (vault) recentArcs = parseSessionLogs(vault).docs.slice(0, 8).map((d) => ({ date: d.date, title: d.title }));
+  } catch {}
+
+  const lines = ["## Reflection (auto-draft — engage with it, don't just read it)", ""];
+  if (recentArcs.length) { lines.push("Recent arcs:"); recentArcs.forEach((a) => lines.push(`- ${a.date} — ${a.title}`)); lines.push(""); }
+  if (trendingEntities.length) { lines.push("Entities trending across your sessions:"); trendingEntities.forEach((t) => lines.push(`- [[${t.note}]] (${t.sessions} sessions)`)); lines.push(""); }
+  lines.push("What pattern is forming? What's the one decision to make next? (your call — this is the /analyse-day judgment half.)");
+
+  return { available: true, draft: lines.join("\n"), trendingEntities, recentArcs, written: 0 };
+}
+
+module.exports = { curate, reflect, MEM_DIR };
+
+// ── CLI ──
+if (require.main === module) {
+  const vault = require("./paths").resolveVault();
+  console.log("curate:", JSON.stringify(curate()));
+  console.log("\n" + reflect({ vault }).draft);
+}