dotmd-cli 0.46.0 → 0.48.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotmd-cli",
-  "version": "0.46.0",
+  "version": "0.48.0",
   "description": "CLI for managing markdown documents with YAML frontmatter — index, query, validate, graph, export, Notion sync, AI summaries.",
   "type": "module",
   "license": "MIT",

package/src/config.mjs

@@ -58,6 +58,10 @@ const DEFAULTS = {
     skipStaleFor: ['archived', 'reference', 'partial', 'queued-after'],
     skipWarningsFor: ['archived', 'partial', 'queued-after'],
     terminalStatuses: ['archived', 'deprecated', 'reference'],
+    // F15: opt-in per-status `{ filed: true }` in `types.<type>.statuses`
+    // populates this map (status → dirName). Empty by default — archive: true
+    // remains a separate primitive untouched.
+    filedStatuses: {},
   },
 
   taxonomy: {
@@ -126,6 +130,12 @@ function normalizeRichStatuses(config, userConfig) {
     skipWarningsFor: [],
     terminalStatuses: [],
     moduleRequiredFor: [],
+    // F15: status-name → directory-name (defaults to the status name verbatim).
+    // Filed statuses move docs into <root>/<dirName>/ on transition INTO the
+    // status, and back to flat <root>/ on transition OUT. Separate from
+    // archive: true to avoid touching that long-standing primitive's
+    // semantics.
+    filedStatuses: {},
     staleDays: {},
     statusOrder: [],
     context: { expanded: [], listed: [], counted: [] },
@@ -177,6 +187,11 @@ function normalizeRichStatuses(config, userConfig) {
       if ((p.skipWarnings || quietImpliesSkipWarnings) && !derived.skipWarningsFor.includes(name)) derived.skipWarningsFor.push(name);
       if (p.terminal && !derived.terminalStatuses.includes(name)) derived.terminalStatuses.push(name);
       if (p.requiresModule && !derived.moduleRequiredFor.includes(name)) derived.moduleRequiredFor.push(name);
+      if (p.filed && !derived.filedStatuses[name]) {
+        // dirName defaults to the status name; users can override with
+        // `filed: 'custom-dir'` (string form) instead of `filed: true`.
+        derived.filedStatuses[name] = typeof p.filed === 'string' ? p.filed : name;
+      }
 
       if (!derived.statusOrder.includes(name)) derived.statusOrder.push(name);
     }
@@ -222,6 +237,9 @@ function applyDerivedConfig(config, userConfig, derived) {
   if (!userConfig.lifecycle?.terminalStatuses && derived.terminalStatuses.length) {
     config.lifecycle.terminalStatuses = derived.terminalStatuses;
   }
+  if (!userConfig.lifecycle?.filedStatuses && Object.keys(derived.filedStatuses).length) {
+    config.lifecycle.filedStatuses = derived.filedStatuses;
+  }
 
   // taxonomy.moduleRequiredFor
   if (!userConfig.taxonomy?.moduleRequiredFor && derived.moduleRequiredFor.length) {
@@ -442,6 +460,9 @@ export async function resolveConfig(cwd, explicitConfigPath) {
   const skipStaleFor = new Set(lifecycle.skipStaleFor);
   const skipWarningsFor = new Set(lifecycle.skipWarningsFor);
   const terminalStatuses = new Set(lifecycle.terminalStatuses);
+  // F15: filedStatuses keyed by status name, value = directory name. Empty
+  // object when no status opts in via `filed: true` (or `filed: '<dirname>'`).
+  const filedStatuses = new Map(Object.entries(lifecycle.filedStatuses ?? {}));
 
   // Warn if rootStatuses keys don't match any configured root
   for (const rootKey of Object.keys(rootStatusesRaw)) {
@@ -473,7 +494,7 @@ export async function resolveConfig(cwd, explicitConfigPath) {
     rootValidStatuses,
     staleDaysByStatus,
 
-    lifecycle: { archiveStatuses, skipStaleFor, skipWarningsFor, terminalStatuses },
+    lifecycle: { archiveStatuses, skipStaleFor, skipWarningsFor, terminalStatuses, filedStatuses },
 
     validSurfaces,
     moduleRequiredStatuses,

package/src/hud.mjs

@@ -1,12 +1,13 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import path from 'node:path';
-import { readLeases, findStaleLeases, currentSessionId } from './lease.mjs';
+import { readLeases, findStaleLeases, currentSessionId, isLeaseStale, STALE_LEASE_AGE_MS } from './lease.mjs';
 import { scrubStaleSilently } from './lease-scrub.mjs';
 import { extractFrontmatter, parseSimpleFrontmatter } from './frontmatter.mjs';
 import { asString, toRepoPath } from './util.mjs';
-import { dim } from './color.mjs';
+import { dim, yellow } from './color.mjs';
 import { buildIndex } from './index.mjs';
 import { refreshStaleSlashCommands } from './claude-commands.mjs';
+import { readJournalEntries, journalFilePath } from './journal.mjs';
 
 const MAX_PREVIEW = 5;
 
@@ -67,6 +68,121 @@ function findActionablePrompts(config) {
   return found.sort();
 }
 
+// F17b: hud reads journal. Three additive sections, gated on
+// existsSync(journalFilePath). Silent-when-clean — sections are omitted when
+// they have nothing to say. Caps keep hud single-screen even when the journal
+// is dense.
+
+const PREVIOUS_SELF_CAP = 3;
+const FLEET_CAP = 5;
+const REJECTIONS_CAP = 3;
+const FLEET_WINDOW_MS = 24 * 60 * 60 * 1000;
+const REJECTIONS_WINDOW_MS = 60 * 60 * 1000;
+
+function relTime(ts, now = Date.now()) {
+  const t = new Date(ts).getTime();
+  if (!Number.isFinite(t)) return '?';
+  const delta = Math.max(0, now - t);
+  const sec = Math.floor(delta / 1000);
+  if (sec < 60) return `${sec}s ago`;
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min}m ago`;
+  const hr = Math.floor(min / 60);
+  if (hr < 24) return `${hr}h ago`;
+  return `${Math.floor(hr / 24)}d ago`;
+}
+
+// Coarse error-class for rejection grouping. Most dotmd die() messages follow
+// `<class>: <variable detail>` (e.g. "File not found: docs/foo.md", "Already
+// archived: docs/plans/x.md", "Too many arguments to status"). Take the chunk
+// before the first colon, cap at 6 words, normalize whitespace. Cheap;
+// good-enough until a proper taxonomy emerges from real journal data.
+function errorClass(err) {
+  if (typeof err !== 'string') return '';
+  const flat = err.replace(/\s+/g, ' ').trim();
+  if (!flat) return '';
+  const prefix = flat.split(':')[0];
+  return prefix.split(' ').slice(0, 6).join(' ');
+}
+
+export function buildJournalSections(config, now = Date.now()) {
+  const journalFile = journalFilePath(config);
+  if (!existsSync(journalFile)) return { previousSelf: [], fleet: [], recentRejections: [] };
+
+  let entries;
+  try { entries = readJournalEntries(config); }
+  catch { return { previousSelf: [], fleet: [], recentRejections: [] }; }
+  if (!entries.length) return { previousSelf: [], fleet: [], recentRejections: [] };
+
+  const sid = currentSessionId();
+  const leases = readLeases(config);
+  const leaseBySession = new Map();
+  for (const lease of Object.values(leases)) {
+    if (!lease?.session) continue;
+    if (!leaseBySession.has(lease.session)) leaseBySession.set(lease.session, []);
+    leaseBySession.get(lease.session).push(lease);
+  }
+
+  // 1. Previous self: this sid's last N entries (excluding the current
+  // invocation, which is recorded only at process exit so it isn't in the
+  // file yet). Newest-first.
+  const previousSelf = entries
+    .filter(e => e?.sid === sid)
+    .slice(-PREVIOUS_SELF_CAP)
+    .reverse()
+    .map(e => ({
+      argv: Array.isArray(e.argv) ? e.argv : [],
+      exit: e.exit ?? 0,
+      ts: e.ts,
+      ago: relTime(e.ts, now),
+    }));
+
+  // 2. Fleet: per-other-sid summary for entries in the last 24h.
+  const fleetCutoff = now - FLEET_WINDOW_MS;
+  const bySid = new Map();
+  for (const e of entries) {
+    if (!e?.sid || e.sid === sid) continue;
+    const t = new Date(e.ts).getTime();
+    if (!Number.isFinite(t) || t < fleetCutoff) continue;
+    if (!bySid.has(e.sid)) bySid.set(e.sid, { count: 0, lastTs: 0 });
+    const row = bySid.get(e.sid);
+    row.count++;
+    if (t > row.lastTs) row.lastTs = t;
+  }
+  const fleet = [...bySid.entries()].map(([otherSid, row]) => {
+    const myLeases = leaseBySession.get(otherSid) ?? [];
+    const stalest = myLeases.find(isLeaseStale);
+    return {
+      sid: otherSid,
+      cmds: row.count,
+      lastAgo: relTime(new Date(row.lastTs).toISOString(), now),
+      holding: myLeases.map(l => l.path),
+      stale: Boolean(stalest),
+    };
+  }).sort((a, b) => b.cmds - a.cmds).slice(0, FLEET_CAP);
+
+  // 3. Recent rejections: top error-class groups for exit!=0 entries in the
+  // last hour. Group key = `${cmd} :: ${errClass}`.
+  const rejCutoff = now - REJECTIONS_WINDOW_MS;
+  const groups = new Map();
+  for (const e of entries) {
+    if ((e?.exit ?? 0) === 0) continue;
+    const t = new Date(e.ts).getTime();
+    if (!Number.isFinite(t) || t < rejCutoff) continue;
+    const cmd = e.argv?.[0] ?? '(none)';
+    const cls = errorClass(e.err);
+    if (!cls) continue;
+    const key = `${cmd} :: ${cls}`;
+    if (!groups.has(key)) groups.set(key, { cmd, cls, count: 0 });
+    groups.get(key).count++;
+  }
+  const recentRejections = [...groups.values()]
+    .sort((a, b) => b.count - a.count)
+    .slice(0, REJECTIONS_CAP);
+
+  return { previousSelf, fleet, recentRejections };
+}
+
 export function buildHud(config) {
   // Drop stale lease entries (and flip their plan frontmatter back to
   // oldStatus) before reading anything. Without this, hud would surface
@@ -93,7 +209,9 @@ export function buildHud(config) {
     errors = index.errors.length;
   } catch { /* swallow — bad config shouldn't break the SessionStart hook */ }
 
-  return { owned, stale, prompts, errors };
+  const { previousSelf, fleet, recentRejections } = buildJournalSections(config);
+
+  return { owned, stale, prompts, errors, previousSelf, fleet, recentRejections };
 }
 
 export function runHud(argv, config) {
@@ -131,5 +249,34 @@ export function runHud(argv, config) {
     lines.push(dim(`↻ slash commands refreshed (v${from} → v${to}): ${names}`));
   }
 
+  // F17b: three journal-aware sections. Silent-when-clean: each block emits
+  // only when it has entries.
+  if (hud.previousSelf?.length) {
+    lines.push(dim('— previous self —'));
+    for (const e of hud.previousSelf) {
+      const cmd = (e.argv ?? []).join(' ');
+      const exitTag = e.exit === 0 ? '' : `, exit ${e.exit}`;
+      lines.push(dim(`  ${cmd} (${e.ago}${exitTag})`));
+    }
+  }
+
+  if (hud.fleet?.length) {
+    lines.push(dim('— fleet (last 24h) —'));
+    for (const f of hud.fleet) {
+      const heldTag = f.holding?.length
+        ? ` · holding ${f.holding.map(p => path.basename(p, '.md')).join(', ')}`
+        : '';
+      const staleTag = f.stale ? yellow(' [stale]') : '';
+      lines.push(dim(`  session ${f.sid} · ${f.cmds} cmds · last ${f.lastAgo}${heldTag}`) + staleTag);
+    }
+  }
+
+  if (hud.recentRejections?.length) {
+    lines.push(dim('— recent rejections (last 1h) —'));
+    for (const r of hud.recentRejections) {
+      lines.push(dim(`  ${r.count}× "${r.cls}" on \`${r.cmd}\``));
+    }
+  }
+
   process.stdout.write(lines.join('\n') + '\n');
 }

package/src/lifecycle.mjs

@@ -168,9 +168,22 @@ export async function runStatus(argv, config, opts = {}) {
   const today = nowIso();
   const archiveDir = path.join(fileRoot, config.archiveDir);
   const relFromRoot = path.relative(fileRoot, filePath);
+  const relSegments = relFromRoot.split(path.sep);
   const inArchive = relFromRoot.startsWith(config.archiveDir + '/') || relFromRoot.startsWith(config.archiveDir + path.sep);
   const isArchiving = config.lifecycle.archiveStatuses.has(newStatus) && !inArchive;
   const isUnarchiving = !config.lifecycle.archiveStatuses.has(newStatus) && inArchive;
+
+  // F15 filing: a status with `filed: true` lives in `<root>/<dirName>/`. The
+  // current parent dir under root tells us whether the file is in some
+  // "bucket" right now. Archiving keeps its own path; filing is a separate
+  // primitive that fires only when the new status is filed (and isn't an
+  // archive transition — archive wins by being earlier in the conditional).
+  const filedStatuses = config.lifecycle.filedStatuses ?? new Map();
+  const newFiledDir = filedStatuses.get(newStatus) ?? null;
+  const oldFiledDir = oldStatus ? (filedStatuses.get(oldStatus) ?? null) : null;
+  const currentBucket = relSegments.length > 1 ? relSegments[0] : null;
+  const isFiling = !isArchiving && !isUnarchiving && newFiledDir && currentBucket !== newFiledDir;
+  const isUnfiling = !isArchiving && !isUnarchiving && !newFiledDir && oldFiledDir && currentBucket === oldFiledDir;
   let finalPath = filePath;
 
   if (dryRun) {
@@ -186,7 +199,17 @@ export async function runStatus(argv, config, opts = {}) {
       process.stdout.write(`${prefix} Would move: ${toRepoPath(filePath, config.repoRoot)} → ${toRepoPath(targetPath, config.repoRoot)}\n`);
       finalPath = targetPath;
     }
-    if ((isArchiving || isUnarchiving) && config.indexPath) {
+    if (isFiling) {
+      const targetPath = path.join(fileRoot, newFiledDir, path.basename(filePath));
+      process.stdout.write(`${prefix} Would file: ${toRepoPath(filePath, config.repoRoot)} → ${toRepoPath(targetPath, config.repoRoot)}\n`);
+      finalPath = targetPath;
+    }
+    if (isUnfiling) {
+      const targetPath = path.join(fileRoot, path.basename(filePath));
+      process.stdout.write(`${prefix} Would unfile: ${toRepoPath(filePath, config.repoRoot)} → ${toRepoPath(targetPath, config.repoRoot)}\n`);
+      finalPath = targetPath;
+    }
+    if ((isArchiving || isUnarchiving || isFiling || isUnfiling) && config.indexPath) {
       process.stdout.write(`${prefix} Would regenerate index\n`);
     }
     process.stdout.write(`${prefix} ${toRepoPath(finalPath, config.repoRoot)}: ${oldStatus ?? 'unknown'} → ${newStatus}\n`);
@@ -212,6 +235,24 @@ export async function runStatus(argv, config, opts = {}) {
     finalPath = targetPath;
   }
 
+  if (isFiling) {
+    const targetDir = path.join(fileRoot, newFiledDir);
+    mkdirSync(targetDir, { recursive: true });
+    const targetPath = path.join(targetDir, path.basename(filePath));
+    if (existsSync(targetPath)) { die(`Target already exists: ${toRepoPath(targetPath, config.repoRoot)}`); }
+    const result = gitMv(filePath, targetPath, config.repoRoot);
+    if (result.status !== 0) { die(result.stderr || 'git mv failed.'); }
+    finalPath = targetPath;
+  }
+
+  if (isUnfiling) {
+    const targetPath = path.join(fileRoot, path.basename(filePath));
+    if (existsSync(targetPath)) { die(`Target already exists: ${toRepoPath(targetPath, config.repoRoot)}`); }
+    const result = gitMv(filePath, targetPath, config.repoRoot);
+    if (result.status !== 0) { die(result.stderr || 'git mv failed.'); }
+    finalPath = targetPath;
+  }
+
   // Regen the index on every status change — `active → planned` etc. drift
   // the per-status sections just as much as archive crossings. Archive paths
   // also benefit (replaces the previously-gated regen). `--no-index` skips

package/src/validate.mjs

@@ -19,6 +19,11 @@ const BUILTIN_TYPE_DIR_NAMES = ['plans', 'prompts'];
 function liveTypeDirsForRoots(config) {
   const set = new Set();
   const roots = config.docsRoots || (config.docsRoot ? [config.docsRoot] : []);
+  // F15: filed-status bucket dirs are "live" too — a doc whose status is
+  // an archive status but whose parent dir is a filed bucket should still
+  // trigger the archive-drift warning (the file needs to move into the
+  // archive bucket).
+  const filedDirs = [...((config.lifecycle?.filedStatuses?.values?.()) ?? [])];
   for (const root of roots) {
     const rootRel = path.relative(config.repoRoot, root).split(path.sep).join('/');
     // The root itself is a live dir (covers flat-array layouts where the
@@ -40,6 +45,11 @@ function liveTypeDirsForRoots(config) {
         set.add(rootRel ? `${rootRel}/${tmpl.dir}` : tmpl.dir);
       }
     }
+    // F15: filed bucket dirs joined to each root.
+    for (const dirName of filedDirs) {
+      if (path.basename(rootRel) === dirName) continue;
+      set.add(rootRel ? `${rootRel}/${dirName}` : dirName);
+    }
   }
   return set;
 }