hypomnema 1.9.0 → 1.9.1

package/hooks/hypo-shared.mjs

@@ -584,7 +584,11 @@ export function gitDirtyFiles(dir = HYPO_DIR, opts = {}) {
     t1 === undefined ? { encoding: 'utf-8' } : { encoding: 'utf-8', timeout: t1 },
   );
   if (prefixRes.error || prefixRes.status !== 0) return []; // can't resolve the repo → cannot attribute
-  const prefix = (prefixRes.stdout || '').trim();
+  // Only the line ending is git's framing (LF, or CRLF where git writes one). The
+  // prefix is a real path segment, so a leading or trailing space in a parent
+  // directory name belongs to it; trim() would make every path under that vault
+  // read as foreign.
+  const prefix = (prefixRes.stdout || '').replace(/\r?\n$/, '');
 
   const t2 = remainingSpawnTimeoutMs(deadline);
   if (t2 === 0) return [];
@@ -813,11 +817,11 @@ export function sessionLogScopePath(hypoDir, project, date) {
  * the project slug from anything that follows by whitespace, a colon, or
  * end-of-line, so the lookahead correctly rejects "session | foo-bar" when
  * looking for "foo". Both delimiters are canonical: the derive path
- * (rootLogEntry) emits `<project> — <title>` (space), while the dominant
- * hand-written convention is `<project>: <title>` (colon, since the tone rule
- * banned the em dash). The colon must be accepted: without it, a close whose
- * only log.md evidence used the colon form was misread as "stale" and blocked
- * non-deterministically. (Was a pre-existing boundary bug in
+ * (rootLogEntry) now emits `<project>: <title>` (colon, since the tone rule
+ * banned the em dash), and log.md files written by earlier versions carry
+ * `<project>` + space + em dash + `<title>`, which must keep matching. The colon must be
+ * accepted: without it, a close whose only log.md evidence used the colon form
+ * was misread as "stale" and blocked non-deterministically. (Was a pre-existing boundary bug in
  * sessionCloseFileStatus that the helper extraction inherited.)
  */
 export function hasLogEntry(content, date, project) {
@@ -1789,15 +1793,14 @@ function backUpOnce(hotPath, content, testHooks) {
  * one must never proceed once this step has been skipped by a thrown error.
  * @returns {boolean} true when the file was actually changed
  */
-function ensureVaultGitignorePattern(hypoDir, pattern) {
+export function ensureVaultGitignorePattern(hypoDir, pattern) {
   const path = join(hypoDir, '.gitignore');
   const content = existsSync(path) ? readFileSync(path, 'utf-8') : '';
   if (content.split('\n').some((l) => l.trim() === pattern)) return false;
-  const next =
-    content.length > 0 && !content.endsWith('\n')
-      ? `${content}\n${pattern}\n`
-      : `${content}${pattern}\n`;
-  atomicWrite(path, next);
+  // An append, not a rewrite: the file may be a symlink into a dotfiles repo, have a mode of
+  // its own, or be saved by an editor at this moment; a replace would change the first two
+  // and could drop the third.
+  appendFileSync(path, `${content.length > 0 && !content.endsWith('\n') ? '\n' : ''}${pattern}\n`);
   return true;
 }
 
@@ -2908,10 +2911,21 @@ function deriveLogTitle(tail) {
  */
 export function rootLogEntry(slug, date, headingTail) {
   const title = deriveLogTitle(headingTail);
-  const heading = `## [${date}] session | ${slug}` + (title ? ` — ${title}` : '');
+  const heading = `## [${date}] session | ${slug}` + (title ? `: ${title}` : '');
   return { heading, block: `${heading}\n→ [[projects/${slug}/hot]]` };
 }
 
+/**
+ * The form of a log.md line that rootLogEntry's exact-line dedup compares. Earlier
+ * versions wrote an em dash after the slug; this one writes `## [d] session | slug: title`. A
+ * log.md that already carries the old heading must count as having the entry, or
+ * the next derive appends the same session a second time. Only the separator right
+ * after the slug is rewritten, so every other line is returned as it came.
+ */
+export function rootLogHeadingKey(line) {
+  return String(line).replace(/^(## \[[^\]]*\] session \| [^\s:]+) — /, '$1: ');
+}
+
 /**
  * Append any missing root log.md `## [date] session | <slug>` entries derived from
  * each today-active project's session-log heading(s). Idempotent: dedups on the
@@ -3194,9 +3208,10 @@ export function deriveRootLogEntries(hypoDir) {
   }
 
   // Exact-LINE dedup: a titleless heading (`## [d] session | a`) is a substring/
-  // prefix of a titled one (`## [d] session | a — first`), so substring checks
-  // would wrongly drop a distinct same-day session. Track whole heading lines.
-  const seenHeadings = new Set((logContent || '').split(/\r?\n/));
+  // prefix of a titled one (`## [d] session | a: first`), so substring checks
+  // would wrongly drop a distinct same-day session. Track whole heading lines,
+  // with an old em dash heading read as its colon form.
+  const seenHeadings = new Set((logContent || '').split(/\r?\n/).map(rootLogHeadingKey));
   const additions = [];
   for (const slug of todayActive) {
     // Guard: only the log.md entry may be the gap; an otherwise-incomplete close
@@ -3256,7 +3271,7 @@ export function deriveRootLogEntries(hypoDir) {
       } catch {
         return 0;
       }
-      const seen = new Set((current || '').split(/\r?\n/));
+      const seen = new Set((current || '').split(/\r?\n/).map(rootLogHeadingKey));
       const fresh = additions.filter(({ heading }) => {
         if (seen.has(heading)) return false;
         seen.add(heading);
@@ -4280,7 +4295,7 @@ export function commitWikiChanges(hypoDir, paths) {
   const prefixRes = git('rev-parse', '--show-prefix');
   if (prefixRes.status !== 0)
     return { committed: false, reason: `git rev-parse --show-prefix failed in ${hypoDir}` };
-  const prefix = (prefixRes.stdout || '').replace(/\n$/, '');
+  const prefix = (prefixRes.stdout || '').replace(/\r?\n$/, '');
   const toVaultRelative = (f) => {
     if (!f || !prefix) return f || null;
     return f.startsWith(prefix) ? f.slice(prefix.length) : null;
@@ -6125,9 +6140,11 @@ export function precompactGateStatus(hypoDir, opts = {}) {
       );
       if (r.error || r.status === null) {
         skipped.feedback = true; // spawn failure → fail-open
-      } else if (r.status !== 0) {
-        // Only a non-zero exit carries an actionable issue. A clean check exits 0
-        // (the implicit else below) — that is NOT skipped, just nothing to do.
+      } else {
+        // A non-zero exit carries an actionable issue. A clean check exits 0 and is NOT
+        // skipped, just nothing to do, except that its report can still carry
+        // sideWarnings (a hand-written feedback_<slug>.md in the way): those exit 0, so
+        // the report is read for them too.
         let report = null;
         try {
           report = JSON.parse(r.stdout || '');
@@ -6138,7 +6155,11 @@ export function precompactGateStatus(hypoDir, opts = {}) {
         const conflictedT = entries
           .filter(
             ([, t]) =>
-              t.intruder || t.unpaired || t.outOfContainer || (t.conflicts && t.conflicts.length),
+              t.intruder ||
+              t.unpaired ||
+              t.outOfContainer ||
+              (t.conflicts && t.conflicts.length) ||
+              (t.sideEdited && t.sideEdited.length),
           )
           .map(([n]) => n);
         const overCapT = entries.filter(([, t]) => t.overCap).map(([n]) => n);
@@ -6165,14 +6186,15 @@ export function precompactGateStatus(hypoDir, opts = {}) {
         // gets bypassed.
         const sideWarnT = entries.filter(([, t]) => (t.sideWarnings || []).length);
         if (
-          !report ||
-          !(
-            conflictedT.length ||
-            overCapT.length ||
-            driftedT.length ||
-            buildErrT.length ||
-            sideWarnT.length
-          )
+          r.status !== 0 &&
+          (!report ||
+            !(
+              conflictedT.length ||
+              overCapT.length ||
+              driftedT.length ||
+              buildErrT.length ||
+              sideWarnT.length
+            ))
         ) {
           skipped.feedback = true; // unparseable / non-actionable → fail-open
         } else if (buildErrT.length) {
@@ -6193,9 +6215,30 @@ export function precompactGateStatus(hypoDir, opts = {}) {
             reason: `feedback projection cannot be built — ${details} — no rules are loaded from it. ${remedies}`,
           });
         } else if (conflictedT.length) {
+          // The remedy text comes from the report (feedback-sync names the real
+          // slugs and leaves out --accept-wiki for an unpaired file). A report from an
+          // older installed script has none, and this hook cannot tell from the report
+          // which of its shapes is the right way out (the import command it used to
+          // fall back to does nothing for an intruder-only target), so that target gets
+          // a generic pointer and no state-specific command.
+          const remedies = [
+            ...new Set(
+              entries
+                .filter(([n]) => conflictedT.includes(n))
+                .map(([, t]) =>
+                  typeof t.conflictRemedy === 'string' && t.conflictRemedy
+                    ? t.conflictRemedy
+                    : 'the installed feedback-sync sent no remedy for this target (its version differs from this hook): run `hypomnema feedback-sync --check` for the details, and update Hypomnema so the hook and the script match.',
+                ),
+            ),
+          ].join(' ');
           blockers.push({
             type: 'feedback',
-            reason: `feedback projection conflict (manual edit of ${conflictedT.join(', ')}) — run \`hypomnema feedback-sync --import-target-change --from=<memory|claude>\``,
+            // reasons are rendered with an appended period and joined with ', ', so
+            // the full-sentence remedy loses its own final period here (CLI and doctor keep it)
+            reason:
+              `feedback projection conflict (manual edit of ${conflictedT.join(', ')}): ` +
+              remedies.replace(/\.$/, ''),
           });
         } else if (overCapT.length) {
           blockers.push({
@@ -6209,14 +6252,26 @@ export function precompactGateStatus(hypoDir, opts = {}) {
             reason: `feedback projection drift (${driftedT.join(', ')}) — will self-heal at /compact`,
           });
         }
-        // Additive, and deliberately outside the chain above: a side-file I/O
-        // problem is orthogonal to the primary target's health, so it is a notice
-        // whatever else is (or is not) going on. It names the path and the
-        // permission fix, because that — not a command — is the way out.
+        // Additive, and deliberately outside the chain above: a side-file problem
+        // is orthogonal to the primary target's health, so it is a notice whatever
+        // else is (or is not) going on. Two kinds reach here. "cannot read side
+        // file" is an I/O error whose only way out is a permission bit on that
+        // path (`--ensure-container` cannot touch it), so only that kind carries
+        // the permissions advice. "not overwriting ..." is feedback-sync declining
+        // to replace a hand-written file that lacks its provenance header; the
+        // warning text already says to rename or delete it, and calling it
+        // unreadable or pointing at permissions would be wrong. The reason has no
+        // trailing period: the hook that renders it appends one.
         for (const [n, t] of sideWarnT) {
+          const unreadable = t.sideWarnings.some((w) => w.startsWith('cannot read side file'));
           notices.push({
             type: 'feedback',
-            reason: `feedback projection side file unreadable (${n}): ${t.sideWarnings.join('; ')} — fix the permissions on that path; the primary projection still loads every rule (\`--ensure-container\` does not fix this)`,
+            reason:
+              `feedback projection side file warning (${n}): ${t.sideWarnings.join('; ')}. ` +
+              'The primary projection still loads every rule' +
+              (unreadable
+                ? '. Fix the permissions on that path; --ensure-container does not fix this'
+                : ''),
           });
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hypomnema",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "description": "LLM-native personal wiki system for Claude Code",
   "type": "module",
   "license": "MIT",
@@ -27,6 +27,7 @@
     "scripts/upgrade.mjs",
     "scripts/verify.mjs",
     "scripts/weekly-report.mjs",
+    "scripts/lib/code-fence.mjs",
     "scripts/lib/core-hooks.mjs",
     "scripts/lib/crystallize-args.mjs",
     "scripts/lib/crystallize-close-apply.mjs",

package/scripts/crystallize.mjs

@@ -15,9 +15,9 @@
  *   --check-session-close    Verify the strict session-close memory files: 4 mandatory + open-questions conditional
  *   --project=<slug>         Override the recency-inferred project on --check / --mark (single segment
  *                            [A-Za-z0-9._-]+, projects/<slug>/ must exist). On --check it NARROWS the
- *                            gate to that one project — a project-scoped diagnostic, NOT a global
- *                            compact-ready verdict. On --mark it is ATTRIBUTION only; the gate stays
- *                            global (the marker == compact-ready invariant). Ignored on --apply.
+ *                            gate to that one project: a project-scoped diagnostic, NOT a global
+ *                            close verdict. On --mark it is ATTRIBUTION only; the gate stays
+ *                            global (the marker gate is the global gate with the git axis narrowed). Ignored on --apply.
  *   --apply-session-close    Apply a JSON payload that updates the 4 mandatory memory files
  *                            (+ optional open-questions). Idempotent — re-running with the same
  *                            payload is a no-op. Always finishes with the strict gate check.

package/scripts/doctor.mjs

@@ -2170,7 +2170,12 @@ function checkFeedbackProjection(hypoDir, claudeHome, projectId) {
 
   // 1) integrity violations → FAIL
   const broken = targets.find(
-    ([, t]) => (t.conflicts && t.conflicts.length) || t.unpaired || t.intruder || t.outOfContainer,
+    ([, t]) =>
+      (t.conflicts && t.conflicts.length) ||
+      t.unpaired ||
+      t.intruder ||
+      t.outOfContainer ||
+      (t.sideEdited && t.sideEdited.length),
   );
   if (broken) {
     const [name, t] = broken;
@@ -2181,10 +2186,19 @@ function checkFeedbackProjection(hypoDir, claudeHome, projectId) {
           ? 'unpaired managed marker'
           : t.intruder
             ? 'hand-edited line inside managed region'
-            : 'managed block outside its container';
+            : t.outOfContainer
+              ? 'managed block outside its container'
+              : `side file edited after it was generated (${t.sideEdited.join(', ')})`;
     fail(
       'Feedback projection integrity',
-      `${name}: ${reason} — run \`hypomnema feedback-sync --import-target-change\` to reconcile`,
+      // feedback-sync decides the remedy by shape (import and accept for a
+      // conflicting block, move the lines for an intruder, repair for unpaired
+      // markers). An older installed script that does not send one gets a generic
+      // pointer: the import command it used to get is only right when a block is in
+      // conflict.
+      `${name}: ${reason}. ` +
+        (t.conflictRemedy ||
+          'The installed feedback-sync sent no remedy for this target (its version differs from this doctor): run `hypomnema feedback-sync --check` for the details, and update Hypomnema so the script matches.'),
     );
   } else {
     // 2) build error. Split by kind:
@@ -2245,10 +2259,14 @@ function checkFeedbackProjection(hypoDir, claudeHome, projectId) {
   //    touch. feedback-sync already put the path in the message.
   for (const [name, t] of targets) {
     for (const w of t.sideWarnings || []) {
+      // The advice follows the kind, as in the PreCompact gate: only an unreadable file
+      // is a permission problem; "not overwriting ..." already says to rename or delete.
       warn(
         'Feedback projection side file',
-        `${name}: ${w} — fix the permissions on that path; the primary projection still loads ` +
-          `(\`--ensure-container\` does not fix this)`,
+        `${name}: ${w}. ` +
+          (w.startsWith('cannot read side file')
+            ? 'fix the permissions on that path; the primary projection still loads (`--ensure-container` does not fix this)'
+            : 'the primary projection still loads every rule'),
       );
     }
   }