memgineering 0.25.2 → 0.25.3

package/CHANGELOG.md

@@ -11,6 +11,34 @@ language the reader wants. The bilingual rule the monorepo applies to
 
 ## [Unreleased]
 
+## [0.25.3] — 2026-10-06
+
+### Fixed
+
+- **`onboard` no longer asks again for a base note you filled in with prose.**
+  On a hosted brain, a `USER.md` or other `01_BASE/` note whose prompt you
+  replaced with your own sentences still counted as unfilled, so `onboard` told
+  the agent to ask the same questions and write the body again — over what you
+  had written. A note counts as filled once its body is your words, prose or
+  bullets. Hosted `resurface` no longer labels such a note "not filled in yet"
+  either.
+- **`onboard` keeps asking about a note whose body is still the prompt**, even
+  after a `revise` put a claim in its frontmatter. On a folder brain this used
+  to take the note off the list. The same goes for a note whose prompt was
+  deleted and nothing written in its place.
+- **A starter note saved with Windows line endings (CRLF) or a byte-order mark
+  is still recognised as the untouched template** by `recall`, `resurface` and
+  `onboard`. `revise`'s "the body is still the prompt" warning now notices it
+  too.
+
+### Agent guidance
+
+- `memgineering-writing` and `onboard`'s `how_to_write`: `onboard` lists the
+  base notes whose body has not been written yet, and editing one directly is
+  right only while that is so.
+- `memgineering-recall`: a card marked `not filled in yet` is exactly what
+  `init` wrote, line endings aside.
+
 ## [0.25.2] — 2026-10-05
 
 Small fixes found by an independent review of 0.25.0 and 0.25.1. Nothing here

package/assets/MEMGINEERING.md

@@ -2,7 +2,7 @@
 name: memgineering
 description: Use whenever the user refers to something they told you before, asks what was decided, tells you something worth keeping, or settles something that should hold next time. The memory lives in their own folder and outlives this session; check it before answering from guesswork, and write to it when you learn something durable.
 type: skill
-version: 0.25.2
+version: 0.25.3
 ---
 
 # memgineering

package/assets/memgineering-recall/SKILL.md

@@ -205,7 +205,7 @@ next brain, and three of them said it out loud. Reading another brain does not
 move the machine's pointer.
 
 **Cards that are not answers.** A card marked `not filled in yet` is one of the
-five `01_BASE/` files, still byte-for-byte what `init` wrote. Nobody has answered
+five `01_BASE/` files, still exactly what `init` wrote (line endings aside). Nobody has answered
 it, so it is evidence of nothing — do not quote it back as what they think. When
 every card carries that mark, recall says so above them (`--json`:
 `scaffolding: true`), and that is the moment to offer to fill them in rather

package/assets/memgineering-writing/SKILL.md

@@ -359,7 +359,7 @@ so an empty one costs something every time.
 memgineering onboard
 ```
 
-Says which are still untouched and what to ask for each. Run it first rather
+Says which still have no body written and what to ask for each. Run it first rather
 than working from a script — asking somebody a question they already answered is
 its own kind of forgetting. They may also ask outright ("set up my memory", "fill in my profile"); same job.
 
@@ -404,7 +404,7 @@ always true and you have only just been told them, so dating them today is wrong
 in the one field a memory store exists to get right.
 
 **This is the ONE place you edit a brain file directly** — `01_BASE/` only, and
-only while it is still the template. After that first pass these are theirs like
+only while its body has not been written yet. After that first pass these are theirs like
 any other note.
 
 **Do not invent an answer to move on, and do not fill a file because it is

package/dist/index.js

@@ -1065,22 +1065,6 @@ function mapNoteToMemory(input) {
     issues
   };
 }
-function isUntouchedBase(path, content) {
-  if (!/^01_BASE\//.test(path)) return false;
-  const body = content.replace(/^---\r?\n[\s\S]*?\r?\n---[ \t]*(\r?\n|$)/, "");
-  const lines2 = body.split(/\r?\n/).map((l) => l.trimEnd());
-  let seenHeading = false;
-  for (const line of lines2) {
-    if (line.trim() === "") continue;
-    if (!seenHeading && line.startsWith("# ")) {
-      seenHeading = true;
-      continue;
-    }
-    if (/^-\s*$/.test(line)) continue;
-    if (/^[-*+]\s+\S/.test(line) || /^#{1,6}\s/.test(line)) return false;
-  }
-  return seenHeading;
-}
 var NAMESPACE, isRecord, asString, asStringArray, AUTHORABLE;
 var init_markdown_mapping = __esm({
   "../../packages/memory-engine/src/markdown-mapping.ts"() {
@@ -2441,6 +2425,21 @@ var init_planner = __esm({
   }
 });
 
+// ../../packages/memory-engine/src/note-body.ts
+function bodyOf(content) {
+  const stripped = content.startsWith(BOM) ? content.slice(BOM.length) : content;
+  const fence2 = FENCE.exec(stripped);
+  return fence2 ? stripped.slice(fence2[0].length) : stripped;
+}
+var BOM, FENCE;
+var init_note_body = __esm({
+  "../../packages/memory-engine/src/note-body.ts"() {
+    "use strict";
+    BOM = String.fromCharCode(65279);
+    FENCE = /^---[ \t]*\r?\n[\s\S]*?\r?\n---[ \t]*(\r?\n|$)/;
+  }
+});
+
 // ../../packages/memory-engine/src/base-templates.ts
 function base(id, title, summary, body) {
   return [
@@ -2461,10 +2460,31 @@ function base(id, title, summary, body) {
 function ownEntry(record, key2) {
   return Object.hasOwn(record, key2) ? record[key2] : void 0;
 }
-var BASE_TEMPLATES, RETIRED_BASE_TEMPLATES;
+function wordingsFor(path) {
+  const current = ownEntry(BASE_TEMPLATES, path);
+  const retired = ownEntry(RETIRED_BASE_TEMPLATES, path) ?? [];
+  return current === void 0 ? retired : [current, ...retired];
+}
+function isExactUntouchedBase(path, content) {
+  const saved = asSaved(content);
+  return wordingsFor(path).some((t) => asSaved(t) === saved);
+}
+function isTemplateBody(path, content) {
+  const lines2 = bodyLines(content).join("\n");
+  return wordingsFor(path).some((t) => bodyLines(t).join("\n") === lines2);
+}
+function isUnwrittenBody(path, content) {
+  if (isTemplateBody(path, content)) return true;
+  const [first, ...rest] = bodyLines(content);
+  if (first === void 0) return false;
+  const headings = wordingsFor(path).map((t) => bodyLines(t)[0]);
+  return headings.includes(first) && rest.every((line) => /^-\s*$/.test(line));
+}
+var BASE_TEMPLATES, RETIRED_BASE_TEMPLATES, BOM2, asSaved, bodyLines;
 var init_base_templates = __esm({
   "../../packages/memory-engine/src/base-templates.ts"() {
     "use strict";
+    init_note_body();
     BASE_TEMPLATES = {
       "01_BASE/CRITICAL_FACTS.md": base(
         "critical-facts",
@@ -2545,6 +2565,9 @@ var init_base_templates = __esm({
         ].join("\n")
       ]
     };
+    BOM2 = String.fromCharCode(65279);
+    asSaved = (text) => (text.startsWith(BOM2) ? text.slice(BOM2.length) : text).replace(/\r\n/g, "\n").trimEnd();
+    bodyLines = (content) => bodyOf(content).split("\n").map((line) => line.trimEnd()).filter((line) => line.trim() !== "");
   }
 });
 
@@ -4050,11 +4073,6 @@ function bodyStillAsserts(content, oldClaim, newClaim, normalize) {
   if (line === normalize(newClaim?.split("\n")[0] ?? "").trim()) return null;
   return bodyOf(content).includes(line) ? line : null;
 }
-function bodyOf(content) {
-  const stripped = content.replace(/^/, "");
-  const fence2 = /^---[ \t]*\r?\n[\s\S]*?\r?\n---[ \t]*(\r?\n|$)/.exec(stripped);
-  return fence2 ? stripped.slice(fence2[0].length) : stripped;
-}
 function previousClaim(entry) {
   const current = entry.claims.find((claim) => claim.id === entry.memory.current_claim) ?? entry.claims[0];
   return current?.text ?? null;
@@ -4072,6 +4090,7 @@ var init_curate = __esm({
     init_planner();
     init_schema();
     init_rule_budget();
+    init_note_body();
     NO_REASON_GIVEN = "revised directly";
     noLifecycleReason = (action) => `${action}d directly`;
   }
@@ -13372,24 +13391,11 @@ function capTemplates(cards, isTemplate, inConflict = () => false) {
   }
   return { kept, withheld };
 }
-function bodyOf2(content) {
-  const stripped = content.replace(/^/, "");
-  const fence2 = /^---[ \t]*\r?\n[\s\S]*?\r?\n---[ \t]*(\r?\n|$)/.exec(stripped);
-  return (fence2 ? stripped.slice(fence2[0].length) : stripped).trim();
-}
-function templatesFor(path, current) {
-  const retired = ownEntry(RETIRED_BASE_TEMPLATES, path) ?? [];
-  return current === void 0 ? retired : [current, ...retired];
-}
 function isBaseFilePath(path) {
   return path.startsWith("01_BASE/");
 }
 function bodyStillTemplate(path, content) {
-  const template = ownEntry(files("brain"), path);
-  if (template === void 0) return false;
-  const body = bodyOf2(content);
-  if (body === "") return false;
-  return templatesFor(path, template).some((t) => body === bodyOf2(t));
+  return isTemplateBody(path, content);
 }
 async function scaffoldingAmong(adapter, notes) {
   const basePaths = new Set(BASE_FILES.map((f) => f.path));
@@ -13404,19 +13410,18 @@ async function scaffoldingAmong(adapter, notes) {
 async function untouchedHub(adapter, title) {
   const actual = await adapter.read(HUB_PATH).then((r) => r.content).catch(() => null);
   if (actual === null) return false;
-  return actual.trimEnd() === (files(title)[HUB_PATH] ?? "").trimEnd();
+  return asSaved2(actual) === asSaved2(files(title)[HUB_PATH] ?? "");
+}
+function asSaved2(text) {
+  const BOM3 = String.fromCharCode(65279);
+  return (text.startsWith(BOM3) ? text.slice(BOM3.length) : text).replace(/\r\n/g, "\n").trimEnd();
 }
 async function untouchedBase(adapter, paths) {
-  const templates = files("brain");
   const out = /* @__PURE__ */ new Set();
   await Promise.all(
     paths.map(async (path) => {
-      const template = ownEntry(templates, path);
-      if (template === void 0) return;
       const actual = await adapter.read(path).then((r) => r.content).catch(() => null);
-      if (actual === null) return;
-      const trimmed = actual.trimEnd();
-      if (templatesFor(path, template).some((t) => trimmed === t.trimEnd())) out.add(path);
+      if (actual !== null && isExactUntouchedBase(path, actual)) out.add(path);
     })
   );
   return out;
@@ -18561,7 +18566,7 @@ function onboardCommand() {
         ...survey.missing.length === 0 ? {} : { missing: survey.missing, missing_hint: MISSING_HINT },
         // Spelled out in the machine-readable form too, because an agent
         // parsing this is the one that has to do the asking.
-        how_to_write: 'Write the body with your own file tools, then `memgineering revise <path> --action reinforce --claim "<one line>" --summary "<what recall should show>"`. This is the one place editing a brain file directly is right, and only while it is still the template.'
+        how_to_write: 'Write the body with your own file tools, then `memgineering revise <path> --action reinforce --claim "<one line>" --summary "<what recall should show>"`. This is the one place editing a brain file directly is right, and only while its body has not been written yet.'
       },
       human: () => {
         if (survey.unfilled.length === 0 && survey.missing.length === 0) {
@@ -18575,7 +18580,7 @@ function onboardCommand() {
           );
           return;
         }
-        printHuman(`${survey.heading}  (${survey.unfilled.length} of 5 still untouched)
+        printHuman(`${survey.heading}  (${survey.unfilled.length} of 5 still to write)
 `);
         if (survey.unfilled.length > 0) {
           printHuman(
@@ -18616,21 +18621,23 @@ function onboardCommand() {
 var MISSING_HINT = "A note that does not exist cannot be revised into \u2014 `revise` answers `ref_not_found`. `memgineering create <name>` writes the base notes into a brain that holds nothing but its own scaffolding. A brain that already holds other notes takes them from a folder: `memgineering init <folder>` then `memgineering push --brain <name>`, which skips every path already up there.";
 async function localSurvey(where) {
   const adapter = await openBrainOrExplain(where.brain.root);
-  const untouched = await untouchedBase(
-    adapter,
-    BASE_FILES.map((f) => f.path)
+  const unwritten = /* @__PURE__ */ new Set();
+  await Promise.all(
+    BASE_FILES.map(async (f) => {
+      const content = await adapter.read(f.path).then((r) => r.content).catch(() => null);
+      if (content !== null && isUnwrittenBody(f.path, content)) unwritten.add(f.path);
+    })
   );
   return {
     identity: { brain: where.brain.root },
     heading: "## onboard",
-    unfilled: BASE_FILES.filter((f) => untouched.has(f.path)),
-    // A file that is not there reads as written here, and that is the shipped
-    // behaviour rather than a decision taken now: `untouchedBase` cannot tell
-    // "somebody wrote in it" from "it is gone", because both fail the
-    // byte-equality test (`lib/base-files.ts`). `init` writes all five, so the
-    // state does not arise on a folder brain. The hosted half CAN arrive
-    // without them, which is why it answers the question separately.
-    filled: BASE_FILES.filter((f) => !untouched.has(f.path)).map((f) => f.path),
+    unfilled: BASE_FILES.filter((f) => unwritten.has(f.path)),
+    // A file that is not there reads as written here. That is a choice kept
+    // from before, not something this side cannot tell: `init` writes all
+    // five, so the state does not arise on a folder brain, and asking about a
+    // file that is gone would send an agent to revise a ref that does not
+    // exist. The hosted half CAN arrive without them, and says so (`missing`).
+    filled: BASE_FILES.filter((f) => !unwritten.has(f.path)).map((f) => f.path),
     missing: []
   };
 }
@@ -18639,7 +18646,7 @@ async function hostedSurvey(where) {
   const state = (file) => {
     const content = contents.get(file.path);
     if (content === void 0) return "missing";
-    return isUntouchedBase(file.path, content) ? "unfilled" : "filled";
+    return isUnwrittenBody(file.path, content) ? "unfilled" : "filled";
   };
   return {
     identity: { brain: where.name, brain_id: where.brainId },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memgineering",
-  "version": "0.25.2",
+  "version": "0.25.3",
   "private": false,
   "description": "One memory for the AI you connect. Recall, remember, and revise a brain your agents share — stored in your own folder.",
   "license": "Apache-2.0",