memoryintel 1.1.2 → 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.2"
+    "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.2"
+      "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.2",
+  "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

@@ -176,7 +176,10 @@ async function main() {
             const result = await runUpdate(root, planText);
             // root printed first, same reasoning as load/status: a wrong-directory update should
             // never be silent.
-            process.stdout.write(`root: ${root}\nApplied: ${result.applied.join(', ') || '(none)'}\nSkipped: ${result.skipped.join(', ') || '(none)'}\n`);
+            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
@@ -129,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,7 +3,7 @@ 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';
@@ -27,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.
@@ -42,7 +82,19 @@ 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
@@ -56,27 +108,58 @@ export function runLoad(cwd, domain) {
             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,
             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
         });
@@ -90,5 +173,5 @@ export function runLoad(cwd, domain) {
     // 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}\n${sections.join('\n')}`;
+    return `root: ${root}\n${manifest}${domainIndex}\n${sections.join('\n')}`;
 }

package/dist/commands/update.js

@@ -6,11 +6,12 @@ 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 {
@@ -21,7 +22,11 @@ export async function runUpdate(root, planText) {
         // Dashboard visibility is best-effort — never let it break `update`.
     }
     const rows = decodePlanRows(planText);
-    return withLock(join(root, '.lock'), () => {
+    // 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/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.2",
+  "version": "1.1.3",
   "description": "Persistent, cross-session project memory for AI coding agents.",
   "type": "module",
   "bin": {