memoryintel 1.0.0

package/dist/daemon/views/layout.js

@@ -0,0 +1,233 @@
+export function escapeHtml(s) {
+    return s
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+// Tiers a recency value (days since some event) into the tool's one signature device: a
+// three-step freshness read (fresh / aging / stale) used consistently for both "when did we
+// last see this project" and "when was this memory file last touched" — the two questions
+// this whole dashboard exists to answer at a glance.
+export function freshnessTier(daysAgo) {
+    if (daysAgo === null || daysAgo > 7)
+        return 'stale';
+    if (daysAgo <= 1)
+        return 'fresh';
+    return 'aging';
+}
+export function daysSince(iso) {
+    return Math.floor((Date.now() - new Date(iso).getTime()) / (24 * 60 * 60 * 1000));
+}
+// A day-only label ("0d ago") is indistinguishable for anything from just now up to almost 24h
+// old - on an actively-worked project nearly every file lands in that bucket, making the
+// dashboard's staleness read useless right when it matters most. Minutes/hours below the 24h
+// mark, days once it's crossed.
+export function formatAge(ms) {
+    const totalMinutes = Math.floor(Math.max(0, ms) / 60000);
+    if (totalMinutes < 1)
+        return 'just now';
+    if (totalMinutes < 60)
+        return `${totalMinutes}m ago`;
+    const totalHours = Math.floor(totalMinutes / 60);
+    if (totalHours < 24)
+        return `${totalHours}h ago`;
+    const totalDays = Math.floor(totalHours / 24);
+    return `${totalDays}d ago`;
+}
+const DISPLAY_FONT = `Georgia, 'Iowan Old Style', 'Palatino Linotype', 'Book Antiqua', serif`;
+const BODY_FONT = `-apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif`;
+const MONO_FONT = `'SF Mono', 'Cascadia Code', 'JetBrains Mono', Consolas, 'Liberation Mono', monospace`;
+const BASE_STYLES = `
+  :root {
+    color-scheme: light dark;
+    --bg: #F6F3EC;
+    --surface: #FFFFFF;
+    --ink: #211D17;
+    --muted: #736B5C;
+    --accent: #A8752C;
+    --border: rgba(33, 29, 23, 0.14);
+    --fresh: #3F7D52;
+    --aging: #B8853A;
+    --stale: #A8514A;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --bg: #16130F;
+      --surface: #201C16;
+      --ink: #EEE8DA;
+      --muted: #A79D8C;
+      --accent: #E3AE58;
+      --border: rgba(238, 232, 218, 0.16);
+      --fresh: #6FAE82;
+      --aging: #D9A653;
+      --stale: #D97C74;
+    }
+  }
+
+  * { box-sizing: border-box; }
+  body {
+    font-family: ${BODY_FONT};
+    background: var(--bg);
+    color: var(--ink);
+    max-width: 720px;
+    margin: 3rem auto;
+    padding: 0 1.25rem 4rem;
+    line-height: 1.55;
+  }
+  h1, h2, h3 { font-family: ${DISPLAY_FONT}; line-height: 1.2; font-weight: 600; margin: 0 0 0.5rem; }
+  h1 { font-size: 1.6rem; }
+  h2 { font-size: 1.15rem; margin-top: 2rem; color: var(--muted); font-weight: 600; letter-spacing: 0.01em; }
+  a { color: var(--accent); text-decoration: none; }
+  a:hover, a:focus-visible { text-decoration: underline; }
+  a:focus-visible, summary:focus-visible, button:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+
+  .eyebrow {
+    font-family: ${MONO_FONT};
+    font-size: 0.72rem;
+    letter-spacing: 0.12em;
+    text-transform: uppercase;
+    color: var(--muted);
+    margin-bottom: 0.35rem;
+  }
+  .path {
+    font-family: ${MONO_FONT};
+    font-size: 0.82rem;
+    color: var(--muted);
+    word-break: break-all;
+  }
+
+  .card {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-left: 3px solid var(--border);
+    border-radius: 6px;
+    padding: 1.1rem 1.2rem;
+    margin-bottom: 1rem;
+    animation: rise 0.25s ease-out backwards;
+  }
+  .card.fresh { border-left-color: var(--fresh); }
+  .card.aging { border-left-color: var(--aging); }
+  .card.stale { border-left-color: var(--stale); }
+  .card:nth-of-type(2) { animation-delay: 0.03s; }
+  .card:nth-of-type(3) { animation-delay: 0.06s; }
+  .card:nth-of-type(4) { animation-delay: 0.09s; }
+  @keyframes rise {
+    from { opacity: 0; transform: translateY(4px); }
+    to { opacity: 1; transform: translateY(0); }
+  }
+  @media (prefers-reduced-motion: reduce) {
+    .card { animation: none; }
+  }
+
+  .muted { opacity: 0.75; color: var(--muted); font-size: 0.9em; }
+  .missing { opacity: 0.6; font-style: italic; }
+
+  .mental-model {
+    font-family: ${DISPLAY_FONT};
+    font-size: 1.15rem;
+    font-style: italic;
+    border-left: 3px solid var(--accent);
+    padding-left: 1rem;
+    margin: 0.5rem 0 0;
+    white-space: pre-wrap;
+  }
+
+  pre {
+    font-family: ${MONO_FONT};
+    font-size: 0.85rem;
+    white-space: pre-wrap;
+    word-break: break-word;
+    background: color-mix(in srgb, currentColor 6%, transparent);
+    padding: 0.75rem;
+    border-radius: 6px;
+    margin: 0.5rem 0 0;
+  }
+
+  .tag {
+    display: inline-block;
+    font-family: ${MONO_FONT};
+    font-size: 0.72rem;
+    border-radius: 999px;
+    padding: 0.15em 0.75em;
+    background: color-mix(in srgb, currentColor 10%, transparent);
+    margin: 0 0.4em 0.4em 0;
+  }
+
+  details {
+    border-bottom: 1px solid var(--border);
+    padding: 0.5rem 0;
+  }
+  details:last-child { border-bottom: none; }
+  summary {
+    cursor: pointer;
+    font-family: ${MONO_FONT};
+    font-size: 0.88rem;
+  }
+  summary .stale-label.fresh { color: var(--fresh); }
+  summary .stale-label.aging { color: var(--aging); }
+  summary .stale-label.stale { color: var(--stale); }
+
+  .timeline-entry {
+    position: relative;
+    padding-left: 1rem;
+    border-left: 2px solid var(--border);
+    padding-bottom: 1rem;
+    margin-bottom: 0;
+  }
+  .timeline-entry:last-child { padding-bottom: 0; }
+  .timeline-files { display: block; font-family: var(--mono, monospace); font-size: 0.82em; }
+  .timeline-entry::before {
+    content: '';
+    position: absolute;
+    left: -5px;
+    top: 0.3rem;
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--accent);
+  }
+
+  .empty-state {
+    font-family: ${DISPLAY_FONT};
+    font-style: italic;
+    color: var(--muted);
+    padding: 2rem 0;
+  }
+
+  .dashboard-controls {
+    margin-top: 3rem;
+    padding-top: 1.5rem;
+    border-top: 1px solid var(--border);
+  }
+  .btn-stop {
+    font-family: ${BODY_FONT};
+    font-size: 0.85rem;
+    font-weight: 600;
+    color: var(--stale);
+    background: color-mix(in srgb, var(--stale) 10%, var(--surface));
+    border: 1px solid var(--stale);
+    border-radius: 6px;
+    padding: 0.5rem 1rem;
+    cursor: pointer;
+  }
+  .btn-stop:hover { background: color-mix(in srgb, var(--stale) 18%, var(--surface)); }
+`;
+export function pageShell(title, bodyHtml) {
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(title)}</title>
+<style>${BASE_STYLES}</style>
+</head>
+<body>
+${bodyHtml}
+</body>
+</html>`;
+}

package/dist/daemon/views/projectPage.js

@@ -0,0 +1,111 @@
+import { existsSync, readFileSync } from 'node:fs';
+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 { escapeHtml, pageShell, freshnessTier, formatAge } from './layout.js';
+function renderFileBrowser(memoryRoot) {
+    const groups = {};
+    for (const file of WRITABLE_FILES) {
+        if (file === 'context/currentMentalModel.md')
+            continue;
+        const [domain] = file.split('/');
+        (groups[domain] ??= []).push(file);
+    }
+    const health = computeFileHealth(memoryRoot);
+    const healthByFile = Object.fromEntries(health.map((h) => [h.file, h]));
+    const sections = Object.entries(groups).map(([domain, files]) => {
+        const items = files.map((file) => {
+            const path = join(memoryRoot, file);
+            const content = existsSync(path) ? readFileSync(path, 'utf-8').trim() : '';
+            const staleness = healthByFile[file]?.staleDays;
+            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`;
+            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}`;
+    });
+    return sections.join('\n');
+}
+function readEvents(memoryRoot) {
+    const eventsPath = join(memoryRoot, 'memory-events.jsonl');
+    if (!existsSync(eventsPath))
+        return [];
+    return readFileSync(eventsPath, 'utf-8').trim().split('\n').filter(Boolean).map((l) => JSON.parse(l));
+}
+// `session-load` events exist for KPI analysis (how often is this project's memory actually
+// read, how many tokens does a session bootstrap cost), not to narrate "what changed" - the
+// question this timeline exists to answer. A `load` fires every session start, so mixing it in
+// unfiltered would bury real content changes under routine reads. Still fully inspectable via
+// ?type=session-load - this only affects the unfiltered default view.
+const TELEMETRY_ONLY_TYPES = new Set(['session-load']);
+function renderEventTimeline(memoryRoot, typeFilter) {
+    const events = readEvents(memoryRoot);
+    if (events.length === 0)
+        return '<p class="muted">No events yet.</p>';
+    const filtered = typeFilter
+        ? events.filter((e) => e.type === typeFilter)
+        : events.filter((e) => !TELEMETRY_ONLY_TYPES.has(e.type));
+    if (filtered.length === 0)
+        return '<p class="muted">No events match this filter.</p>';
+    // update() logs one event per file it writes, not one per `update` call - a single logical
+    // checkpoint spanning N files (e.g. currentMentalModel.md + progress.md for the same change)
+    // produces N events with the identical, agent-written `summary` text. Without the affected
+    // file shown, two such events render as indistinguishable back-to-back lines - reads as a
+    // duplicate even though they're two real, distinct writes. See business/roadmap.md "Next".
+    return filtered.slice().reverse().map((e) => {
+        const files = Array.isArray(e.affectedFiles) ? e.affectedFiles : [];
+        const filesLabel = files.length > 0 ? `<span class="muted timeline-files">${escapeHtml(files.join(', '))}</span>` : '';
+        return `<div class="timeline-entry"><span class="tag">${escapeHtml(e.type)}</span>${escapeHtml(e.summary)} ${filesLabel}<div class="muted">${escapeHtml(e.timestamp)}</div></div>`;
+    }).join('\n');
+}
+// KPI summary for `session-load` events: how often this project's memory is actually read, and
+// roughly how much it costs per read. `totalChars` on each event is what was actually loaded at
+// that moment - avgTokens is a ~4-chars/token estimate (a standard approximation, not a real
+// tokenizer count; load time has no access to one).
+function renderSessionActivity(memoryRoot, projectRoot) {
+    const loads = readEvents(memoryRoot).filter((e) => e.type === 'session-load');
+    if (loads.length === 0)
+        return '<p class="muted">No session loads recorded yet.</p>';
+    const totalChars = loads.reduce((sum, e) => sum + (typeof e.totalChars === 'number' ? e.totalChars : 0), 0);
+    const avgTokens = Math.round(totalChars / loads.length / 4);
+    const last = loads[loads.length - 1];
+    const filterHref = `/project?path=${encodeURIComponent(projectRoot)}&type=session-load`;
+    return `<p><strong>${loads.length}</strong> session load(s) recorded &middot; avg ~${avgTokens} tokens/load (est.) &middot; last: ${formatAge(Date.now() - new Date(last.timestamp).getTime())}</p>
+<p class="muted"><a href="${escapeHtml(filterHref)}">view raw load events</a></p>`;
+}
+export function renderProjectPage(projectRoot, options = {}) {
+    const memoryRoot = join(projectRoot, '.memoryintel');
+    const mentalModelPath = join(memoryRoot, 'context', 'currentMentalModel.md');
+    const mentalModel = existsSync(mentalModelPath) ? readFileSync(mentalModelPath, 'utf-8').trim() : '(no mental model yet)';
+    const tools = detectToolsWired(projectRoot);
+    const toolsHtml = tools.map((t) => `<span class="tag">${escapeHtml(t)}</span>`).join('') || '<span class="muted">no tools wired</span>';
+    const body = `
+<a href="/">&larr; All projects</a>
+<div class="eyebrow" style="margin-top: 1rem;">${escapeHtml(basename(projectRoot))}</div>
+<h1>${escapeHtml(basename(projectRoot))}</h1>
+<div class="path">${escapeHtml(projectRoot)}</div>
+
+<h2>Current understanding</h2>
+<div class="mental-model">${escapeHtml(mentalModel)}</div>
+
+<h2>Automation status</h2>
+<p>${toolsHtml}</p>
+
+<h2>Session activity</h2>
+${renderSessionActivity(memoryRoot, projectRoot)}
+
+<h2>Memory files</h2>
+${renderFileBrowser(memoryRoot)}
+
+<h2>Event timeline</h2>
+${renderEventTimeline(memoryRoot, options.typeFilter)}
+`;
+    return pageShell(projectRoot, body);
+}

package/dist/daemon/views/registryPage.js

@@ -0,0 +1,54 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { escapeHtml, pageShell, freshnessTier, daysSince } from './layout.js';
+function mentalModelPreview(projectPath) {
+    const path = join(projectPath, '.memoryintel', 'context', 'currentMentalModel.md');
+    if (!existsSync(path))
+        return '(no mental model yet)';
+    return readFileSync(path, 'utf-8').trim().split('\n')[0] ?? '(empty)';
+}
+const DASHBOARD_CONTROLS = `
+<div class="dashboard-controls">
+  <form method="POST" action="/stop">
+    <button type="submit" class="btn-stop">Stop dashboard</button>
+  </form>
+  <p class="muted">Stops the daemon and disables the dashboard for every Memory Intel project on this machine. <code>memoryintel dashboard enable</code> turns it back on, or it starts itself again the next time any project needs it.</p>
+</div>
+`;
+export function renderRegistryPage(entries) {
+    const projectPaths = Object.keys(entries);
+    if (projectPaths.length === 0) {
+        return pageShell('Memory Intel', `
+<div class="eyebrow">Memory Intel</div>
+<h1>Project registry</h1>
+<p class="empty-state">No projects registered yet. Run <code>memoryintel init</code> in a project to see it here.</p>
+${DASHBOARD_CONTROLS}
+`);
+    }
+    const cards = projectPaths.map((path) => {
+        const entry = entries[path];
+        if (!existsSync(path)) {
+            return `<div class="card missing stale">
+  <strong>${escapeHtml(basename(path))}</strong>
+  <div class="path">${escapeHtml(path)}</div>
+  <p>(missing — this project's directory no longer exists)</p>
+</div>`;
+        }
+        const preview = mentalModelPreview(path);
+        const tier = freshnessTier(daysSince(entry.lastSessionAt));
+        const tools = entry.toolsWired.map((t) => `<span class="tag">${escapeHtml(t)}</span>`).join('') || '<span class="muted">no tools wired</span>';
+        return `<div class="card ${tier}">
+  <h3><a href="/project?path=${encodeURIComponent(path)}">${escapeHtml(basename(path))}</a></h3>
+  <div class="path">${escapeHtml(path)}</div>
+  <p class="mental-model" style="font-size: 1rem; margin-top: 0.6rem;">${escapeHtml(preview)}</p>
+  <p class="muted">Last session: ${escapeHtml(entry.lastSessionAt)}</p>
+  <p>${tools}</p>
+</div>`;
+    });
+    return pageShell('Memory Intel', `
+<div class="eyebrow">Memory Intel</div>
+<h1>Project registry</h1>
+${cards.join('\n')}
+${DASHBOARD_CONTROLS}
+`);
+}

package/dist/skill.js

@@ -0,0 +1,46 @@
+import { USAGE } from './cli.js';
+export function createSkillMarkdown() {
+    return `---
+name: memoryintel
+description: Give an AI coding agent persistent, cross-session project memory. Use when the user asks to set up persistent project memory, or when the current project already contains a .memoryintel/ directory.
+---
+
+# Memory Intel
+
+Memory Intel gives an AI coding agent durable, cross-session understanding of a project —
+architecture, decisions, progress, and a running "mental model" — that survives new chats, new
+agent sessions, and switching tools entirely (Claude Code, Cursor, Codex, Gemini CLI).
+
+## First time in this project? (no \`.memoryintel/\` yet)
+
+If the user asks to set up persistent project memory, run:
+
+    npx -y memoryintel init
+
+This is a one-time step. It scaffolds \`.memoryintel/\` and installs pointer files for tools without
+native hook support (Cursor, Codex, Gemini CLI, opencode) — safe to re-run later, it never
+overwrites existing content. Claude Code automation doesn't come from this command at all: it comes
+from the memoryintel plugin's own bundled hooks, active globally for every project once the plugin
+itself is installed — \`init\` never touches \`.claude/settings.json\`.
+
+## Already initialized? (\`.memoryintel/\` exists)
+
+Read \`.memoryintel/instructions.md\` first — it is the authoritative, per-project guide. In short:
+
+- At the start of a session: run \`memoryintel load [--domain technical|business|research]\` and
+  treat the output as project context.
+- At the end of a session, only if your work changed real project understanding (new architecture,
+  decision, feature, integration, or roadmap item — never for formatting/typos): draft an
+  update-plan and run \`memoryintel update\`.
+- If the user asks to turn the dashboard on or off: \`memoryintel dashboard enable\` /
+  \`memoryintel dashboard disable\`.
+
+## Command reference
+
+${USAGE}
+## Sandboxed environments
+
+If \`npx\`/a global \`memoryintel\` install aren't directly runnable, fall back to invoking the
+package's built CLI directly: \`node "$(npm root -g)/memoryintel/dist/cli.js" <command>\`.
+`;
+}

package/dist/templates/starterFiles.js

@@ -0,0 +1,22 @@
+export const STARTER_FILES = [
+    { relPath: 'context/projectBrief.md', headings: ['Overview'] },
+    { relPath: 'context/objectives.md', headings: ['Objectives'] },
+    { relPath: 'context/activeContext.md', headings: ['Current Focus'] },
+    { relPath: 'context/decisions.md', headings: ['Decisions Log'] },
+    { relPath: 'context/progress.md', headings: ['Status'] },
+    { relPath: 'context/learnings.md', headings: ['Learnings'] },
+    { relPath: 'technical/architecture.md', headings: ['Overview', 'Components', 'Data Flow', 'Integrations'] },
+    { relPath: 'technical/techContext.md', headings: ['Stack', 'Conventions', 'Environment'] },
+    { relPath: 'technical/patterns.md', headings: ['Design Patterns', 'Anti-Patterns'] },
+    { relPath: 'technical/integrations.md', headings: ['External Services', 'Internal Dependencies'] },
+    { relPath: 'technical/infrastructure.md', headings: ['Deployment', 'Hosting', 'CI/CD'] },
+    { relPath: 'business/productContext.md', headings: ['Product Overview', 'Users', 'Value Proposition'] },
+    { relPath: 'business/roadmap.md', headings: ['Now', 'Next', 'Later'] },
+    { relPath: 'business/stakeholders.md', headings: ['Team', 'External Stakeholders'] },
+    { relPath: 'business/marketContext.md', headings: ['Market Overview', 'Competitors'] },
+    { relPath: 'research/findings.md', headings: ['Key Findings'] },
+    { relPath: 'research/references.md', headings: ['Sources'] },
+    { relPath: 'research/hypotheses.md', headings: ['Open Hypotheses'] }
+];
+// No headings — always fully overwritten by `update`, never section-addressed.
+export const MENTAL_MODEL_STARTER = '_No sessions yet._\n';

package/hooks/hooks.json

@@ -0,0 +1,11 @@
+{
+  "description": "Load and maintain persistent project memory automatically",
+  "hooks": {
+    "SessionStart": [
+      { "hooks": [{ "type": "command", "command": "npx -y memoryintel load" }] }
+    ],
+    "Stop": [
+      { "hooks": [{ "type": "command", "command": "npx -y memoryintel check-stop" }] }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "memoryintel",
+  "version": "1.0.0",
+  "description": "Persistent, cross-session project memory for AI coding agents.",
+  "type": "module",
+  "bin": {
+    "memoryintel": "./dist/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/adeeshsharma/memoryintel.git"
+  },
+  "homepage": "https://github.com/adeeshsharma/memoryintel#readme",
+  "bugs": {
+    "url": "https://github.com/adeeshsharma/memoryintel/issues"
+  },
+  "author": {
+    "name": "Adeesh Sharma",
+    "url": "https://github.com/adeeshsharma"
+  },
+  "keywords": [
+    "ai-agent",
+    "claude-code",
+    "cli",
+    "memory",
+    "context",
+    "skill",
+    "mcp"
+  ],
+  "license": "MIT",
+  "files": [
+    "dist",
+    "skills",
+    ".claude-plugin",
+    "hooks"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/build-skill.js && node scripts/ensure-executable.mjs",
+    "build:skill": "node scripts/build-skill.js",
+    "build:skill:check": "node scripts/build-skill.js --check",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0",
+    "@types/node": "^20.0.0"
+  }
+}

package/skills/memoryintel/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: memoryintel
+description: Give an AI coding agent persistent, cross-session project memory. Use when the user asks to set up persistent project memory, or when the current project already contains a .memoryintel/ directory.
+---
+
+# Memory Intel
+
+Memory Intel gives an AI coding agent durable, cross-session understanding of a project —
+architecture, decisions, progress, and a running "mental model" — that survives new chats, new
+agent sessions, and switching tools entirely (Claude Code, Cursor, Codex, Gemini CLI).
+
+## First time in this project? (no `.memoryintel/` yet)
+
+If the user asks to set up persistent project memory, run:
+
+    npx -y memoryintel init
+
+This is a one-time step. It scaffolds `.memoryintel/` and installs pointer files for tools without
+native hook support (Cursor, Codex, Gemini CLI, opencode) — safe to re-run later, it never
+overwrites existing content. Claude Code automation doesn't come from this command at all: it comes
+from the memoryintel plugin's own bundled hooks, active globally for every project once the plugin
+itself is installed — `init` never touches `.claude/settings.json`.
+
+## Already initialized? (`.memoryintel/` exists)
+
+Read `.memoryintel/instructions.md` first — it is the authoritative, per-project guide. In short:
+
+- At the start of a session: run `memoryintel load [--domain technical|business|research]` and
+  treat the output as project context.
+- At the end of a session, only if your work changed real project understanding (new architecture,
+  decision, feature, integration, or roadmap item — never for formatting/typos): draft an
+  update-plan and run `memoryintel update`.
+- If the user asks to turn the dashboard on or off: `memoryintel dashboard enable` /
+  `memoryintel dashboard disable`.
+
+## Command reference
+
+Usage: memoryintel <command> [options]
+
+Commands:
+  init [path]              Initialize .memoryintel/ in the current or given directory
+  load [--domain <d>]      Print resolved memory context to stdout
+  update <plan.toon|->     Apply an update-plan (file path, or - for stdin)
+  status                   Print a human-readable summary of current memory state
+  check-stop               Stop-hook check: emit a JSON allow/block decision
+  dashboard <enable|disable>  Turn the shared local dashboard on or off
+  daemon start             Run the dashboard daemon in the foreground (usually auto-started)
+
+An update-plan row may set kind=compress to compact an oversized section; update() only applies
+such a row when its target file is currently git-clean.
+
+## Sandboxed environments
+
+If `npx`/a global `memoryintel` install aren't directly runnable, fall back to invoking the
+package's built CLI directly: `node "$(npm root -g)/memoryintel/dist/cli.js" <command>`.