@staix/vault-mem 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.1.3] - 2026-10-30
+
+- `vmem tidy --log` fixes legacy log lines that fail lint L09: a trailing seconds field is dropped, and any other malformed line is kept verbatim behind `# legacy: `.
+
+## [0.1.2] - 2026-10-30
+
+- `vmem move` accepts an existing legacy-named note (lint L13) as its source and may rewrite inbound links in other legacy-named notes, so the finding can be fixed with a normal rename. Destinations still need a valid stem.
+
 ## [0.1.1] - 2026-10-30
 
 - `vmem setup` registers the PATH `bun` launcher when it runs the same binary, so host MCP entries survive a runtime upgrade that removes the versioned real path.

package/README.md

@@ -78,7 +78,7 @@ vmem tidy personal --all --json                 # migration sanitize preview (se
 
 Syntax follows indexed reads: the vault id comes first. `new` supports `--title`, `--source`, `--confidence`, `--status`, `--extra JSON` and `--body file|-`; omitted body gets an H1/Relevant Notes/Topics skeleton. Patch accepts nonempty old/new strings up to 8192 bytes and requires exactly one occurrence (including overlapping occurrences). Append uses an existing section or inserts it before Topics; it refuses targeting or introducing a Topics H2. `frontmatter` supports `--set JSON`, `--unset key,key` and `--expected-sha`; append also supports `--expected-sha`. Link relations are `supports`, `contradicts`, `extends`, `applies-to`, `context-for`; links are bidirectional unless `--one-way`. Supersede sets `status`/`superseded_by` on the old note and adds a reverse link in the next note. Report permits plain paths below `reports/` or `ops/`, is schema-exempt and still screened. Inputs are bounded to 256 KiB, follow no file symlinks and accept stdin with `-`.
 
-`--dry-run` plans and validates any writer without creating locks, temporary files, directories or caches. `check` always takes this path, even without `--dry-run`. Move, delete and tidy first return a preview with planned path/hash changes and a fingerprint; confirmation requires that fingerprint. It covers canonical operation input, the canonical vault path/identity and policy, expected SHAs, every scanned note and all touched files, so even a new inbound reference after preview forces another preview. Move rewrites visible wiki/heading/block/embed targets and wiki references in frontmatter across the vault, preserving explicit `|label` text, anchors and code. Alias-only links resolve to no note and are left as written. Tidy folds Connections sections into Relevant Notes. Delete refuses when it would newly break inbound links or MOC topics; fix those references first.
+`--dry-run` plans and validates any writer without creating locks, temporary files, directories or caches. `check` always takes this path, even without `--dry-run`. Move, delete and tidy first return a preview with planned path/hash changes and a fingerprint; confirmation requires that fingerprint. It covers canonical operation input, the canonical vault path/identity and policy, expected SHAs, every scanned note and all touched files, so even a new inbound reference after preview forces another preview. Move rewrites visible wiki/heading/block/embed targets and wiki references in frontmatter across the vault, preserving explicit `|label` text, anchors and code. Alias-only links resolve to no note and are left as written. The move source may be an existing note with a legacy file name (lint L13, for example a dot in the stem); the destination must be a valid stem. Tidy folds Connections sections into Relevant Notes. Delete refuses when it would newly break inbound links or MOC topics; fix those references first.
 
 Validation returns named issues with severity and no matched secret text: V01 schema/enums/description; V02 existing MOC topics; V03 newly unresolved links; V04 flat ASCII note paths (maximum 200 bytes) and safe report paths; V05 final Topics placement/content (warning), with explicit append-to-Topics refusal; V06 pinned agent-mem secret regex parity and denied sources/input/snapshot paths; V07 email/phone/configured PII patterns when denied; V08 create duplicates (stem/NFKC H1); V09 256 KiB prospective size, exact patch and expected-SHA/drift; V10 supersession target integrity. Unchanged pre-existing broken links warn, including after a move. `possibleDuplicates` lists candidate paths for warnings from a disposable in-memory FTS5 query of title terms, with BM25 <= -0.000001, up to three paths; no disk cache is written for that check. `LOCKED`, `IO`, `ROLLBACK`, `INDEX` and `CLEANUP` identify operational failures. CLI returns exit 1 when `ok` is false.
 
@@ -247,6 +247,6 @@ Runtime changes intentionally make `release:verify` report stale historical rele
 | `--topics` | append `## Topics` listing the frontmatter topics where no such heading exists; mismatched sections are reported |
 | `--connections` | fold `## Connections (...)` headings into `## Relevant Notes` |
 | `--secrets` | replace V06 secret matches with `[redacted]`: in the body the match itself, in frontmatter the whole field value (the key stays, so the YAML stays valid). A match outside a field value, such as a YAML comment, is reported for manual repair. The preview names note and line, never the value. PII in personal vaults is left alone |
-| `--log` | replace secret-looking substrings and email addresses in existing log lines with `[redacted]`, under the log lock (refused with V06 when `denyPaths` covers the log); legacy lines are otherwise kept byte for byte. Git history is not rewritten: rotate exposed credentials |
+| `--log` | replace secret-looking substrings and email addresses in existing log lines with `[redacted]`, under the log lock (refused with V06 when `denyPaths` covers the log). A line that fails the lint L09 structure check loses a trailing seconds field when that makes it valid, and is otherwise kept verbatim behind `# legacy: ` (readers skip `#` lines); no time, zone or TYPE is guessed. Other lines are kept byte for byte. Git history is not rewritten: rotate exposed credentials |
 
 `--map <file>` overrides defaults with strict JSON `{"enums": {"confidence|status|type": {"from": "to"}}, "keys": {"key": "drop" | "keep" | {"rename": "key"}}}` (at most 64 KiB and 1000 entries). For `tidy`, `--log` selects the log rule; tidy always writes its own `LINT` event.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@staix/vault-mem",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Validated Obsidian-compatible knowledge vaults for agents and people",
   "license": "MIT",
   "type": "module",

package/src/tidy.ts

@@ -29,7 +29,7 @@ export interface TidyResult {
   notes: { path: string; changes: string[] }[];
   /** Values and keys left unchanged because no rule or map entry covers them. */
   reported: { path: string; message: string }[];
-  log?: { lines: number; redactions: number; changes: string[] };
+  log?: { lines: number; redactions: number; formats: number; changes: string[] };
   fingerprint?: string;
   written: string[];
   issues: WriteIssue[];
@@ -271,17 +271,32 @@ function readLogFile(root: string): string | null {
     return buffer.subarray(0, read).toString("utf8");
   } finally { closeSync(fd); }
 }
-function sanitizeLog(text: string): { text: string; lines: number; redactions: number; changes: string[] } {
-  let lines = 0, redactions = 0;
+/** The lint L09 structure check (kept identical to vault-lint.ts). */
+const LOG_STRUCTURE = /^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2})\s+(\S+)\s+(.*)$/;
+/** Fix a legacy line that fails L09: drop a seconds field when that makes it valid, otherwise comment it out verbatim. */
+function normalizeLogLine(line: string): string | undefined {
+  const body = line.endsWith("\r") ? line.slice(0, -1) : line;
+  if (!body.trim() || body.startsWith("#") || LOG_STRUCTURE.test(body)) return undefined;
+  const seconds = /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}):\d{2}(\s.*)$/.exec(body);
+  if (seconds && LOG_STRUCTURE.test(seconds[1]! + seconds[2]!)) return seconds[1]! + seconds[2]! + line.slice(body.length);
+  return `# legacy: ${line}`;
+}
+function sanitizeLog(text: string): { text: string; lines: number; redactions: number; formats: number; changes: string[] } {
+  let lines = 0, redactions = 0, formats = 0;
   const changes: string[] = [];
   const out = text.split("\n").map((line, index) => {
     const secret = redact(line);
     let hits = secret.hits, next = secret.text;
     next = next.replace(new RegExp(EMAIL_PATTERN.source, "gi"), () => { hits++; return "[redacted]"; });
-    if (hits) { lines++; redactions += hits; changes.push(`log: line ${index + 1}, ${hits} redaction${hits === 1 ? "" : "s"}`); }
+    const normalized = normalizeLogLine(next);
+    if (normalized !== undefined) { next = normalized; formats++; }
+    if (hits || normalized !== undefined) {
+      lines++; redactions += hits;
+      changes.push(`log: line ${index + 1}, ${[hits ? `${hits} redaction${hits === 1 ? "" : "s"}` : "", normalized !== undefined ? "format" : ""].filter(Boolean).join(", ")}`);
+    }
     return next;
   }).join("\n");
-  return { text: out, lines, redactions, changes };
+  return { text: out, lines, redactions, formats, changes };
 }
 /** Replace the log under its own lock, atomically (the one sanctioned in-place rewrite of the append-only log). */
 function rewriteLog(root: string, expected: string, next: string): void {
@@ -339,14 +354,14 @@ export function tidyVault(home: string, request: TidyRequest, options: { env?: N
     }
   }
   result.notes = planned.map(change => ({ path: change.path, changes: change.changes }));
-  let logPlan: { before: string; text: string; lines: number; redactions: number; changes: string[] } | undefined;
+  let logPlan: { before: string; text: string; lines: number; redactions: number; formats: number; changes: string[] } | undefined;
   if (rules.includes("log") && isDenied(join(root, "log"), config.denyPaths)) return { ...result, issues: [issue("V06", "the vault log is denied by the path policy; drop --log")] };
   if (rules.includes("log")) {
     const before = readLogFile(root);
     if (before !== null) {
       const sanitized = sanitizeLog(before);
-      result.log = { lines: sanitized.lines, redactions: sanitized.redactions, changes: sanitized.changes };
-      if (sanitized.redactions) { logPlan = { before, ...sanitized }; result.counts.log = sanitized.redactions; }
+      result.log = { lines: sanitized.lines, redactions: sanitized.redactions, formats: sanitized.formats, changes: sanitized.changes };
+      if (sanitized.text !== before) { logPlan = { before, ...sanitized }; result.counts.log = sanitized.redactions + sanitized.formats; }
     }
   }
   // Validate every planned note with the writer (dry-run). A note the writer would refuse is reported and skipped

package/src/write-operations.ts

@@ -14,6 +14,15 @@ export function notePath(path: string): string {
   if (!/^notes\/[a-z0-9][a-z0-9-]*\.md$/.test(value) || Buffer.byteLength(value) > 200) refuse("V04", "expected flat lowercase ASCII note path <=200 bytes");
   return value;
 }
+/** A move source may keep a legacy file name (lint L13) as long as it is an existing flat note; `to` still uses notePath. */
+export function moveSourcePath(value: string, notes: ReadonlyMap<string, string>): string {
+  try { return notePath(value); } catch (error) {
+    if (typeof value !== "string") throw error;
+    const path = value.startsWith("notes/") ? value : `notes/${value.endsWith(".md") ? value : `${value}.md`}`;
+    if (path.slice(6).includes("/") || path.includes("\\") || !path.endsWith(".md") || !notes.has(path)) throw error;
+    return path;
+  }
+}
 function needed(notes: Map<string, string>, path: string): string {
   const source = notes.get(path);
   if (source === undefined) refuse("V04", "note does not exist", path);
@@ -138,7 +147,7 @@ export function planOperation(operation: WriteOp, notes: Map<string, string>, re
     }
     case "delete": { const { path } = existing(operation.path); set(path, null); break; }
     case "move": {
-      const from = existing(operation.from), to = notePath(operation.to);
+      const fromPath = moveSourcePath(operation.from, notes), from = { path: fromPath, source: needed(notes, fromPath) }, to = notePath(operation.to);
       if (notes.has(to)) refuse("V08", "move destination already exists", to);
       const names = new Map<string, Set<string>>();
       for (const [path, source] of notes) {

package/src/write-validation.ts

@@ -6,6 +6,7 @@ import { parseFrontmatter } from "./frontmatter.ts";
 import { extractLinks, normalizeTarget, proseLines, resolveLinks, type Link, type LinkNote, type ResolvedLink } from "./links.ts";
 import { canonicalPath, isDenied } from "./platform.ts";
 import type { PlannedChange, ValidationContext, WriteIssue } from "./write-types.ts";
+import { moveSourcePath } from "./write-operations.ts";
 
 const TYPES = new Set(["insight", "decision", "observation", "person", "project", "method", "moc", "reference"]);
 const DOMAINS = new Set(["research", "projects", "teaching", "operations", "people", "ai-practice"]);
@@ -147,10 +148,14 @@ function linkSignature(link: ResolvedLink, source: string = link.source): string
   return JSON.stringify([source, noteKey(link.target), link.heading ? normalizeTarget(link.heading) : null,
     link.block ? normalizeTarget(link.block) : null, link.embed, link.reason]);
 }
+/** The snapshot path a move removes, legacy file names included. */
+function movedFrom(value: string, context: ValidationContext): string {
+  try { return moveSourcePath(value, context.notes); } catch { return `notes/${value.replace(/^notes\//, "").replace(/\.md$/, "")}.md`; }
+}
 function changedBrokenLinks(oldNotes: Map<string, ParsedNote>, newNotes: Map<string, ParsedNote>, context: ValidationContext): WriteIssue[] {
   const oldCounts = new Map<string, number>();
   const move = context.operation.op === "move" ? context.operation : undefined;
-  const from = move ? `notes/${move.from.replace(/^notes\//, "").replace(/\.md$/, "")}.md` : "";
+  const from = move ? movedFrom(move.from, context) : "";
   const to = move ? `notes/${move.to.replace(/^notes\//, "").replace(/\.md$/, "")}.md` : "";
   const oldNames = move ? names(oldNotes) : undefined;
   for (const link of references(oldNotes)) if (link.reason) {
@@ -229,8 +234,9 @@ export function validateWrite(changes: PlannedChange[], context: ValidationConte
   const issues: WriteIssue[] = [], final = new Map(context.notes), touched = new Set(changes.map(change => change.path));
   const report = context.operation.op === "report";
   for (const change of changes) {
-    // Sanitize may rewrite an existing legacy-named note in place (L13 names stay until moved).
-    if (!validPath(change.path, report) && !(context.operation.op === "sanitize" && context.notes.has(change.path))) issues.push(issue("V04", "invalid mutation path"));
+    // Sanitize and move may touch an existing legacy-named note (L13 names stay until moved); move destinations stay strict.
+    const legacy = context.notes.has(change.path) && (context.operation.op === "sanitize" || context.operation.op === "move");
+    if (!validPath(change.path, report) && !legacy) issues.push(issue("V04", "invalid mutation path"));
     if (change.after === null) final.delete(change.path);
     else if (change.path.startsWith("notes/")) final.set(change.path, change.after);
     if (change.after === null) continue;
@@ -249,7 +255,7 @@ export function validateWrite(changes: PlannedChange[], context: ValidationConte
     if (change.after === null || report) continue;
     const note = newNotes.get(change.path);
     if (!note) { issues.push(issue("V01", "invalid frontmatter", "error", change.path)); continue; }
-    const prior=context.operation.op==="move"&&noteKey(context.operation.to)===noteKey(note.path)?oldNotes.get(`notes/${noteKey(context.operation.from)}.md`):oldNotes.get(note.path);
+    const prior=context.operation.op==="move"&&noteKey(context.operation.to)===noteKey(note.path)?oldNotes.get(movedFrom(context.operation.from, context)):oldNotes.get(note.path);
     issues.push(...schemaIssues(note,prior,context), ...topicPlacement(note));
     const source = note.data.source;
     let sourceDenied=strings(source).some(entry=>isDenied(entry.replaceAll("\\","/"),context.config.denyPaths));

package/src/writer.ts

@@ -9,7 +9,7 @@ import { loadRegistry, syncDirectory } from "./registry.ts";
 import { VaultIndex, MAX_NOTE_BYTES } from "./vault-index.ts";
 import { parseFrontmatter } from "./frontmatter.ts";
 import { canonicalPath, isDenied } from "./platform.ts";
-import { notePath, planOperation, refuse, WriteRefusal } from "./write-operations.ts";
+import { moveSourcePath, notePath, planOperation, refuse, WriteRefusal } from "./write-operations.ts";
 import { validateWrite } from "./write-validation.ts";
 import type { ChangeReceipt, PlannedChange, WriteIssue, WriteReceipt, WriteRequest } from "./write-types.ts";
 export const MUTATION_LOCK = "mutation.lock";
@@ -223,7 +223,7 @@ export function applyWrite(home: string, request: WriteRequest, options: { env?:
     if (request.log !== false) {
       const op = request.operation;
       const type = op.op === "link" ? "CONNECT" : op.op === "move" ? "ROUTE" : ["supersede", "tidy"].includes(op.op) ? "RETHINK" : "EXTRACT";
-      const source = op.op === "move" || op.op === "link" ? notePath(op.from) : op.op === "supersede" ? notePath(op.old) : op.op === "delete" ? notePath(op.path) : `vmem:${op.op}`;
+      const source = op.op === "move" ? moveSourcePath(op.from, notes) : op.op === "link" ? notePath(op.from) : op.op === "supersede" ? notePath(op.old) : op.op === "delete" ? notePath(op.path) : `vmem:${op.op}`;
       const dest = op.op === "move" || op.op === "link" ? notePath(op.to) : op.op === "supersede" ? notePath(op.next) : op.op === "delete" ? undefined : changes.find(change => change.after !== null)?.path;
       const event: LogEvent = request.log ?? { type, project: "-", source, ...(dest ? { dest } : {}), note: op.op };
       try { result.log = appendLog(home, { vault: request.vault, event, channel: request.channel }, { env: options.env, binding: { vault, denyPaths: config.denyPaths ?? [], piiPatterns: config.piiPatterns ?? [], dev: Number(identity.dev), ino: Number(identity.ino) } }); }