fix(memory): 加固记忆完整性校验

修复组合 fix plan 的行号漂移，补齐 schema 值校验、绝对定位与 project 参数，并让 doctor 和 knowledge-lint 共用公开校验入口。

Refs #2

Author: cortex-agent

lib/commands/doctor.js

@@ -304,8 +304,10 @@ async function doctor(ctx) {
       } else {
         for (const issue of result.issues) {
           const locator = issue.line
-            ? `${issue.path || `.agent/memory/MEMORY.md`}:${issue.line}`
-            : issue.path || `.agent/memory/${issue.type}`;
+            ? `${result.parsed.indexPath}:${issue.line}`
+            : issue.path
+              ? path.join(result.memoryRoot, issue.path)
+              : path.join(result.memoryRoot, issue.type);
           console.log(`  - ${issue.kind}: ${locator}  ${issue.detail}`);
         }
         const s = result.summary;
@@ -321,10 +323,21 @@ async function doctor(ctx) {
         console.log(
           `  - ${isZh ? "修复" : "remedy"}: ${
             isZh
-              ? "运行 `cortex-agent memory-validate --fix --yes` 自动修复 drift/orphan/duplicate"
-              : "run `cortex-agent memory-validate --fix --yes` to auto-fix drift/orphan/duplicate"
+              ? "运行 `cortex-agent memory validate --fix --yes` 自动修复 drift/orphan/duplicate"
+              : "run `cortex-agent memory validate --fix --yes` to auto-fix drift/orphan/duplicate"
           }`
         );
+        if (options.fix) {
+          const plan = memoryValidate.buildFixPlan(result.parsed, result.issues, result.memoryRoot);
+          const applied = memoryValidate.applyFixPlan(result.parsed, plan, { confirm: true });
+          console.log(`  - ${isZh ? "已修复" : "fixed"}: ${applied.applied} ${isZh ? "项安全修改" : "safe edit(s)"}`);
+          const after = memoryValidate.validateMemory({ projectRoot: cwd });
+          if (after.issues.length === 0) {
+            console.log(`  - ${isZh ? "修复后状态" : "status after fix"}: ${isZh ? "正常" : "ok"}`);
+          } else {
+            console.log(`  - ${isZh ? "修复后剩余" : "remaining after fix"}: ${after.issues.length}`);
+          }
+        }
       }
     } catch (err) {
       console.log(`\n[${isZh ? "memory-integrity" : "memory-integrity"}]`);

lib/memory-validate.js

@@ -46,13 +46,28 @@ const REQUIRED_FRONTMATTER_KEYS = Object.freeze([
   "created",
   "tags",
 ]);
+const ALLOWED_FRONTMATTER_KEYS = new Set([
+  ...REQUIRED_FRONTMATTER_KEYS,
+  "expires",
+  "metadata",
+  "source",
+  "related",
+]);
+const SLUG_PATTERN = /^[a-z0-9_][a-z0-9_-]*$/;
 
 // ─── Default path resolution ──────────────────────────────────────────────────
 
 function defaultMemoryRoot(projectRoot) {
   return path.join(projectRoot, ".agent", "memory");
 }
 
+function resolveMemoryPath(memoryRoot, relativePath) {
+  const root = path.resolve(memoryRoot);
+  const resolved = path.resolve(root, relativePath);
+  if (resolved !== root && !resolved.startsWith(root + path.sep)) return null;
+  return resolved;
+}
+
 // ─── MEMORY.md parser (V-1 / V-2 / V-5 sources) ──────────────────────────────
 
 function parseMemoryIndex(memoryRoot) {
@@ -114,11 +129,19 @@ function parseFrontmatter(text) {
   if (!m) return null;
   const result = {};
   const lines = m[1].split(/\r?\n/);
+  let currentKey = null;
   for (const line of lines) {
     if (!line.trim() || line.trim().startsWith("#")) continue;
+    const listItem = line.match(/^\s+-\s+(.+)$/);
+    if (listItem && currentKey) {
+      if (!Array.isArray(result[currentKey])) result[currentKey] = [];
+      result[currentKey].push(listItem[1].replace(/^["']|["']$/g, "").trim());
+      continue;
+    }
     const kv = line.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/);
     if (!kv) continue;
     const key = kv[1];
+    currentKey = key;
     let raw = kv[2];
     // Strip trailing inline comment after a quoted value.
     if (
@@ -128,14 +151,66 @@ function parseFrontmatter(text) {
       raw = raw.slice(1, -1);
     } else if (raw.startsWith("[") && raw.endsWith("]")) {
       raw = raw.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean);
-    } else if (raw === "true" || raw === "false" || raw === "null" || raw === "") {
-      // Keep as-is.
+    } else if (raw === "") {
+      raw = key === "metadata" ? {} : [];
+    } else if (raw === "true" || raw === "false" || raw === "null") {
+      // Keep simple literals as strings; the schema validator rejects wrong types.
     }
     result[key] = raw;
   }
   return result;
 }
 
+function isValidDate(value) {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return false;
+  const [year, month, day] = value.split("-").map(Number);
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+
+function validateFrontmatterValues(frontmatter, expectedType) {
+  const errors = [];
+  for (const key of Object.keys(frontmatter)) {
+    if (!ALLOWED_FRONTMATTER_KEYS.has(key)) errors.push(`unknown frontmatter key: ${key}`);
+  }
+  if (typeof frontmatter.name !== "string" || !SLUG_PATTERN.test(frontmatter.name)) {
+    errors.push("name must match ^[a-z0-9_][a-z0-9_-]*$");
+  } else if (frontmatter.name.length > 64) {
+    errors.push("name must be at most 64 characters");
+  }
+  if (typeof frontmatter.description !== "string") {
+    errors.push("description must be a string");
+  } else if (frontmatter.description.length > 200) {
+    errors.push("description must be at most 200 characters");
+  }
+  if (!ALL_TYPES.includes(frontmatter.type)) {
+    errors.push(`type must be one of: ${ALL_TYPES.join(", ")}`);
+  } else if (frontmatter.type !== expectedType) {
+    errors.push(`type must match directory "${expectedType}"`);
+  }
+  if (!isValidDate(frontmatter.created)) errors.push("created must be a valid YYYY-MM-DD date");
+  if (frontmatter.expires !== undefined && frontmatter.expires !== "null" && !isValidDate(frontmatter.expires)) {
+    errors.push("expires must be null or a valid YYYY-MM-DD date");
+  }
+  if (!Array.isArray(frontmatter.tags) || frontmatter.tags.length < 1 || frontmatter.tags.length > 10) {
+    errors.push("tags must contain 1 to 10 items");
+  } else {
+    frontmatter.tags.forEach((tag, index) => {
+      if (typeof tag !== "string" || !SLUG_PATTERN.test(tag)) {
+        errors.push(`tags[${index}] must match ^[a-z0-9_][a-z0-9_-]*$`);
+      }
+    });
+  }
+  if (frontmatter.metadata !== undefined && (typeof frontmatter.metadata !== "object" || Array.isArray(frontmatter.metadata))) {
+    errors.push("metadata must be an object");
+  }
+  if (frontmatter.source !== undefined && typeof frontmatter.source !== "string") errors.push("source must be a string");
+  if (frontmatter.related !== undefined && (!Array.isArray(frontmatter.related) || frontmatter.related.some((item) => typeof item !== "string"))) {
+    errors.push("related must be an array of strings");
+  }
+  return errors;
+}
+
 // ─── Validators ─────────────────────────────────────────────────────────────────
 
 function validateDrift(parsed) {
@@ -161,7 +236,17 @@ function validateMissing(parsed, memoryRoot) {
     const section = parsed.sections[type];
     if (!section) continue;
     for (const item of section.items) {
-      const fullPath = path.join(memoryRoot, item.path);
+      const fullPath = resolveMemoryPath(memoryRoot, item.path);
+      if (!fullPath) {
+        issues.push({
+          kind: "missing",
+          type,
+          line: item.line,
+          path: item.path,
+          detail: `MEMORY.md path ${item.path} escapes the memory root`,
+        });
+        continue;
+      }
       let stat = null;
       try { stat = fs.statSync(fullPath); } catch (_) {}
       const placeholder = path.basename(item.path) === ".gitkeep";
@@ -205,12 +290,15 @@ function validateSchema(memoryRoot) {
         continue;
       }
       const missingKeys = REQUIRED_FRONTMATTER_KEYS.filter((k) => !(k in fm));
-      if (missingKeys.length > 0) {
+      const valueErrors = missingKeys.length === 0 ? validateFrontmatterValues(fm, type) : [];
+      if (missingKeys.length > 0 || valueErrors.length > 0) {
         issues.push({
           kind: "schema",
           type,
           path: path.join(type, file),
-          detail: `topic file is missing frontmatter keys: ${missingKeys.join(", ")}`,
+          detail: missingKeys.length > 0
+            ? `topic file is missing frontmatter keys: ${missingKeys.join(", ")}`
+            : `topic file frontmatter is invalid: ${valueErrors.join("; ")}`,
         });
       }
     }
@@ -354,16 +442,22 @@ function buildFixPlan(parsed, issues, memoryRoot) {
   // computation sees the *post-fix* item count (otherwise appending N
   // orphans to a section with declaredCount=K would still leave drift).
   const orphanAppendCount = Object.create(null);
+  const duplicateRemovalCount = Object.create(null);
   for (const issue of issues) {
-    if (issue.kind !== "orphan") continue;
-    orphanAppendCount[issue.type] = (orphanAppendCount[issue.type] || 0) + 1;
+    if (issue.kind === "orphan") {
+      orphanAppendCount[issue.type] = (orphanAppendCount[issue.type] || 0) + 1;
+    } else if (issue.kind === "duplicate") {
+      duplicateRemovalCount[issue.type] = (duplicateRemovalCount[issue.type] || 0) + 1;
+    }
   }
 
   // drift: rewrite section headers
   for (const type of ALL_TYPES) {
     const section = parsed.sections[type];
     if (!section) continue;
-    const projectedItems = section.items.length + (orphanAppendCount[type] || 0);
+    const projectedItems = section.items.length
+      - (duplicateRemovalCount[type] || 0)
+      + (orphanAppendCount[type] || 0);
     if (section.declaredCount !== projectedItems) {
       const newHeader = `## ${type} (${projectedItems}/${section.declaredCap})`;
       edits.push({
@@ -415,15 +509,13 @@ function buildFixPlan(parsed, issues, memoryRoot) {
   }
 
   // duplicate: drop the duplicate line (keep first occurrence)
-  const duplicateLines = new Set();
   const seen = new Set();
   for (const type of ALL_TYPES) {
     const section = parsed.sections[type];
     if (!section) continue;
     seen.clear();
     for (const item of section.items) {
       if (seen.has(item.path)) {
-        duplicateLines.add(item.line);
         edits.push({
           kind: "duplicate",
           type,
@@ -461,37 +553,29 @@ function applyFixPlan(parsed, plan, { confirm = false } = {}) {
   }
   if (!plan || !plan.ok) return { ok: false, applied: 0 };
   const lines = parsed.lines.slice();
-  // Apply drift (replace header)
-  for (const edit of plan.edits) {
-    if (edit.kind === "drift") {
-      lines[edit.line - 1] = edit.after;
-    }
+  // Apply every original-line edit in descending order before any insertion,
+  // so no operation can invalidate another edit's line number.
+  const lineEdits = plan.edits
+    .filter((edit) => edit.kind === "drift" || edit.kind === "duplicate")
+    .sort((a, b) => b.line - a.line);
+  for (const edit of lineEdits) {
+    if (edit.kind === "duplicate") lines.splice(edit.line - 1, 1);
+    else lines[edit.line - 1] = edit.after;
   }
-  // Apply orphan (insert after the section header). Find the next "## "
-  // boundary for each edit before inserting.
+  // Insert orphans after line-based edits. Locate the section by its stable
+  // heading instead of stale source line numbers.
   const orphanInsertions = plan.edits
     .filter((e) => e.kind === "orphan")
-    // Process in reverse line order so earlier insertions do not shift
-    // later line numbers.
-    .sort((a, b) => b.line - a.line);
+    .sort((a, b) => ALL_TYPES.indexOf(b.type) - ALL_TYPES.indexOf(a.type));
   for (const edit of orphanInsertions) {
-    const section = parsed.sections[edit.type];
-    let insertAt = edit.line; // after header line
+    const headerIndex = lines.findIndex((line) => new RegExp(`^##\\s+${edit.type}\\s*\\(`).test(line));
+    if (headerIndex === -1) continue;
+    let insertAt = headerIndex + 1;
     while (insertAt < lines.length && !lines[insertAt].match(/^##\s/)) {
       insertAt += 1;
     }
     lines.splice(insertAt, 0, edit.after);
   }
-  // Apply duplicate (remove line). Process in reverse order so deletions
-  // do not shift earlier line numbers.
-  const duplicateDeletions = plan.edits
-    .filter((e) => e.kind === "duplicate")
-    .sort((a, b) => b.line - a.line);
-  for (const edit of duplicateDeletions) {
-    if (edit.line >= 1 && edit.line <= lines.length) {
-      lines.splice(edit.line - 1, 1);
-    }
-  }
   const newText = lines.join("\n") + (parsed.text.endsWith("\n") ? "" : "\n");
   fs.writeFileSync(parsed.indexPath, newText);
   return { ok: true, applied: plan.edits.length, newText };
@@ -504,8 +588,10 @@ module.exports = {
   ALL_TYPES,
   REQUIRED_FRONTMATTER_KEYS,
   defaultMemoryRoot,
+  resolveMemoryPath,
   parseMemoryIndex,
   parseFrontmatter,
+  validateFrontmatterValues,
   validateMemory,
   buildFixPlan,
   applyFixPlan,