moveros 4.1.1 → 4.1.2

package/install.js

@@ -327,10 +327,11 @@ function validateKey(key) {
 // ─── CLI ─────────────────────────────────────────────────────────────────────
 function parseArgs() {
   const args = process.argv.slice(2);
-  const opts = { vault: "", key: "" };
+  const opts = { vault: "", key: "", update: false };
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--vault" && args[i + 1]) opts.vault = args[++i];
     else if (args[i] === "--key" && args[i + 1]) opts.key = args[++i];
+    else if (args[i] === "--update" || args[i] === "-u") opts.update = true;
     else if (args[i] === "--help" || args[i] === "-h") {
       ln();
       ln(`  ${bold("mover os")} ${dim("installer")}`);
@@ -340,6 +341,7 @@ function parseArgs() {
       ln(`  ${dim("Options")}`);
       ln(`    --key KEY       License key (skip interactive prompt)`);
       ln(`    --vault PATH    Obsidian vault path (skip detection)`);
+      ln(`    --update, -u    Quick update (auto-detect vault + agents, no prompts)`);
       ln();
       process.exit(0);
     }
@@ -347,6 +349,181 @@ function parseArgs() {
   return opts;
 }
 
+// ─── Obsidian vault detection ───────────────────────────────────────────────
+function detectObsidianVaults() {
+  const configPaths = {
+    win32: path.join(os.homedir(), "AppData", "Roaming", "Obsidian", "obsidian.json"),
+    darwin: path.join(os.homedir(), "Library", "Application Support", "obsidian", "obsidian.json"),
+    linux: path.join(os.homedir(), ".config", "obsidian", "obsidian.json"),
+  };
+  const configPath = configPaths[process.platform];
+  if (!configPath || !fs.existsSync(configPath)) return [];
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    if (!config.vaults) return [];
+    return Object.values(config.vaults)
+      .map((v) => v.path)
+      .filter((p) => p && fs.existsSync(p))
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+// ─── Change detection (update mode) ─────────────────────────────────────────
+function detectChanges(bundleDir, vaultPath, selectedAgentIds) {
+  const home = os.homedir();
+  const result = { workflows: [], hooks: [], rules: null, templates: [] };
+
+  // --- Workflows: compare source vs first installed destination ---
+  const wfSrc = path.join(bundleDir, "src", "workflows");
+  const wfDests = [
+    selectedAgentIds.includes("claude-code") && path.join(home, ".claude", "commands"),
+    selectedAgentIds.includes("cursor") && path.join(home, ".cursor", "commands"),
+    selectedAgentIds.includes("antigravity") && path.join(home, ".gemini", "antigravity", "global_workflows"),
+  ].filter(Boolean);
+  const wfDest = wfDests.find((d) => fs.existsSync(d));
+
+  if (fs.existsSync(wfSrc)) {
+    for (const file of fs.readdirSync(wfSrc).filter((f) => f.endsWith(".md"))) {
+      const srcContent = fs.readFileSync(path.join(wfSrc, file), "utf8");
+      const destFile = wfDest && path.join(wfDest, file);
+      if (!destFile || !fs.existsSync(destFile)) {
+        result.workflows.push({ file, status: "new" });
+      } else {
+        const destContent = fs.readFileSync(destFile, "utf8");
+        result.workflows.push({
+          file,
+          status: srcContent === destContent ? "unchanged" : "changed",
+        });
+      }
+    }
+  }
+
+  // --- Hooks: compare with CRLF normalization ---
+  const hooksSrc = path.join(bundleDir, "src", "hooks");
+  const hooksDest = path.join(home, ".claude", "hooks");
+  if (fs.existsSync(hooksSrc) && selectedAgentIds.includes("claude-code")) {
+    for (const file of fs.readdirSync(hooksSrc).filter((f) => f.endsWith(".sh") || f.endsWith(".md"))) {
+      const srcContent = fs.readFileSync(path.join(hooksSrc, file), "utf8")
+        .replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+      const destFile = path.join(hooksDest, file);
+      if (!fs.existsSync(destFile)) {
+        result.hooks.push({ file, status: "new" });
+      } else {
+        const destContent = fs.readFileSync(destFile, "utf8")
+          .replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        result.hooks.push({
+          file,
+          status: srcContent === destContent ? "unchanged" : "changed",
+        });
+      }
+    }
+  }
+
+  // --- Rules: compare source vs first installed destination ---
+  const rulesSrc = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+  const rulesDests = [
+    selectedAgentIds.includes("claude-code") && path.join(home, ".claude", "CLAUDE.md"),
+    selectedAgentIds.includes("cursor") && path.join(home, ".cursor", "rules", "mover-os.mdc"),
+    selectedAgentIds.includes("gemini-cli") && path.join(home, ".gemini", "GEMINI.md"),
+  ].filter(Boolean);
+  const rulesDest = rulesDests.find((d) => fs.existsSync(d));
+  if (fs.existsSync(rulesSrc) && rulesDest) {
+    const srcContent = fs.readFileSync(rulesSrc, "utf8");
+    const destContent = fs.readFileSync(rulesDest, "utf8");
+    result.rules = srcContent === destContent ? "unchanged" : "changed";
+  } else {
+    result.rules = "unchanged";
+  }
+
+  // --- Templates: non-Engine vault files ---
+  const structDir = path.join(bundleDir, "src", "structure");
+  if (fs.existsSync(structDir)) {
+    const walkTemplates = (dir, rel) => {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const entryRel = path.join(rel, entry.name);
+        if (entry.isDirectory()) {
+          walkTemplates(path.join(dir, entry.name), entryRel);
+        } else {
+          const relNorm = entryRel.replace(/\\/g, "/");
+          if (relNorm.includes("02_Areas") && relNorm.includes("Engine")) continue;
+          const srcContent = fs.readFileSync(path.join(dir, entry.name), "utf8");
+          const destFile = path.join(vaultPath, entryRel);
+          if (!fs.existsSync(destFile)) {
+            result.templates.push({ file: entryRel, status: "new" });
+          } else {
+            const destContent = fs.readFileSync(destFile, "utf8");
+            result.templates.push({
+              file: entryRel,
+              status: srcContent === destContent ? "unchanged" : "changed",
+            });
+          }
+        }
+      }
+    };
+    walkTemplates(structDir, "");
+  }
+
+  return result;
+}
+
+function countChanges(changes) {
+  let n = 0;
+  n += changes.workflows.filter((f) => f.status !== "unchanged").length;
+  n += changes.hooks.filter((f) => f.status !== "unchanged").length;
+  if (changes.rules === "changed") n++;
+  n += changes.templates.filter((f) => f.status !== "unchanged").length;
+  return n;
+}
+
+function displayChangeSummary(changes, installedVersion, newVersion) {
+  // Version line
+  if (installedVersion && newVersion && installedVersion !== newVersion) {
+    barLn(`  Installed: ${dim(installedVersion)} → ${bold(newVersion)}`);
+  } else if (installedVersion === newVersion) {
+    barLn(`  Version: ${dim(installedVersion)} (files may differ)`);
+  }
+  barLn();
+
+  // Workflows
+  const wfChanged = changes.workflows.filter((f) => f.status === "changed");
+  const wfNew = changes.workflows.filter((f) => f.status === "new");
+  const wfUnchanged = changes.workflows.filter((f) => f.status === "unchanged");
+  barLn(`  Workflows ${dim(`(${wfChanged.length + wfNew.length} changed, ${wfUnchanged.length} unchanged)`)}:`);
+  for (const f of wfChanged) barLn(`    ${yellow("✦")} /${f.file.replace(".md", "")}`);
+  for (const f of wfNew) barLn(`    ${green("+")} /${f.file.replace(".md", "")} ${dim("(new)")}`);
+  if (wfChanged.length === 0 && wfNew.length === 0) barLn(`    ${dim("all up to date")}`);
+  barLn();
+
+  // Hooks
+  if (changes.hooks.length > 0) {
+    const hkChanged = changes.hooks.filter((f) => f.status === "changed");
+    const hkNew = changes.hooks.filter((f) => f.status === "new");
+    const hkUnchanged = changes.hooks.filter((f) => f.status === "unchanged");
+    barLn(`  Hooks ${dim(`(${hkChanged.length + hkNew.length} changed, ${hkUnchanged.length} unchanged)`)}:`);
+    for (const f of hkChanged) barLn(`    ${yellow("✦")} ${f.file}`);
+    for (const f of hkNew) barLn(`    ${green("+")} ${f.file} ${dim("(new)")}`);
+    if (hkChanged.length === 0 && hkNew.length === 0) barLn(`    ${dim("all up to date")}`);
+    barLn();
+  }
+
+  // Rules
+  barLn(`  Rules: ${changes.rules === "changed" ? yellow("changed") : dim("unchanged")}`);
+
+  // Templates
+  const tmplChanged = changes.templates.filter((f) => f.status === "changed");
+  const tmplNew = changes.templates.filter((f) => f.status === "new");
+  if (tmplChanged.length > 0 || tmplNew.length > 0) {
+    barLn(`  Templates ${dim(`(${tmplChanged.length + tmplNew.length} changed)`)}:`);
+    for (const f of tmplChanged) barLn(`    ${yellow("✦")} ${f.file.replace(/\\/g, "/")}`);
+    for (const f of tmplNew) barLn(`    ${green("+")} ${f.file.replace(/\\/g, "/")} ${dim("(new)")}`);
+  } else {
+    barLn(`  Templates: ${dim("unchanged")}`);
+  }
+  barLn();
+}
+
 // ─── Engine file detection ──────────────────────────────────────────────────
 function detectEngineFiles(vaultPath) {
   const engineDir = path.join(vaultPath, "02_Areas", "Engine");
@@ -967,13 +1144,14 @@ function installTemplateFiles(bundleDir, vaultPath) {
   return count;
 }
 
-function installWorkflows(bundleDir, destDir) {
+function installWorkflows(bundleDir, destDir, selectedWorkflows) {
   const srcDir = path.join(bundleDir, "src", "workflows");
   if (!fs.existsSync(srcDir)) return 0;
 
   fs.mkdirSync(destDir, { recursive: true });
   let count = 0;
   for (const file of fs.readdirSync(srcDir).filter((f) => f.endsWith(".md"))) {
+    if (selectedWorkflows && !selectedWorkflows.has(file)) continue;
     if (linkOrCopy(path.join(srcDir, file), path.join(destDir, file))) count++;
   }
   return count;
@@ -1018,6 +1196,12 @@ function installHooksForClaude(bundleDir, vaultPath) {
     fs.writeFileSync(dst, content, { mode: 0o755 });
     count++;
   }
+  // Copy hook template files (.md)
+  for (const file of fs.readdirSync(hooksSrc).filter((f) => f.endsWith(".md"))) {
+    const dst = path.join(hooksDst, file);
+    fs.copyFileSync(path.join(hooksSrc, file), dst);
+    count++;
+  }
 
   // Deep-merge hooks into existing settings.json (preserve user config)
   const settingsPath = path.join(settingsDir, "settings.json");
@@ -1060,10 +1244,12 @@ function installClaudeCode(bundleDir, vaultPath, skillOpts) {
 
   const claudeDir = path.join(home, ".claude");
   fs.mkdirSync(claudeDir, { recursive: true });
-  if (installRules(bundleDir, path.join(claudeDir, "CLAUDE.md"))) steps.push("rules");
+  if (!skillOpts?.skipRules) {
+    if (installRules(bundleDir, path.join(claudeDir, "CLAUDE.md"))) steps.push("rules");
+  }
 
   const cmdsDir = path.join(claudeDir, "commands");
-  const wfCount = installWorkflows(bundleDir, cmdsDir);
+  const wfCount = installWorkflows(bundleDir, cmdsDir, skillOpts?.workflows);
   if (wfCount > 0) steps.push(`${wfCount} commands`);
 
   if (skillOpts && skillOpts.install) {
@@ -1072,7 +1258,7 @@ function installClaudeCode(bundleDir, vaultPath, skillOpts) {
     if (skCount > 0) steps.push(`${skCount} skills`);
   }
 
-  if (vaultPath) {
+  if (vaultPath && !skillOpts?.skipHooks) {
     const hkCount = installHooksForClaude(bundleDir, vaultPath);
     if (hkCount > 0) steps.push(`${hkCount} hooks`);
   }
@@ -1108,19 +1294,21 @@ function installCursor(bundleDir, vaultPath, skillOpts) {
   const home = os.homedir();
   const steps = [];
 
-  if (vaultPath) {
-    if (installRules(bundleDir, path.join(vaultPath, ".cursorrules"))) steps.push("rules");
-  }
+  if (!skillOpts?.skipRules) {
+    if (vaultPath) {
+      if (installRules(bundleDir, path.join(vaultPath, ".cursorrules"))) steps.push("rules");
+    }
 
-  const cursorRulesDir = path.join(home, ".cursor", "rules");
-  fs.mkdirSync(cursorRulesDir, { recursive: true });
-  const src = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
-  if (fs.existsSync(src)) {
-    fs.copyFileSync(src, path.join(cursorRulesDir, "mover-os.mdc"));
+    const cursorRulesDir = path.join(home, ".cursor", "rules");
+    fs.mkdirSync(cursorRulesDir, { recursive: true });
+    const src = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(cursorRulesDir, "mover-os.mdc"));
+    }
   }
 
   const cmdsDir = path.join(home, ".cursor", "commands");
-  const wfCount = installWorkflows(bundleDir, cmdsDir);
+  const wfCount = installWorkflows(bundleDir, cmdsDir, skillOpts?.workflows);
   if (wfCount > 0) steps.push(`${wfCount} commands`);
 
   if (skillOpts && skillOpts.install) {
@@ -1256,7 +1444,7 @@ function installAntigravity(bundleDir, vaultPath, skillOpts, writtenFiles) {
   }
 
   const wfDir = path.join(geminiDir, "antigravity", "global_workflows");
-  const wfCount = installWorkflows(bundleDir, wfDir);
+  const wfCount = installWorkflows(bundleDir, wfDir, skillOpts?.workflows);
   if (wfCount > 0) steps.push(`${wfCount} workflows`);
 
   if (skillOpts && skillOpts.install) {
@@ -1417,6 +1605,93 @@ async function main() {
     process.exit(1);
   }
 
+  // ── Headless quick update (--update flag) ──
+  if (opts.update) {
+    // Auto-detect vault
+    let vaultPath = opts.vault;
+    if (!vaultPath) {
+      const obsVaults = detectObsidianVaults();
+      vaultPath = obsVaults.find((p) =>
+        fs.existsSync(path.join(p, ".mover-version"))
+      );
+      if (!vaultPath) {
+        outro(red("No Mover OS vault found. Use: npx moveros --update --vault /path"));
+        process.exit(1);
+      }
+    }
+    if (vaultPath.startsWith("~")) vaultPath = path.join(os.homedir(), vaultPath.slice(1));
+    vaultPath = path.resolve(vaultPath);
+    barLn(dim(`Vault: ${vaultPath}`));
+
+    // Auto-detect agents
+    const detectedAgents = AGENTS.filter((a) => a.detect());
+    if (detectedAgents.length === 0) {
+      outro(red("No AI agents detected."));
+      process.exit(1);
+    }
+    const selectedIds = detectedAgents.map((a) => a.id);
+    barLn(dim(`Agents: ${detectedAgents.map((a) => a.name).join(", ")}`));
+    barLn();
+
+    // Detect changes
+    const changes = detectChanges(bundleDir, vaultPath, selectedIds);
+    const totalChanged = countChanges(changes);
+
+    // Read versions
+    const vfPath = path.join(vaultPath, ".mover-version");
+    const installedVer = fs.existsSync(vfPath) ? fs.readFileSync(vfPath, "utf8").trim() : null;
+    let newVer = `V${VERSION}`;
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(bundleDir, "package.json"), "utf8"));
+      newVer = pkg.version || newVer;
+    } catch {}
+
+    displayChangeSummary(changes, installedVer, newVer);
+
+    if (totalChanged === 0) {
+      outro(green("Already up to date."));
+      return;
+    }
+
+    // Apply all changes
+    barLn(bold("Updating..."));
+    barLn();
+    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+    // Vault structure
+    createVaultStructure(vaultPath);
+
+    // Templates
+    installTemplateFiles(bundleDir, vaultPath);
+
+    // Per-agent installation
+    const writtenFiles = new Set();
+    const skillOpts = { install: true, categories: null, workflows: null };
+    for (const agent of detectedAgents) {
+      const fn = AGENT_INSTALLERS[agent.id];
+      if (!fn) continue;
+      const sp = spinner(agent.name);
+      const usesWrittenFiles = agent.id === "antigravity" || agent.id === "gemini-cli";
+      const steps = usesWrittenFiles
+        ? fn(bundleDir, vaultPath, skillOpts, writtenFiles)
+        : fn(bundleDir, vaultPath, skillOpts);
+      await sleep(200);
+      if (steps.length > 0) {
+        sp.stop(`${agent.name}  ${dim(steps.join(", "))}`);
+      } else {
+        sp.stop(`${agent.name}  ${dim("configured")}`);
+      }
+    }
+
+    // Update version marker
+    fs.writeFileSync(path.join(vaultPath, ".mover-version"), `V${VERSION}\n`, "utf8");
+
+    barLn();
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+    outro(`${green("Done.")} ${totalChanged} files updated in ${elapsed}s. Run ${bold("/update")} if version bumped.`);
+    return;
+  }
+
   // ── License key ──
   let key = opts.key;
 
@@ -1462,26 +1737,45 @@ async function main() {
   let vaultPath = opts.vault;
 
   if (!vaultPath) {
-    const candidates = [
-      path.join(os.homedir(), "Documents", "Obsidian"),
-      path.join(os.homedir(), "Obsidian"),
-      path.join(os.homedir(), "Documents", "Mover-OS"),
-    ];
+    const obsVaults = detectObsidianVaults();
 
-    const detected = candidates.find((p) => {
-      try {
-        return fs.existsSync(p) && (fs.existsSync(path.join(p, ".obsidian")) || fs.existsSync(path.join(p, "02_Areas")));
-      } catch {
-        return false;
-      }
-    });
+    if (obsVaults.length > 0) {
+      question("Select your Obsidian vault");
+      barLn();
+
+      const vaultItems = obsVaults.map((p) => {
+        const name = path.basename(p);
+        const hasMover =
+          fs.existsSync(path.join(p, ".mover-version")) ||
+          fs.existsSync(path.join(p, "02_Areas", "Engine"));
+        return {
+          id: p,
+          name: `${name}${hasMover ? dim("  (Mover OS)") : ""}`,
+          tier: dim(p),
+        };
+      });
+      vaultItems.push({
+        id: "__manual__",
+        name: "Enter path manually",
+        tier: "Type or paste a custom vault path",
+      });
 
-    const defaultPath = detected || path.join(os.homedir(), "Mover-OS");
+      const selected = await interactiveSelect(vaultItems, { multi: false });
 
-    vaultPath = await textInput({
-      label: `Where is your Obsidian vault?${detected ? dim("  (detected)") : ""}`,
-      initial: defaultPath,
-    });
+      if (selected === "__manual__") {
+        vaultPath = await textInput({
+          label: "Where is your Obsidian vault?",
+          initial: path.join(os.homedir(), "Mover-OS"),
+        });
+      } else {
+        vaultPath = selected;
+      }
+    } else {
+      vaultPath = await textInput({
+        label: "Where is your Obsidian vault?",
+        initial: path.join(os.homedir(), "Mover-OS"),
+      });
+    }
   } else {
     barLn(dim(`Vault: ${vaultPath}`));
     barLn();
@@ -1709,6 +2003,102 @@ async function main() {
     process.exit(0);
   }
 
+  // ── Change detection + selection (update mode only) ──
+  let selectedWorkflows = null; // null = install all
+  let skipHooks = false;
+  let skipRules = false;
+  let skipTemplates = false;
+
+  if (updateMode) {
+    const changes = detectChanges(bundleDir, vaultPath, selectedIds);
+    const totalChanged = countChanges(changes);
+
+    // Read versions for display
+    const versionFilePath = path.join(vaultPath, ".mover-version");
+    const installedVersion = fs.existsSync(versionFilePath)
+      ? fs.readFileSync(versionFilePath, "utf8").trim()
+      : null;
+    let newVersion = `V${VERSION}`;
+    try {
+      const pkgPath = path.join(bundleDir, "package.json");
+      if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        newVersion = pkg.version || newVersion;
+      }
+    } catch {}
+
+    barLn();
+    question("Change Summary");
+    barLn();
+    displayChangeSummary(changes, installedVersion, newVersion);
+
+    if (totalChanged === 0) {
+      barLn(green("  Already up to date."));
+      barLn();
+    } else {
+      const applyChoice = await interactiveSelect(
+        [
+          { id: "all", name: "Yes, update all changed files", tier: "" },
+          { id: "select", name: "Select individually", tier: "" },
+          { id: "cancel", name: "Cancel", tier: "" },
+        ],
+        { multi: false, defaultIndex: 0 }
+      );
+
+      if (applyChoice === "cancel") {
+        outro("Cancelled.");
+        process.exit(0);
+      }
+
+      if (applyChoice === "select") {
+        // Build list of only changed/new files for individual selection
+        const changedItems = [];
+        const changedPreSelected = [];
+        for (const f of changes.workflows.filter((x) => x.status !== "unchanged")) {
+          const id = `wf:${f.file}`;
+          changedItems.push({ id, name: `/${f.file.replace(".md", "")}`, tier: dim(f.status === "new" ? "new workflow" : "workflow") });
+          changedPreSelected.push(id);
+        }
+        for (const f of changes.hooks.filter((x) => x.status !== "unchanged")) {
+          const id = `hook:${f.file}`;
+          changedItems.push({ id, name: f.file, tier: dim(f.status === "new" ? "new hook" : "hook") });
+          changedPreSelected.push(id);
+        }
+        if (changes.rules === "changed") {
+          changedItems.push({ id: "rules", name: "Global Rules", tier: dim("rules") });
+          changedPreSelected.push("rules");
+        }
+        for (const f of changes.templates.filter((x) => x.status !== "unchanged")) {
+          const id = `tmpl:${f.file}`;
+          changedItems.push({ id, name: f.file.replace(/\\/g, "/"), tier: dim(f.status === "new" ? "new template" : "template") });
+          changedPreSelected.push(id);
+        }
+
+        if (changedItems.length > 0) {
+          question("Select files to update");
+          barLn();
+          const selectedFileIds = await interactiveSelect(changedItems, {
+            multi: true,
+            preSelected: changedPreSelected,
+          });
+
+          // Build workflow filter Set
+          const selectedWfFiles = selectedFileIds
+            .filter((id) => id.startsWith("wf:"))
+            .map((id) => id.slice(3));
+          if (selectedWfFiles.length < changes.workflows.filter((x) => x.status !== "unchanged").length) {
+            selectedWorkflows = new Set(selectedWfFiles);
+          }
+          // Check if hooks/rules/templates were deselected
+          skipHooks = !selectedFileIds.some((id) => id.startsWith("hook:"));
+          skipRules = !selectedFileIds.includes("rules");
+          skipTemplates = !selectedFileIds.some((id) => id.startsWith("tmpl:"));
+        }
+      }
+      // "all" = selectedWorkflows stays null, skip flags stay false
+    }
+  }
+
   // ── Skills ──
   const allSkills = findSkills(bundleDir);
   let installSkills = false;
@@ -1800,13 +2190,15 @@ async function main() {
   totalSteps++;
 
   // 2. Template files (runs in both modes — only creates missing files, never overwrites)
-  sp = spinner(updateMode ? "New template files" : "Engine templates");
-  const templatesInstalled = installTemplateFiles(bundleDir, vaultPath);
-  await sleep(200);
-  sp.stop(updateMode
-    ? `New template files${templatesInstalled > 0 ? dim(`  ${templatesInstalled} added`) : dim("  all present")}`
-    : `Engine templates${templatesInstalled > 0 ? dim(`  ${templatesInstalled} files`) : dim("  up to date")}`);
-  totalSteps++;
+  if (!skipTemplates) {
+    sp = spinner(updateMode ? "New template files" : "Engine templates");
+    const templatesInstalled = installTemplateFiles(bundleDir, vaultPath);
+    await sleep(200);
+    sp.stop(updateMode
+      ? `New template files${templatesInstalled > 0 ? dim(`  ${templatesInstalled} added`) : dim("  all present")}`
+      : `Engine templates${templatesInstalled > 0 ? dim(`  ${templatesInstalled} files`) : dim("  up to date")}`);
+    totalSteps++;
+  }
 
   // 3. CLAUDE.md (skip on update)
   if (!updateMode) {
@@ -1823,7 +2215,7 @@ async function main() {
 
   // 4. Per-agent installation
   const writtenFiles = new Set(); // Track shared files to avoid double-writes (e.g. GEMINI.md)
-  const skillOpts = { install: installSkills, categories: selectedCategories, statusLine: installStatusLine };
+  const skillOpts = { install: installSkills, categories: selectedCategories, statusLine: installStatusLine, workflows: selectedWorkflows, skipHooks, skipRules, skipTemplates };
   for (const agent of selectedAgents) {
     const fn = AGENT_INSTALLERS[agent.id];
     if (!fn) continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moveros",
-  "version": "4.1.1",
+  "version": "4.1.2",
   "description": "The self-improving OS for AI agents. Turns Obsidian into an execution engine.",
   "bin": {
     "moveros": "install.js"

package/src/hooks/background-log-prompt.md

@@ -0,0 +1,42 @@
+You are a session logger for Mover OS. Process this session log entry.
+
+Timestamps: current={{CURRENT_TS}}, pre-compaction={{COMPACT_TS}}.
+Session backup: {{SUMMARY_PATH}}
+Working directory: {{WORKING_DIR}}
+Project: {{PROJECT_NAME}}
+
+## Steps
+
+0. Read the log workflow at: {{LOG_WORKFLOW}}
+   Use Step 4 for session log FORMAT, Step 6C for System State Snapshot FORMAT (metadata header + narrative paragraph). Follow these formats exactly.
+
+1. Read the session backup summary at the path above.
+
+2. Read the Daily Note at: {{DAILY_NOTE}}
+   If it does not exist, create it with a basic template.
+   Find the `## Session Log` section. Insert the new entry WITHIN that section (not at end of file).
+   Mark as [COMPACTED].
+   Format: `### Session Log [ATTENDED] — ~HH:MM-HH:MM [Claude Code] [{{PROJECT_NAME}}] [COMPACTED]`
+   Then subsections with ~timestamps and 3-4 line descriptions.
+
+3. If plan.md exists at: {{PLAN_MD}}
+   Read it, mark completed tasks [~] (NOT [x]) with [UNVERIFIED] tag, append to EXECUTION LOG.
+   The [~] means "code written, not yet verified." Only /morning or the user promotes to [x].
+
+4. If project_state.md exists at: {{PROJECT_STATE}}
+   Append new Solutions Ledger entries (deduplicate first), Changelog entry, and System State Snapshot.
+   Snapshot format: structured metadata (Mode, Focus, Risk, Next Milestone, Blocker) AND a narrative paragraph (8-12 sentences). See log.md Step 6C.
+
+5. Read Active_Context at: {{ACTIVE_CONTEXT}}
+   Prepend 1-line summary to Active Sessions (keep 5 max, remove oldest).
+   Update log_last_run to {{CURRENT_TS}}.
+
+6. Git commit changed files if inside a repo.
+   Git add specific files only. Never git add . at root. Never commit Dailies.
+
+## Constraints
+
+- Append-only (never delete)
+- Cite sources
+- Mark entries [COMPACTED]
+- Windows: no && in commands

package/src/hooks/session-log-reminder.sh

@@ -58,8 +58,6 @@ if [ -f "$PENDING_FILE" ]; then
       COMPACT_TS=$(grep '^\*\*Timestamp:\*\*' "$SUMMARY_PATH" 2>/dev/null | sed 's/\*\*Timestamp:\*\* //')
     fi
     CURRENT_TS=$(date '+%Y-%m-%dT%H:%M')
-    CURRENT_DATE=$(date '+%Y-%m-%d')
-    CURRENT_MONTH=$(date '+%Y-%m')
     WORKING_DIR=$(pwd)
 
     # Resolve vault root: walk up from working dir looking for 02_Areas/Engine/
@@ -73,9 +71,36 @@ if [ -f "$PENDING_FILE" ]; then
       CHECK_DIR=$(dirname "$CHECK_DIR")
     done
 
+    # Determine which daily note to use:
+    # Use pre-compaction date (session date), NOT wall-clock time.
+    # This prevents 1am sessions from creating a new day's note.
+    SESSION_DATE=""
+    if [ -n "$COMPACT_TS" ]; then
+      SESSION_DATE=$(echo "$COMPACT_TS" | grep -oE '[0-9]{4}-[0-9]{2}-[0-9]{2}')
+    fi
+    # Fallback: find the latest existing daily note
+    if [ -z "$SESSION_DATE" ]; then
+      DAILIES_DIR="${VAULT_ROOT}/02_Areas/Engine/Dailies"
+      if [ -d "$DAILIES_DIR" ]; then
+        LATEST_NOTE=$(find "$DAILIES_DIR" -name "Daily - *.md" -type f 2>/dev/null | sort -r | head -1)
+        if [ -n "$LATEST_NOTE" ]; then
+          SESSION_DATE=$(echo "$LATEST_NOTE" | grep -oE '[0-9]{4}-[0-9]{2}-[0-9]{2}')
+        fi
+      fi
+    fi
+    # Final fallback: use current date
+    if [ -z "$SESSION_DATE" ]; then
+      SESSION_DATE=$(date '+%Y-%m-%d')
+    fi
+    SESSION_MONTH=$(echo "$SESSION_DATE" | cut -c1-7)
+
     # Derive key file paths
-    DAILY_NOTE="${VAULT_ROOT}/02_Areas/Engine/Dailies/${CURRENT_MONTH}/Daily - ${CURRENT_DATE}.md"
+    DAILY_NOTE="${VAULT_ROOT}/02_Areas/Engine/Dailies/${SESSION_MONTH}/Daily - ${SESSION_DATE}.md"
     ACTIVE_CONTEXT="${VAULT_ROOT}/02_Areas/Engine/Active_Context.md"
+    LOG_WORKFLOW="$HOME/.claude/commands/log.md"
+    if [ ! -f "$LOG_WORKFLOW" ]; then
+      LOG_WORKFLOW="${VAULT_ROOT}/01_Projects/Mover OS Bundle/src/workflows/log.md"
+    fi
 
     # Detect project context (if inside 01_Projects/[Name]/)
     PROJECT_NAME=""
@@ -98,7 +123,32 @@ if [ -f "$PENDING_FILE" ]; then
         ;;
     esac
 
-    echo "{\"decision\":\"block\",\"reason\":\"POST-COMPACTION BACKGROUND LOG: Context was just compacted. Instead of running the full /log workflow (which fills your context and causes more compactions), spawn a BACKGROUND Task agent to handle it. Do this: 1. Write a brief summary of what was worked on this session (from your compacted context — you have the conversation summary). 2. Spawn: Task tool with subagent_type='general-purpose', model='sonnet', run_in_background=true. 3. In the Task prompt, include: (a) your session context summary, (b) instructions below. 4. Mark session as logged: echo done > /tmp/mover_logdone_${SESSION_KEY}. 5. Continue with whatever you were doing. INSTRUCTIONS FOR THE BACKGROUND AGENT: You are a session logger for Mover OS. Process this session log entry. Timestamps: current=${CURRENT_TS}, pre-compaction=${COMPACT_TS:-unknown}. Session backup summary: ${SUMMARY_PATH}. Working directory: ${WORKING_DIR}. Project: ${PROJECT_NAME:-none}. STEPS: (1) Read the session backup summary at the path above. (2) Read the Daily Note at: ${DAILY_NOTE} — if it does not exist, create it with a basic template. Append a session log entry under '## Session Log' marked [COMPACTED]. Format: '### Session Log [ATTENDED] — ~HH:MM-HH:MM [Claude Code] [${PROJECT_NAME:-Unknown}] [COMPACTED]' then subsections with ~timestamps and 3-4 line descriptions. (3) If plan.md exists at: ${PLAN_MD:-N/A} — read it, mark completed tasks [x], append to EXECUTION LOG. (4) If project_state.md exists at: ${PROJECT_STATE:-N/A} — append new Solutions Ledger entries (deduplicate first), Changelog entry, System State Snapshot. (5) Read Active_Context at: ${ACTIVE_CONTEXT} — prepend 1-line summary to Active Sessions (keep 5 max, remove oldest), update log_last_run to ${CURRENT_TS}. (6) Git commit changed files if inside a repo (git add specific files only, never git add . at root, never commit Dailies). CONSTRAINTS: append-only (never delete), cite sources, mark entries [COMPACTED], Windows=no && in commands.\"}"
+    # Load instructions from template file (keeps this script readable)
+    PROMPT_TEMPLATE="$HOME/.claude/hooks/background-log-prompt.md"
+    if [ ! -f "$PROMPT_TEMPLATE" ]; then
+      PROMPT_TEMPLATE="${VAULT_ROOT}/01_Projects/Mover OS Bundle/src/hooks/background-log-prompt.md"
+    fi
+    if [ -f "$PROMPT_TEMPLATE" ]; then
+      AGENT_INSTRUCTIONS=$(sed \
+        -e "s|{{CURRENT_TS}}|${CURRENT_TS}|g" \
+        -e "s|{{COMPACT_TS}}|${COMPACT_TS:-unknown}|g" \
+        -e "s|{{SUMMARY_PATH}}|${SUMMARY_PATH}|g" \
+        -e "s|{{WORKING_DIR}}|${WORKING_DIR}|g" \
+        -e "s|{{PROJECT_NAME}}|${PROJECT_NAME:-Unknown}|g" \
+        -e "s|{{DAILY_NOTE}}|${DAILY_NOTE}|g" \
+        -e "s|{{PLAN_MD}}|${PLAN_MD:-N/A}|g" \
+        -e "s|{{PROJECT_STATE}}|${PROJECT_STATE:-N/A}|g" \
+        -e "s|{{ACTIVE_CONTEXT}}|${ACTIVE_CONTEXT}|g" \
+        -e "s|{{LOG_WORKFLOW}}|${LOG_WORKFLOW}|g" \
+        "$PROMPT_TEMPLATE" | tr '\n' ' ')
+    else
+      AGENT_INSTRUCTIONS="Session logger: read ${SUMMARY_PATH}, update Daily Note at ${DAILY_NOTE}, update project_state at ${PROJECT_STATE:-N/A}, update Active_Context at ${ACTIVE_CONTEXT}. Append-only. Mark [COMPACTED]."
+    fi
+
+    # Escape double quotes for JSON
+    AGENT_INSTRUCTIONS=$(echo "$AGENT_INSTRUCTIONS" | sed 's/"/\\"/g')
+
+    echo "{\"decision\":\"block\",\"reason\":\"POST-COMPACTION BACKGROUND LOG: Context was just compacted. Spawn a BACKGROUND Task agent (subagent_type=general-purpose, model=sonnet, run_in_background=true) with your session context summary + the instructions below. Then mark as logged: echo done > /tmp/mover_logdone_${SESSION_KEY}. Continue with your work. INSTRUCTIONS: ${AGENT_INSTRUCTIONS}\"}"
     exit 0
   fi
 fi
@@ -131,5 +181,5 @@ if [ -n "$TRANSCRIPT" ] && [ -f "$TRANSCRIPT" ]; then
   fi
 fi
 
-echo '{"decision":"block","reason":"SESSION REMINDER: Ask the user (one sentence) if they want you to run /log to capture the session. Then continue with your response."}'
+echo '{"decision":"block","reason":"SESSION REMINDER: In ONE sentence, ask the user if they would like to run /log before ending. Do NOT run /log automatically. Do NOT use the Skill tool. Just ask the question and continue with your normal response."}'
 exit 0

package/src/structure/01_Projects/_Template Project/project_state.md

@@ -1,19 +1,24 @@
-#  PROJECT STATE: [Project Name]
-*Status: [Status e.g., Planning]*
-
-## 1. THE BRAIN DUMP (Notes)
-*   **Mission:** [What are we doing?]
-*   **Current Blocker:** [What is stopping us?]
-
-## 2. THE SOLUTIONS LEDGER
-*   **[Topic]:** [Problem] -> [Solution]
-
-## 3. CHANGELOG
-*   [YYYY-MM-DD] Project Initialized -> Template copied.
-
-## 4. SYSTEM STATE SNAPSHOTS
-*   **Latest Snapshot:** [YYYY-MM-DD]
-*   **Current Mode:** [e.g., Planning, Execution]
-*   **Active Focus:** [What is the one thing we are doing?]
-*   **Risk Profile:** [Low/High]
-*   **Next Milestone:** [What is the next big win?]
+#  PROJECT STATE: [Project Name]
+*Status: [Status e.g., Planning]*
+
+## 1. THE BRAIN DUMP (Notes)
+*   **Mission:** [What are we doing?]
+*   **Current Blocker:** [What is stopping us?]
+
+## 2. THE SOLUTIONS LEDGER
+*   **[Topic]:** [Problem] -> [Solution]
+
+## 3. CHANGELOG
+*   [YYYY-MM-DD] Project Initialized -> Template copied.
+
+## 4. SYSTEM STATE SNAPSHOTS
+
+### [YYYY-MM-DD HH:MM] Snapshot
+- **Mode:** [Planning / Execution / Debugging]
+- **Focus:** [Current primary task]
+- **Risk:** [Low / Medium / High / Critical]
+- **Next Milestone:** [What's next]
+- **Blocker:** [What's blocking, or None]
+
+**Narrative:** [8-12 sentences. What changed, why, what unblocked,
+what's next. Concrete and direct.]

package/src/system/Mover_Global_Rules.md

@@ -328,17 +328,19 @@ You are the guardian of `plan.md`.
 - **Read-First:** Your memory is `plan.md`. Read it before acting.
 - **Append-Only:** FORBIDDEN from deleting history/completed tasks.
 - **Real-Time Sync:** After task completion:
-  1. Mark `[x]` in `plan.md`
-  2. Append to `## EXECUTION LOG`: `* [YYYY-MM-DD] {Task} - {Result}`
+  1. Mark `[~]` in `plan.md` with `[UNVERIFIED]` tag
+  2. Append to `## EXECUTION LOG`: `* [YYYY-MM-DD] {Task} - {Result} [UNVERIFIED]`
   3. Suggest Git commit
 
+  `[~]` means "code written, not yet verified working." Only `/morning` or user promotes to `[x]`.
+
 **Passive Detection Protocol (Always Active):**
 
 These triggers fire during EVERY conversation, not just workflows. **DETECT > WRITE > CONTINUE.** Don't ask. Don't announce. Write the entry, then continue the conversation.
 
 | Trigger | What to detect | Where to write |
 |---------|---------------|---------------|
-| User reports action | "I did it", "just finished", "sent it", "got back from" | Daily Note `## Log` + mark `[x]` in plan.md if applicable |
+| User reports action | "I did it", "just finished", "sent it", "got back from" | Daily Note `## Log` + mark `[~] [UNVERIFIED]` in plan.md if applicable |
 | Decision made | "Let's go with X", "I've decided", agreement on direction | Relevant file (plan.md, project_state.md, Active_Context) |
 | Commitment made | "I'll send", "I promised", "by Friday" | Active_Context `## 8.5 COMMITMENTS` |
 | Waiting on someone | "He said he'd", "waiting on", "they'll get back to me" | Active_Context `## 3.5 WAITING FOR` |

package/src/workflows/analyse-day.md

@@ -20,6 +20,17 @@ description: End-of-day analysis. Reads Session Log, audits strategy, updates Da
 
 Global Rules are pre-loaded as CLAUDE.md / GEMINI.md. Output `[Rules Loaded - DATE]`.
 
+GET CURRENT TIME:
+```bash
+date '+%Y-%m-%d %H:%M'
+```
+Save as CURRENT_TIME. Extract the hour.
+
+DETERMINE "TODAY" (session-aware date logic):
+- If the hour is **before 05:00** (midnight-5am): the user is still on "yesterday." Find and analyse YESTERDAY's Daily Note, not today's. The analysis belongs to the day that was lived, not the clock date.
+- If the hour is **05:00 or later**: analyse today's Daily Note as normal.
+- Save the resolved date as ANALYSE_DATE. Use this for all Daily Note lookups.
+
 LOAD (Memory Hierarchy):
 1. Auto_Learnings.md (P0)
 2. Active_Context.md (P1)

package/src/workflows/log.md

@@ -33,7 +33,13 @@ pwd
 ```
 Save as WORKING_DIR. Extract project name: if inside `01_Projects/[Name]/`, capture `[Name]`. Otherwise use the directory basename.
 
-DAILY NOTE PATH (derive from SESSION_END_TIME):
+DETERMINE SESSION DATE (session-aware, not wall-clock):
+- Extract the hour from SESSION_END_TIME.
+- If before **05:00** (midnight-5am): the session belongs to YESTERDAY. Use yesterday's date for the Daily Note.
+- If **05:00 or later**: use today's date.
+- Save as SESSION_DATE.
+
+DAILY NOTE PATH (derive from SESSION_DATE):
 ```
 {VAULT_ROOT}/02_Areas/Engine/Dailies/YYYY-MM/Daily - YYYY-MM-DD.md
 ```
@@ -164,9 +170,10 @@ If no Daily Note exists: output the Session Log in chat for the user to paste.
 
 **Target:** Active project's `plan.md`
 
-1. Mark completed tasks with `[x]`.
+1. Mark completed tasks with `[~]` and `[UNVERIFIED]` tag (NOT `[x]`).
+   `[~]` means "code written, not yet verified." Only `/morning` or user promotes to `[x]`.
 2. Append to `## EXECUTION LOG`:
-   `* [YYYY-MM-DD] {Task} - {Result with context}`
+   `* [YYYY-MM-DD] {Task} - {Result with context} [UNVERIFIED]`
    Include failure context: "Failed with Error X, fixed with Y".
 3. Do NOT rewrite the roadmap. Do NOT delete any lines.
 
@@ -202,9 +209,14 @@ APPEND (never overwrite) a new snapshot:
 
 ```markdown
 ### [YYYY-MM-DD HH:MM] Snapshot
-**Narrative:** [8-20 sentence story of what was improved, fixed, changed.
-Describe the friction and the breakthrough. Be visceral. Merge all
-context into the narrative, not bullet points.]
+- **Mode:** [Planning / Execution / Debugging]
+- **Focus:** [Current primary task]
+- **Risk:** [Low / Medium / High / Critical]
+- **Next Milestone:** [What's next]
+- **Blocker:** [What's blocking, or None]
+
+**Narrative:** [8-12 sentences. What changed, why, what unblocked,
+what's next. Concrete and direct.]
 ```
 
 If no project_state.md in scope: skip this step.

package/src/workflows/morning.md

@@ -99,6 +99,23 @@ Keep this under 30 seconds. Use file modification dates, not full reads. Delegat
 
 ---
 
+## 2.6 VERIFICATION CHECK (Promote Unverified Tasks)
+
+If a project context is active (user is inside a project directory, or today's plan references a project):
+1. Find the active project's `plan.md`
+2. Scan for tasks marked `[~]` with `[UNVERIFIED]` tag
+
+If found:
+- List them: "Last session marked these as done but unverified:"
+  - `[~] Task description [UNVERIFIED]`
+- Ask: "Confirm these are working? (yes / list issues)"
+- If confirmed: promote all to `[x]`, remove `[UNVERIFIED]` tag, append to EXECUTION LOG: `* [YYYY-MM-DD] Verified: [task list]`
+- If issues listed: keep as `[~]`, add issue note to task line, surface in today's plan as priority
+
+If no `[~]` items found: skip silently.
+
+---
+
 ## 2.7 PLAN ALIGNMENT CHECK (Escalating Friction — Level 1)
 
 If today's Daily Note exists:

package/src/workflows/plan-tomorrow.md

@@ -18,6 +18,19 @@ description: Generates the Daily Note for the next day based on Strategy, previo
 
 Global Rules are pre-loaded as CLAUDE.md / GEMINI.md. Output `[Rules Loaded - DATE]`.
 
+GET CURRENT TIME:
+```bash
+date '+%Y-%m-%d %H:%M'
+```
+Save as CURRENT_TIME. Extract the hour.
+
+DETERMINE "TODAY" (session-aware date logic):
+- If the hour is **before 05:00** (midnight-5am): the user is still on "yesterday" in their mind. Check if a Daily Note exists for yesterday's date. If yes, treat YESTERDAY as "today" for planning purposes. "Tomorrow" = the current calendar date.
+- If the hour is **05:00 or later**: treat the current calendar date as "today." "Tomorrow" = current date + 1.
+- **Rule:** Only `/plan-tomorrow` creates new Daily Notes. The note it creates is always for the NEXT waking day. Never create a note for the day after that.
+
+Save the resolved dates as TODAY_DATE and TOMORROW_DATE.
+
 LOAD (Memory Hierarchy):
 1. Auto_Learnings.md (P0)
 2. Active_Context.md (P1)