memoryintel 1.1.1 → 1.1.3

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Persistent, cross-session project memory for AI coding agents.",
-    "version": "1.1.1"
+    "version": "1.1.3"
   },
   "plugins": [
     {
       "name": "memoryintel",
       "source": "./",
       "description": "Persistent project memory for AI coding agents — initialize once, then agents automatically load and update project understanding across sessions.",
-      "version": "1.1.1"
+      "version": "1.1.3"
     }
   ]
 }

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "memoryintel",
   "description": "Persistent project memory for AI coding agents — initialize once, then agents automatically load and update project understanding across sessions.",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "author": {
     "name": "Adeesh Sharma",
     "url": "https://github.com/adeeshsharma"

package/README.md

@@ -176,7 +176,7 @@ systems: 85–93%), despite solving a different problem (durable project state,
 history).
 
 **Why the gap widens over time, not just per-call:** `.memoryintel/` content is self-compressing,
-capped at ~300 lines per file by default — load cost stays roughly flat as a project grows. The
+capped at ~12,000 chars per file by default — load cost stays roughly flat as a project grows. The
 no-memory alternative doesn't; it scales with total codebase size. A project one day old and one
 a year old cost about the same to bootstrap with Memory Intel. Without it, the older project costs
 more, every single session.

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { readFileSync, realpathSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { findMemoryIntelRoot } from './core/discovery.js';
 import { runUpdate } from './commands/update.js';
@@ -13,6 +13,26 @@ import { runCheckStop } from './adapters/claudeCode.js';
 import { runDashboardEnable, runDashboardDisable } from './commands/dashboardToggle.js';
 import { runDaemonStart } from './commands/daemonStart.js';
 import { runDoctor } from './commands/doctor.js';
+// Every command below that resolves .memoryintel/ by walking up from a starting directory
+// previously always used process.cwd() with no override - meaning a long, multi-project
+// session had to religiously `cd` before every single call, with silently-wrong output the
+// only feedback for getting it wrong (mitigated separately by printing the resolved root, but
+// that only helps you NOTICE the mistake, not avoid making it). --root <path> lets a caller
+// that already knows its target project say so directly; MEMORYINTEL_ROOT is the same thing
+// as an env var, for a session-start hook or similar context where passing an extra CLI flag
+// isn't convenient. --root wins when both are given. Either way this is resolved exactly like
+// process.cwd() always was - a starting point findMemoryIntelRoot() walks up from, not
+// required to already BE the exact .memoryintel directory itself.
+function resolveStartDir(argv) {
+    const rootFlagIndex = argv.indexOf('--root');
+    if (rootFlagIndex !== -1 && argv[rootFlagIndex + 1]) {
+        return resolve(process.cwd(), argv[rootFlagIndex + 1]);
+    }
+    if (process.env.MEMORYINTEL_ROOT) {
+        return resolve(process.cwd(), process.env.MEMORYINTEL_ROOT);
+    }
+    return process.cwd();
+}
 export const USAGE = `Usage: memoryintel <command> [options]
 
 Commands:
@@ -52,24 +72,24 @@ export function dispatch(argv) {
         case 'load': {
             const domainFlagIndex = argv.indexOf('--domain');
             const domain = domainFlagIndex !== -1 ? argv[domainFlagIndex + 1] : undefined;
-            const output = runLoad(process.cwd(), domain);
+            const output = runLoad(resolveStartDir(argv), domain);
             return { exitCode: 0, stdout: output, stderr: '' };
         }
         case 'status': {
-            const root = findMemoryIntelRoot(process.cwd());
+            const root = findMemoryIntelRoot(resolveStartDir(argv));
             if (!root)
                 return { exitCode: 1, stdout: '', stderr: 'No .memoryintel/ found.\n' };
             return { exitCode: 0, stdout: runStatus(root), stderr: '' };
         }
         case 'check-stop': {
-            const root = findMemoryIntelRoot(process.cwd());
+            const root = findMemoryIntelRoot(resolveStartDir(argv));
             if (!root)
                 return { exitCode: 0, stdout: '', stderr: '' };
             const result = runCheckStop(root);
             return { exitCode: 0, stdout: JSON.stringify(result) + '\n', stderr: '' };
         }
         case 'doctor': {
-            const root = findMemoryIntelRoot(process.cwd());
+            const root = findMemoryIntelRoot(resolveStartDir(argv));
             if (!root)
                 return { exitCode: 1, stdout: '', stderr: 'No .memoryintel/ found.\n' };
             const force = argv.includes('--force');
@@ -130,13 +150,18 @@ async function main() {
             return;
         }
         if (command === 'update') {
-            const root = findMemoryIntelRoot(process.cwd());
+            const root = findMemoryIntelRoot(resolveStartDir(argv));
             if (!root) {
                 process.stderr.write('No .memoryintel/ found.\n');
                 process.exitCode = 1;
                 return;
             }
-            const source = argv[1] ?? '-';
+            // The plan-file path is the first REMAINING positional argument after stripping the
+            // command name itself and a --root <path> pair, if given - otherwise "--root"'s own
+            // value would get misread as the plan-file path.
+            const rootFlagIndex = argv.indexOf('--root');
+            const positional = argv.filter((_, i) => i !== 0 && i !== rootFlagIndex && i !== rootFlagIndex + 1);
+            const source = positional[0] ?? '-';
             const planText = source === '-' ? readFileSync(0, 'utf-8') : readFileSync(source, 'utf-8');
             // Caught live: an agent ran bare `memoryintel update` (no plan-file argument, no piped
             // stdin) as a one-shot Bash tool call. `source` defaulted to '-' (read stdin), stdin was
@@ -144,12 +169,17 @@ async function main() {
             // generic "Malformed TOON table header" error - true, but useless for figuring out what
             // actually went wrong. This is the one case worth naming explicitly before it gets there.
             if (planText.trim().length === 0) {
-                process.stderr.write('memoryintel: No update-plan given. Pass a TOON plan file (`memoryintel update <path>`) or pipe TOON content via stdin. See .memoryintel/instructions.md for the update-plan format.\n');
+                process.stderr.write('memoryintel: No update-plan given. Pass a plan file (TOON or JSON, `memoryintel update <path>`) or pipe it via stdin. See .memoryintel/instructions.md for the update-plan format.\n');
                 process.exitCode = 1;
                 return;
             }
             const result = await runUpdate(root, planText);
-            process.stdout.write(`Applied: ${result.applied.join(', ') || '(none)'}\nSkipped: ${result.skipped.join(', ') || '(none)'}\n`);
+            // root printed first, same reasoning as load/status: a wrong-directory update should
+            // never be silent.
+            const overCeilingLine = result.overCeiling.length > 0
+                ? `Over ceiling (consider compressing): ${result.overCeiling.join(', ')}\n`
+                : '';
+            process.stdout.write(`root: ${root}\nApplied: ${result.applied.join(', ') || '(none)'}\nSkipped: ${result.skipped.join(', ') || '(none)'}\n${overCeilingLine}`);
             process.exitCode = 0;
             return;
         }

package/dist/commands/init.js

@@ -28,9 +28,16 @@ time. Both commands are safe to run more than once - \`import\`'s already-import
 skipped, not duplicated, and \`scan\` never writes anything at all.
 
 ## Session start
-Run \`memoryintel load [--domain technical|business|research]\` and treat its output as project context.
-Its manifest reports each loaded file's \`lines\`, \`ceiling\`, and \`status\` (\`over\`/\`under\`) — see
-"Compaction" below for what to do about a file marked \`over\`.
+Run \`memoryintel load\` (no arguments — the hook does this automatically) and treat its output as
+project context. Its manifest reports each loaded file's \`lines\`, \`ceiling\`, and \`status\`
+(\`over\`/\`under\`) — see "Compaction" below for what to do about a file marked \`over\`.
+
+\`load\` with no \`--domain\` automatically carries forward whichever domain the most recent
+\`update\` actually touched, so continuing yesterday's technical work loads \`technical/*\` again
+without you having to ask for it. The one case this doesn't cover is deliberately switching to a
+domain nothing was just written to — check the "Other memory available" list at the bottom of
+\`load\`'s output and, if the task is about a topic listed there, run
+\`memoryintel load --domain <domain>\` yourself before continuing.
 
 ## Session end
 If your work changed project understanding (new architecture, feature, decision, integration, or
@@ -62,6 +69,14 @@ outright rather than degrading gracefully, so match it exactly rather than impro
 - \`context/currentMentalModel.md\` is the one exception to \`action\`: its row's \`content\` replaces
   the file's entire content verbatim, regardless of what \`action\`/\`section\` say.
 
+**\`update\` also accepts a plain JSON array of the same rows instead of TOON**, auto-detected by
+whether the file/stdin content starts with \`[\` or \`{\` after trimming - if you'd rather
+\`JSON.stringify\` a plan than hand-write TOON's quoting rule above, this is the safer default:
+\`[{"file": "path/to/file.md", "action": "append", "section": "Section Heading", "content": "New
+paragraph to add.", "reason": "Why this changed"}]\`. Same fields, same required order doesn't
+matter (JSON is keyed, not positional), same \`context/currentMentalModel.md\` exception. Neither
+format is preferred - use whichever you're less likely to get wrong.
+
 Also include a row for \`context/currentMentalModel.md\` whenever the update is more than a small,
 localized fact — anything that shifts what the project *is* or where it currently stands (not
 every single decision/progress entry needs one). Unlike every other file, it is a **whole-file
@@ -121,8 +136,10 @@ recoverable from git history — it just won't be loaded by default anymore. Bec
   your summary can't answer, you compressed too much — keep more.
 
 The ceiling itself is configurable in \`memory-config.json\` under a \`compression\` key
-(\`defaultCeilingLines\`, and optional \`domainOverrides\` keyed by domain, e.g. \`"technical": 500\`)
-— the built-in default is 300 lines if unset.
+(\`defaultCeilingChars\`, and optional \`domainOverrides\` keyed by domain, e.g. \`"technical": 20000\`)
+— the built-in default is 12000 chars if unset. \`update\` also flags a file that crosses the
+ceiling right after the write that pushed it over, in the same turn — don't wait for the next
+\`load\` to notice.
 
 ## Dashboard
 If the user asks to turn off the dashboard/web UI, run \`memoryintel dashboard disable\`. This is a

package/dist/commands/load.js

@@ -3,10 +3,11 @@ import { join, dirname } from 'node:path';
 import { findMemoryIntelRoot } from '../core/discovery.js';
 import { extractHeadings } from '../core/headingMatch.js';
 import { encodeToonTable } from '../core/toon.js';
-import { getCeilingLines, countLines } from '../core/compressionConfig.js';
+import { getCeilingChars, countLines } from '../core/compressionConfig.js';
 import { ensureDaemonRunning } from '../daemon/lifecycle.js';
 import { upsertRegistryEntry } from '../daemon/registry.js';
 import { appendEvent } from '../core/eventLog.js';
+import { readIndex } from '../core/memoryIndex.js';
 const ALWAYS_LOAD = ['context/currentMentalModel.md', 'context/activeContext.md'];
 const DOMAIN_FILES = {
     technical: ['technical/architecture.md', 'technical/techContext.md', 'technical/patterns.md'],
@@ -26,6 +27,46 @@ function assertKnownDomain(domain) {
         throw new UnknownDomainError(domain);
     }
 }
+function domainOf(relFile) {
+    const segment = relFile.split('/')[0];
+    return Object.prototype.hasOwnProperty.call(DOMAIN_FILES, segment) ? segment : null;
+}
+// A heading-only index of unloaded domain files is a nudge, not a guarantee - nothing forces an
+// agent to notice it and pass --domain. Carrying forward whichever domain the *previous* session
+// actually wrote to removes the agent's judgment from the common case entirely: if last session's
+// work touched business/roadmap.md, this session's bare `load` (no --domain given, which is all
+// the SessionStart hook ever passes) already includes that domain, because it's the domain most
+// likely still relevant. Only switching to a domain untouched in the most recent write still
+// depends on the agent reading the "Other memory available" index below and acting on it.
+function inferRecentDomain(eventsPath) {
+    if (!existsSync(eventsPath))
+        return null;
+    let lines;
+    try {
+        lines = readFileSync(eventsPath, 'utf-8').trim().split('\n').filter(Boolean);
+    }
+    catch {
+        return null;
+    }
+    for (let i = lines.length - 1; i >= 0; i--) {
+        let event;
+        try {
+            event = JSON.parse(lines[i]);
+        }
+        catch {
+            continue;
+        }
+        if (!event || typeof event !== 'object')
+            continue;
+        const { type, affectedFiles } = event;
+        if (type !== 'memory-update' || !Array.isArray(affectedFiles))
+            continue;
+        const domain = typeof affectedFiles[0] === 'string' ? domainOf(affectedFiles[0]) : null;
+        if (domain)
+            return domain;
+    }
+    return null;
+}
 export function runLoad(cwd, domain) {
     // Validate before touching disk so a bad --domain always produces a clear, named error
     // rather than spreading `undefined` out of DOMAIN_FILES.
@@ -41,35 +82,84 @@ export function runLoad(cwd, domain) {
     catch {
         // Dashboard visibility is best-effort — never let it break `load`.
     }
-    const files = [...ALWAYS_LOAD, ...(domain ? DOMAIN_FILES[domain] : [])];
+    // An explicit --domain always wins. Only when the caller (in practice: the SessionStart hook,
+    // which never passes --domain) leaves it unset do we fall back to the last-touched domain.
+    let effectiveDomain = domain;
+    let domainSource = domain ? 'explicit' : null;
+    if (effectiveDomain === undefined) {
+        const inferred = inferRecentDomain(join(root, 'memory-events.jsonl'));
+        if (inferred) {
+            effectiveDomain = inferred;
+            domainSource = 'auto';
+        }
+    }
+    const files = [...ALWAYS_LOAD, ...(effectiveDomain ? DOMAIN_FILES[effectiveDomain] : [])];
+    const loadedSet = new Set(files);
     const sections = [];
     const manifestRows = [];
+    // `status` already surfaces lastUpdated from this same index - `load` is the one command
+    // instructions.md tells every session to run FIRST, though, and previously gave zero signal
+    // for "just updated" vs. "nobody has touched this in months" without a separate `status`
+    // call nothing prompts an agent to make.
+    const index = readIndex(join(root, 'memory-index.json'));
     for (const relFile of files) {
         const absPath = join(root, relFile);
         if (!existsSync(absPath))
             continue;
         const content = readFileSync(absPath, 'utf-8');
         const lines = countLines(content);
-        const ceiling = getCeilingLines(root, relFile);
-        const status = lines > ceiling ? 'over' : 'under';
+        const ceiling = getCeilingChars(root, relFile);
+        const status = content.length > ceiling ? 'over' : 'under';
         sections.push(`--- FILE: ${relFile} ---\n${content}`);
         manifestRows.push({
             file: relFile,
             headings: extractHeadings(content).join('|'),
             lines: String(lines),
+            chars: String(content.length),
             ceiling: String(ceiling),
-            status
+            status,
+            lastUpdated: index[relFile]?.lastUpdated ?? 'never'
         });
     }
+    // Domain files exist only to be pulled in via `load --domain <d>`, which nothing prompts an
+    // agent to do proactively - in practice this leaves them written by `update()` but never read
+    // back. A heading-only index (no content, so this costs tens of tokens rather than the
+    // hundreds/thousands a full domain would) at least makes their existence and topic visible on
+    // every load, so an agent can decide to pull one in instead of the content silently going
+    // stale and unread.
+    const domainIndexRows = [];
+    for (const [domainName, domainFiles] of Object.entries(DOMAIN_FILES)) {
+        for (const relFile of domainFiles) {
+            if (loadedSet.has(relFile))
+                continue;
+            const absPath = join(root, relFile);
+            if (!existsSync(absPath))
+                continue;
+            const content = readFileSync(absPath, 'utf-8');
+            domainIndexRows.push({
+                domain: domainName,
+                file: relFile,
+                headings: extractHeadings(content).join('|'),
+                lines: String(countLines(content))
+            });
+        }
+    }
+    const domainIndex = domainIndexRows.length > 0
+        ? `\nOther memory available (not loaded — run \`memoryintel load --domain <domain>\` to include):\n${encodeToonTable(domainIndexRows)}`
+        : '';
     try {
         const totalChars = sections.reduce((sum, s) => sum + s.length, 0);
         const totalLines = manifestRows.reduce((sum, r) => sum + Number(r.lines), 0);
+        const domainLabel = effectiveDomain
+            ? ` (domain: ${effectiveDomain}${domainSource === 'auto' ? ', auto-carried from last update' : ''})`
+            : '';
         appendEvent(join(root, 'memory-events.jsonl'), {
             timestamp: new Date().toISOString(),
             type: 'session-load',
-            summary: `Loaded ${manifestRows.length} file(s)${domain ? ` (domain: ${domain})` : ''}`,
+            summary: `Loaded ${manifestRows.length} file(s)${domainLabel}`,
             affectedFiles: manifestRows.map((r) => r.file),
-            domain: domain ?? null,
+            domain: effectiveDomain ?? null,
+            domainSource,
             totalChars,
             totalLines
         });
@@ -78,5 +168,10 @@ export function runLoad(cwd, domain) {
         // KPI telemetry is best-effort - never let logging a load break the load itself.
     }
     const manifest = encodeToonTable(manifestRows);
-    return `${manifest}\n${sections.join('\n')}`;
+    // A leading, plainly-labeled root line - silently loading the wrong project's (or wrong
+    // worktree/branch's) memory has happened in practice: findMemoryIntelRoot() walks up from
+    // cwd with no built-in visibility into which root it actually found, so confidently-wrong
+    // content came back with nothing to flag it. This is always the first thing printed,
+    // whether or not --domain is given.
+    return `root: ${root}\n${manifest}${domainIndex}\n${sections.join('\n')}`;
 }

package/dist/commands/status.js

@@ -3,8 +3,12 @@ import { join } from 'node:path';
 import { readIndex } from '../core/memoryIndex.js';
 export function runStatus(root) {
     const lines = [];
+    // Always first: silently reading the wrong project's (or wrong worktree/branch's) memory
+    // has happened in practice - findMemoryIntelRoot() walks up from cwd with no built-in
+    // visibility into which root it actually resolved.
+    lines.push('=== Root ===', root);
     const mentalModelPath = join(root, 'context', 'currentMentalModel.md');
-    lines.push('=== Current Mental Model ===');
+    lines.push('', '=== Current Mental Model ===');
     lines.push(existsSync(mentalModelPath) ? readFileSync(mentalModelPath, 'utf-8').trim() : '(none)');
     lines.push('', '=== Memory Index ===');
     const index = readIndex(join(root, 'memory-index.json'));

package/dist/commands/update.js

@@ -1,16 +1,17 @@
 import { readFileSync } from 'node:fs';
 import { join, posix, dirname } from 'node:path';
-import { decodeToonTable } from '../core/toon.js';
+import { decodePlanRows } from '../core/toon.js';
 import { applySectionUpdate, isNearDuplicate, getSectionContent } from '../core/sectionWriter.js';
 import { assertSafePath } from '../core/pathSafety.js';
 import { upsertIndexEntry } from '../core/memoryIndex.js';
 import { appendEvent } from '../core/eventLog.js';
 import { atomicWriteFile } from '../core/atomicWrite.js';
-import { withLock } from '../core/lock.js';
+import { withLocks } from '../core/lock.js';
 import { ensureDaemonRunning } from '../daemon/lifecycle.js';
 import { upsertRegistryEntry } from '../daemon/registry.js';
 import { resolveCheckStopMarker } from '../adapters/claudeCode.js';
 import { isPathClean } from '../core/gitPorcelain.js';
+import { getCeilingChars } from '../core/compressionConfig.js';
 const MENTAL_MODEL_FILE = 'context/currentMentalModel.md';
 export async function runUpdate(root, planText) {
     try {
@@ -20,8 +21,12 @@ export async function runUpdate(root, planText) {
     catch {
         // Dashboard visibility is best-effort — never let it break `update`.
     }
-    const rows = decodeToonTable(planText);
-    return withLock(join(root, '.lock'), () => {
+    const rows = decodePlanRows(planText);
+    // Locking only the files this plan actually touches (rather than one project-wide lock) lets
+    // two update() calls on disjoint files - e.g. two subagents each owning a different domain -
+    // run concurrently instead of serializing on each other.
+    const lockPaths = [...new Set(rows.map((row) => `${assertSafePath(root, row.file)}.lock`))];
+    return withLocks(lockPaths, () => {
         // Phase 1: validate every entry against current disk state, compute the writes, write nothing yet.
         const writes = [];
         // Tracks each path's content as computed so far *this call*, so a second row targeting a
@@ -78,6 +83,7 @@ export async function runUpdate(root, planText) {
         // Phase 2: apply. Every entry above already validated, so this cannot fail on content grounds.
         const applied = [];
         const skipped = [];
+        const overCeiling = [];
         for (const w of writes) {
             if (w.skipped) {
                 // A dropped write is still a fact about this session — log it so `status` can show
@@ -101,8 +107,24 @@ export async function runUpdate(root, planText) {
                 affectedFiles: [w.relFile]
             });
             applied.push(w.relFile);
+            // The compression ceiling used to be purely advisory: `load()` would flag a file as
+            // "over" in its manifest, but nothing surfaced that until the *next* session bothered to
+            // read the manifest. Flagging it here, in the same turn that pushed a file over, means the
+            // agent that just wrote the content is the one told to compress it - the one with the most
+            // context to do so well - rather than leaving it for whoever loads next.
+            const ceiling = getCeilingChars(root, w.relFile);
+            if (w.newContent.length > ceiling) {
+                const reason = `${w.relFile} is ${w.newContent.length} chars, over its ${ceiling}-char ceiling — consider a compress row before the next session.`;
+                appendEvent(join(root, 'memory-events.jsonl'), {
+                    timestamp: new Date().toISOString(),
+                    type: 'over-ceiling',
+                    summary: reason,
+                    affectedFiles: [w.relFile]
+                });
+                overCeiling.push(w.relFile);
+            }
         }
         resolveCheckStopMarker(root);
-        return { applied, skipped };
+        return { applied, skipped, overCeiling };
     });
 }

package/dist/core/compressionConfig.js

@@ -1,8 +1,13 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-export const DEFAULT_CEILING_LINES = 300;
+// ~40 chars/line is a reasonable prose average, so this stays roughly equivalent to the old
+// 300-line default while actually measuring the thing that determines context cost: characters,
+// not lines. A file of long, dense lines and one of short, sparse lines could both read "300
+// lines" while costing very different amounts of context - line count was a proxy that stopped
+// tracking the number it was supposed to.
+export const DEFAULT_CEILING_CHARS = 12000;
 // Reads memory-config.json's optional `compression` block. Missing file, missing key, or
-// corrupt JSON all fall back to an empty config (which getCeilingLines then resolves to the
+// corrupt JSON all fall back to an empty config (which getCeilingChars then resolves to the
 // built-in default) — this is a read-time convenience for load()/the dashboard, never a place
 // that should throw and interrupt them.
 function readCompressionConfig(root) {
@@ -25,13 +30,13 @@ export function countLines(content) {
 }
 // relFile's first path segment (e.g. "technical" from "technical/architecture.md", or "context"
 // from "context/activeContext.md") is the domain domainOverrides keys against.
-export function getCeilingLines(root, relFile) {
+export function getCeilingChars(root, relFile) {
     const config = readCompressionConfig(root);
     const domain = relFile.split('/')[0];
     const override = config.domainOverrides?.[domain];
     if (typeof override === 'number')
         return override;
-    if (typeof config.defaultCeilingLines === 'number')
-        return config.defaultCeilingLines;
-    return DEFAULT_CEILING_LINES;
+    if (typeof config.defaultCeilingChars === 'number')
+        return config.defaultCeilingChars;
+    return DEFAULT_CEILING_CHARS;
 }

package/dist/core/lock.js

@@ -8,14 +8,10 @@ function sleep(ms) {
 function sleepSync(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
-export async function withLock(lockPath, fn, opts = {}) {
-    const retries = opts.retries ?? 100;
-    const delayMs = opts.delayMs ?? 20;
-    let fd = null;
+async function acquireLock(lockPath, retries, delayMs) {
     for (let attempt = 0; attempt <= retries; attempt++) {
         try {
-            fd = openSync(lockPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
-            break;
+            return openSync(lockPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
         }
         catch (err) {
             if (err.code !== 'EEXIST')
@@ -25,17 +21,37 @@ export async function withLock(lockPath, fn, opts = {}) {
             await sleep(delayMs);
         }
     }
+    throw new Error(`Timed out waiting for lock: ${lockPath}`);
+}
+// Acquires every lock in `lockPaths` (deduped, sorted into one global acquisition order so any
+// two callers that both need locks A and B can never deadlock by acquiring them in opposite
+// order) before running fn, releasing them all afterward even if fn throws. This is what lets a
+// caller lock only the specific files a given operation touches - e.g. update() locking just the
+// files named in its plan - instead of one project-wide lock that would serialize every update()
+// call against every other, even when they touch entirely disjoint files.
+export async function withLocks(lockPaths, fn, opts = {}) {
+    const retries = opts.retries ?? 100;
+    const delayMs = opts.delayMs ?? 20;
+    const sorted = [...new Set(lockPaths)].sort();
+    const fds = [];
     try {
+        for (const lockPath of sorted) {
+            fds.push(await acquireLock(lockPath, retries, delayMs));
+        }
         return await fn();
     }
     finally {
-        if (fd !== null)
-            closeSync(fd);
-        unlinkSync(lockPath);
+        // Release in reverse acquisition order; each lock is independent so any partial-acquisition
+        // failure above only needs to unwind what was actually opened, which the fds/sorted-prefix
+        // pairing here already reflects.
+        for (let i = fds.length - 1; i >= 0; i--) {
+            closeSync(fds[i]);
+            unlinkSync(sorted[i]);
+        }
     }
 }
-// Synchronous sibling of withLock, for callers on a synchronous public API (e.g. runLoad) that
-// cannot be made async without rippling out to every caller. Same atomic exclusive-create
+// Synchronous, single-lock sibling of withLocks, for callers on a synchronous public API (e.g.
+// runLoad) that cannot be made async without rippling out to every caller. Same atomic exclusive-create
 // technique; a shorter default retry budget since callers using this are on a hot, latency-
 // sensitive path and the critical section (spawnDaemonProcess is a non-blocking spawn().unref())
 // is expected to be sub-millisecond, not something worth blocking a CLI invocation over.

package/dist/core/sectionWriter.js

@@ -86,6 +86,30 @@ export function applySectionUpdate(markdown, section, action, content) {
     const result = [...before, ...newContentLines, ...after].join('\n');
     return result.endsWith('\n') ? result : result + '\n';
 }
+const DUPLICATE_STOPWORDS = new Set([
+    'the', 'and', 'for', 'are', 'was', 'were', 'with', 'this', 'that', 'from', 'have', 'has'
+]);
+// Words under 3 chars and common connectors are dropped before comparing - otherwise two
+// sentences sharing only "the", "and", "is" would register as near-duplicates of each other.
+function meaningfulTokens(s) {
+    return normalizeHeading(s)
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length >= 3 && !DUPLICATE_STOPWORDS.has(t));
+}
+const TOKEN_OVERLAP_THRESHOLD = 0.85;
 export function isNearDuplicate(existingBlock, newContent) {
-    return normalizeHeading(existingBlock).includes(normalizeHeading(newContent));
+    // Fast path: catches whitespace-only diffs and literal restatements.
+    if (normalizeHeading(existingBlock).includes(normalizeHeading(newContent)))
+        return true;
+    // Reordered/lightly-reworded restatements of the same fact aren't a literal substring of the
+    // existing block, so the check above misses them - which is exactly how the same fact
+    // re-enters memory in slightly different words each session, quietly working against
+    // self-compression. Below a handful of meaningful words, overlap ratios get noisy on trivial
+    // content, so short additions fall back to the literal check above only.
+    const newTokens = meaningfulTokens(newContent);
+    if (newTokens.length < 3)
+        return false;
+    const existingTokens = new Set(meaningfulTokens(existingBlock));
+    const overlap = newTokens.filter((t) => existingTokens.has(t)).length;
+    return overlap / newTokens.length >= TOKEN_OVERLAP_THRESHOLD;
 }

package/dist/core/toon.js

@@ -66,7 +66,10 @@ function parseCsvRows(text) {
         }
     }
     if (inQuotes) {
-        throw new Error('Malformed TOON table: unterminated quoted field.');
+        // rows.length is exactly how many COMPLETE rows were parsed before the failure - the
+        // failing row is the next one, at that same 0-indexed position (matching how a
+        // field-count-mismatch error below reports rowIndex).
+        throw new Error(`Malformed TOON table: unterminated quoted field in row ${rows.length}.`);
     }
     if (rowStarted)
         endRow();
@@ -116,3 +119,63 @@ export function decodeToonTable(text) {
         return row;
     });
 }
+const REQUIRED_PLAN_ROW_FIELDS = ['file', 'action', 'section', 'content', 'reason'];
+const OPTIONAL_PLAN_ROW_FIELDS = ['kind'];
+function decodeJsonPlan(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Malformed JSON plan: ${message}`);
+    }
+    if (!Array.isArray(parsed)) {
+        throw new Error('Malformed JSON plan: expected an array of rows.');
+    }
+    return parsed.map((row, rowIndex) => {
+        if (row === null || typeof row !== 'object' || Array.isArray(row)) {
+            throw new Error(`Malformed JSON plan: row ${rowIndex} must be an object.`);
+        }
+        const record = row;
+        for (const field of REQUIRED_PLAN_ROW_FIELDS) {
+            if (!(field in record)) {
+                throw new Error(`Malformed JSON plan: row ${rowIndex} is missing required field "${field}".`);
+            }
+        }
+        const result = {};
+        for (const field of [...REQUIRED_PLAN_ROW_FIELDS, ...OPTIONAL_PLAN_ROW_FIELDS]) {
+            if (!(field in record))
+                continue;
+            const value = record[field];
+            if (typeof value !== 'string') {
+                throw new Error(`Malformed JSON plan: row ${rowIndex}'s "${field}" must be a string.`);
+            }
+            result[field] = value;
+        }
+        return result;
+    });
+}
+/**
+ * Accepts either format update() itself needs to parse: TOON text (the
+ * default, more compact for a human/agent to scan), or a JSON array of the
+ * same row shape - auto-detected by a leading '[' after trimming, since a
+ * real TOON header always starts with the literal 'items['; this can never
+ * misfire on a genuinely malformed TOON table. JSON exists specifically so
+ * an agent that would rather JSON.stringify a plan than hand-author TOON's
+ * own quoting rules (double an internal '"' as '""', not backslash-escape
+ * it - a real, repeated mistake in practice, not hypothetical) never has to
+ * risk getting that escaping wrong at all. decodeToonTable itself is
+ * unchanged and still exported directly for anyone who wants TOON
+ * specifically.
+ */
+export function decodePlanRows(text) {
+    const trimmed = text.trimStart();
+    // A real TOON header never starts with '[' or '{' either (always the literal
+    // 'items[') - catching '{' too means a plan mistakenly wrapped as a single
+    // object instead of an array gets the clear "expected an array" error below,
+    // not an unrelated, confusing TOON header error.
+    if (trimmed.startsWith('[') || trimmed.startsWith('{'))
+        return decodeJsonPlan(trimmed);
+    return decodeToonTable(text);
+}

package/dist/daemon/registry.js

@@ -6,18 +6,15 @@ const MARKER = 'memoryintel:managed:start';
 export function detectToolsWired(projectRoot) {
     const tools = [];
     // Claude Code automation comes entirely from this package's bundled plugin
-    // (hooks/hooks.json), never from writing to the project's own .claude/settings.json - init
-    // has never touched that file (see src/commands/init.ts). Checking it here was dead code: it
-    // could never be true for any project using the documented setup, which is why a real project
-    // (distilled-docs) never showed claude-code despite Claude driving every session. The
-    // Stop-hook's `.session-marker.json` (written by check-stop / resolveCheckStopMarker, see
-    // src/adapters/claudeCode.ts) only ever exists once the plugin's Stop hook has actually fired
-    // for this project - real evidence of Claude Code automation running, not just installed.
-    // Still also honor a manually-wired settings.json, for anyone who set one up by hand.
-    const claudeSettingsPath = join(projectRoot, '.claude', 'settings.json');
-    const settingsWired = existsSync(claudeSettingsPath) && readFileSync(claudeSettingsPath, 'utf-8').includes('memoryintel load');
+    // (hooks/hooks.json), never from writing to the project's own .claude/settings.json - init has
+    // never touched that file. The Stop-hook's `.session-marker.json` (written by check-stop /
+    // resolveCheckStopMarker, see src/adapters/claudeCode.ts) only ever exists once the plugin's
+    // Stop hook has actually fired for this project - real evidence of Claude Code automation
+    // running, not just installed. A prior version of this check also looked for a hand-wired
+    // .claude/settings.json; dropped after confirming on a real project (distilled-docs) that
+    // nothing ever writes that file, so the check could never fire in practice.
     const sessionMarkerPath = join(projectRoot, '.memoryintel', '.session-marker.json');
-    if (settingsWired || existsSync(sessionMarkerPath)) {
+    if (existsSync(sessionMarkerPath)) {
         tools.push('claude-code');
     }
     if (existsSync(join(projectRoot, '.cursor', 'rules', 'memoryintel.mdc'))) {

package/dist/daemon/views/projectPage.js

@@ -3,7 +3,7 @@ import { join, basename } from 'node:path';
 import { WRITABLE_FILES } from '../../core/pathSafety.js';
 import { computeFileHealth } from '../health.js';
 import { detectToolsWired } from '../registry.js';
-import { getCeilingLines, countLines } from '../../core/compressionConfig.js';
+import { getCeilingChars } from '../../core/compressionConfig.js';
 import { escapeHtml, pageShell, freshnessTier, formatAge } from './layout.js';
 function renderFileBrowser(memoryRoot) {
     const groups = {};
@@ -23,10 +23,9 @@ function renderFileBrowser(memoryRoot) {
             const lastUpdated = healthByFile[file]?.lastUpdated;
             const tier = freshnessTier(staleness ?? null);
             const stalenessLabel = lastUpdated ? formatAge(Date.now() - new Date(lastUpdated).getTime()) : 'never updated';
-            const lines = countLines(content);
-            const ceiling = getCeilingLines(memoryRoot, file);
-            const sizeClass = lines > ceiling ? 'stale' : 'muted';
-            const sizeLabel = `${lines}/${ceiling} lines`;
+            const ceiling = getCeilingChars(memoryRoot, file);
+            const sizeClass = content.length > ceiling ? 'stale' : 'muted';
+            const sizeLabel = `${content.length}/${ceiling} chars`;
             return `<details><summary>${escapeHtml(file)} <span class="muted stale-label ${tier}">(${stalenessLabel})</span> <span class="${sizeClass}">${escapeHtml(sizeLabel)}</span></summary><pre>${escapeHtml(content || '(empty)')}</pre></details>`;
         }).join('\n');
         return `<h3>${escapeHtml(domain)}</h3>\n${items}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memoryintel",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Persistent, cross-session project memory for AI coding agents.",
   "type": "module",
   "bin": {