memoryintel 1.1.4 → 1.2.0

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Persistent, cross-session project memory for AI coding agents.",
-    "version": "1.1.4"
+    "version": "1.2.0"
   },
   "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.4"
+      "version": "1.2.0"
     }
   ]
 }

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.4",
+  "version": "1.2.0",
   "author": {
     "name": "Adeesh Sharma",
     "url": "https://github.com/adeeshsharma"

package/README.md

@@ -122,6 +122,10 @@ If a shared local dashboard is running (a read-only view of every initialized pr
 machine), turn it off any time with `memoryintel dashboard disable` — or back on with
 `memoryintel dashboard enable`.
 
+`memoryintel sync` re-runs automatic stack/integration/deployment fact detection by hand (see
+"How it works" below) — useful for debugging, or to see what it found without waiting for the
+next `load`/`check-stop`.
+
 ## Prerequisites
 
 Node.js ≥18 — actually verified as the real floor (CI runs the full suite on Node 18), not an
@@ -139,6 +143,14 @@ an update-plan and calls `update()`, which validates it, writes atomically under
 and logs the change — never a changelog, always a maintained understanding of the project as it
 currently is.
 
+A second, independent mechanism runs alongside the agent-driven one above: every `load` and
+`check-stop` call also auto-detects mechanically-verifiable stack, integration, and deployment
+facts (a dependency in `package.json`, a `vercel.json`, a `Dockerfile`) and writes them straight
+into `technical/techContext.md` / `integrations.md` / `infrastructure.md` — no agent judgment
+involved, no user action required. This is deliberately narrower than the agent-driven mechanism:
+it only ever asserts what it can prove from a file that's actually there. `memoryintel sync` runs
+the same detection by hand, for debugging.
+
 Full design docs live in `docs/superpowers/specs/`; a diagram-heavy architecture reference lives
 in `docs/architecture/memory-intel-architecture.html`. See `.memoryintel/context/decisions.md` in
 this very repository for the specific design decisions behind the mechanism above, with rationale.

package/dist/adapters/claudeCode.js

@@ -1,6 +1,12 @@
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { runGitStatusPorcelain, porcelainPath, runGitRevParseHead } from '../core/gitPorcelain.js';
+import { syncDetectedFacts } from '../core/factSync.js';
+// Same manifest filenames detectStack() (core/repoScan.ts) already recognizes - kept as a local
+// copy rather than importing repoScan's own internal list, since this is a small, stable set and
+// a shared-constant module for five string literals would be more machinery than the duplication
+// it avoids.
+const MANIFEST_FILES = new Set(['package.json', 'requirements.txt', 'pyproject.toml', 'go.mod', 'Cargo.toml']);
 function readMarker(markerPath) {
     if (!existsSync(markerPath))
         return { lastFlaggedDiffSignature: null };
@@ -79,10 +85,20 @@ export function runCheckStop(memoryRoot) {
         return {};
     }
     writeMarker(markerPath, { lastFlaggedDiffSignature: signature });
-    return {
-        decision: 'block',
-        reason: "Working tree has changes memory hasn't accounted for. Classify them, write a TOON update-plan, and run `memoryintel update <plan-file>` (see .memoryintel/instructions.md) before finishing - running `memoryintel update` bare, with no plan file, fails. Or finish again to proceed without updating this time."
-    };
+    let reason = "Working tree has changes memory hasn't accounted for. Classify them, write a TOON update-plan, and run `memoryintel update <plan-file>` (see .memoryintel/instructions.md) before finishing - running `memoryintel update` bare, with no plan file, fails. Or finish again to proceed without updating this time.";
+    // Mechanism 2 (see docs/superpowers/specs/2026-09-06-automatic-fact-detection-design.md): when
+    // the diff touches a manifest file, name specifically what auto-detection just found, so the
+    // agent's own follow-up judgment gets a concrete lead instead of only "something changed, go
+    // figure out what." This never changes the block/allow decision itself - only the reason text.
+    const statusLines = runGitStatusPorcelain(projectRoot);
+    const touchesManifest = statusLines !== null && statusLines.some((l) => MANIFEST_FILES.has(porcelainPath(l)));
+    if (touchesManifest) {
+        const syncResult = syncDetectedFacts(memoryRoot);
+        if (syncResult.written.length > 0) {
+            reason += ` Also: a manifest file changed — auto-detected facts were just written to ${syncResult.written.join(', ')}. Worth a note elsewhere (e.g. why it was added) if that's not just incidental.`;
+        }
+    }
+    return { decision: 'block', reason };
 }
 // Called after a successful `update`. Does NOT simply clear the marker to null — `update` only
 // writes to .memoryintel/, so the user's actual source diff that triggered the nudge (e.g. an

package/dist/cli.js

@@ -13,6 +13,7 @@ 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';
+import { syncDetectedFacts } from './core/factSync.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
@@ -45,6 +46,9 @@ Commands:
   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
+  sync                      Re-scan for stack/integration/deployment facts and write any new
+                            findings - runs automatically via load/check-stop; this is the
+                            manual/debugging entry point
   dashboard <enable|disable>  Turn the shared local dashboard on or off
   doctor [--force]         Refresh memoryintel's own generated files (instructions.md, pointer
                            blocks) to the current template wherever it's provably safe;
@@ -88,6 +92,16 @@ export function dispatch(argv) {
             const result = runCheckStop(root);
             return { exitCode: 0, stdout: JSON.stringify(result) + '\n', stderr: '' };
         }
+        case 'sync': {
+            const root = findMemoryIntelRoot(resolveStartDir(argv));
+            if (!root)
+                return { exitCode: 1, stdout: '', stderr: 'No .memoryintel/ found.\n' };
+            const result = syncDetectedFacts(root);
+            const stdout = result.written.length > 0
+                ? `root: ${root}\nUpdated: ${result.written.join(', ')}\n`
+                : `root: ${root}\nNo changes - detected facts already up to date.\n`;
+            return { exitCode: 0, stdout, stderr: '' };
+        }
         case 'doctor': {
             const root = findMemoryIntelRoot(resolveStartDir(argv));
             if (!root)

package/dist/commands/load.js

@@ -8,6 +8,7 @@ import { ensureDaemonRunning } from '../daemon/lifecycle.js';
 import { upsertRegistryEntry } from '../daemon/registry.js';
 import { appendEvent } from '../core/eventLog.js';
 import { readIndex } from '../core/memoryIndex.js';
+import { syncDetectedFacts } from '../core/factSync.js';
 const ALWAYS_LOAD = ['context/currentMentalModel.md', 'context/activeContext.md'];
 const DOMAIN_FILES = {
     technical: ['technical/architecture.md', 'technical/techContext.md', 'technical/patterns.md'],
@@ -75,6 +76,13 @@ export function runLoad(cwd, domain) {
     const root = findMemoryIntelRoot(cwd);
     if (!root)
         return '';
+    try {
+        syncDetectedFacts(root);
+    }
+    catch {
+        // Best-effort, same policy as the daemon-registry call just below - auto-detection must
+        // never be the reason a session-start load fails.
+    }
     try {
         ensureDaemonRunning();
         upsertRegistryEntry(dirname(root));

package/dist/commands/status.js

@@ -21,7 +21,8 @@ export function runStatus(root) {
         const eventLines = readFileSync(eventsPath, 'utf-8').trim().split('\n').filter(Boolean);
         for (const line of eventLines.slice(-5)) {
             const event = JSON.parse(line);
-            lines.push(`[${event.timestamp}] ${event.type}: ${event.summary}`);
+            const sourceTag = event.source ? ` (${event.source})` : '';
+            lines.push(`[${event.timestamp}] ${event.type}${sourceTag}: ${event.summary}`);
         }
     }
     return lines.join('\n') + '\n';

package/dist/commands/update.js

@@ -93,7 +93,8 @@ export async function runUpdate(root, planText) {
                     timestamp: new Date().toISOString(),
                     type: w.eventType,
                     summary: w.reason,
-                    affectedFiles: [w.relFile]
+                    affectedFiles: [w.relFile],
+                    source: 'agent'
                 });
                 skipped.push(w.relFile);
                 continue;
@@ -104,7 +105,8 @@ export async function runUpdate(root, planText) {
                 timestamp: new Date().toISOString(),
                 type: w.eventType,
                 summary: w.reason,
-                affectedFiles: [w.relFile]
+                affectedFiles: [w.relFile],
+                source: 'agent'
             });
             applied.push(w.relFile);
             // The compression ceiling used to be purely advisory: `load()` would flag a file as
@@ -119,7 +121,8 @@ export async function runUpdate(root, planText) {
                     timestamp: new Date().toISOString(),
                     type: 'over-ceiling',
                     summary: reason,
-                    affectedFiles: [w.relFile]
+                    affectedFiles: [w.relFile],
+                    source: 'agent'
                 });
                 overCeiling.push(w.relFile);
             }

package/dist/core/detectedBlock.js

@@ -0,0 +1,58 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { atomicWriteFile } from './atomicWrite.js';
+import { getSectionContent, applySectionUpdate } from './sectionWriter.js';
+export const DETECTED_START = '<!-- memoryintel:detected:start -->';
+export const DETECTED_END = '<!-- memoryintel:detected:end -->';
+function buildBlock(lines) {
+    return [DETECTED_START, ...lines, DETECTED_END].join('\n');
+}
+// Inserts or refreshes a memoryintel-owned "detected facts" block at the top of `heading`'s
+// section content in the markdown file at absPath - modeled on the existing pointer-block
+// mechanism in adapters/genericPointer.ts, generalized to work on an arbitrary heading inside an
+// arbitrary file instead of one hardcoded block in one hardcoded set of files.
+//
+// Never creates the file (a directory `init` hasn't touched is left alone - 'missing-file') and
+// never creates the heading either (`init`'s STARTER_FILES already ship every heading this is
+// ever pointed at; a project on an old template without it is simply skipped - 'missing-heading'
+// - rather than this feature mutating a file's structure it was never asked to manage).
+//
+// Content outside the markers - including agent-authored prose elsewhere in the very same
+// section, above or below the block - is preserved byte-for-byte. This is what makes it safe to
+// call this on every session start without ever risking real project understanding: the block is
+// fully machine-owned, and everything else in the file categorically is not.
+export function upsertDetectedBlock(absPath, heading, lines) {
+    if (!existsSync(absPath))
+        return 'missing-file';
+    const markdown = readFileSync(absPath, 'utf-8');
+    const sectionContent = getSectionContent(markdown, heading);
+    if (sectionContent === null)
+        return 'missing-heading';
+    const newBlock = buildBlock(lines);
+    const startIdx = sectionContent.indexOf(DETECTED_START);
+    const endIdx = sectionContent.indexOf(DETECTED_END);
+    let newSectionContent;
+    if (startIdx !== -1 && endIdx !== -1) {
+        const before = sectionContent.slice(0, startIdx);
+        const after = sectionContent.slice(endIdx + DETECTED_END.length);
+        newSectionContent = `${before}${newBlock}${after}`;
+    }
+    else {
+        // Fresh insertion (no existing block to slot into): `.trim()` here would swallow the blank
+        // line this project's own files (and getSectionContent's own single-blank-line stripping
+        // convention) always separate a heading, and every section, by - caught via dogfooding this
+        // feature on this very repo, where a fresh Stack block landed flush against `## Conventions`
+        // with zero blank line between them. The leading/trailing `\n` below combine with
+        // applySectionUpdate's own join('\n') separators (one on each side of this section's content)
+        // to reconstruct exactly one blank line after the heading and exactly one before whatever
+        // comes next (another heading, or end of file) - matching the surrounding blank-line rhythm
+        // instead of fighting it.
+        const rest = sectionContent.trim();
+        const body = rest.length > 0 ? `${newBlock}\n\n${rest}` : newBlock;
+        newSectionContent = `\n${body}\n`;
+    }
+    if (newSectionContent === sectionContent)
+        return 'unchanged';
+    const updated = applySectionUpdate(markdown, heading, 'replace', newSectionContent);
+    atomicWriteFile(absPath, updated);
+    return 'written';
+}

package/dist/core/factSync.js

@@ -0,0 +1,60 @@
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { detectStack } from './repoScan.js';
+import { matchKnownFacts } from './knownFacts.js';
+import { detectInfraSignals } from './infraSignals.js';
+import { upsertDetectedBlock } from './detectedBlock.js';
+import { upsertIndexEntry } from './memoryIndex.js';
+import { appendEvent } from './eventLog.js';
+import { withLockSync } from './lock.js';
+const TARGETS = [
+    { relFile: 'technical/techContext.md', heading: 'Stack' },
+    { relFile: 'technical/integrations.md', heading: 'External Services' },
+    { relFile: 'technical/infrastructure.md', heading: 'Deployment' }
+];
+// Automatically detects mechanically-verifiable stack/integration/deployment facts and writes
+// them into their managed detected-block (detectedBlock.ts), with zero agent or user action
+// required - called from both `load` (every session start) and `check-stop` (when the diff
+// touches a manifest file), plus manually via `memoryintel sync`. A no-op (missing-file, no
+// write, no event) on any target file `init` hasn't created - this feature is inert on an
+// uninitialized or partially-initialized project, never scaffolding structure of its own.
+export function syncDetectedFacts(memoryRoot) {
+    const projectRoot = dirname(memoryRoot);
+    const stack = detectStack(projectRoot);
+    const matched = matchKnownFacts(stack.dependencies);
+    const infraLines = detectInfraSignals(projectRoot);
+    const contentByTarget = {
+        'technical/techContext.md': matched.techContext.length > 0 ? matched.techContext.map((f) => `- ${f}`) : ['_No stack manifest found._'],
+        'technical/integrations.md': matched.integrations.length > 0
+            ? matched.integrations.map((f) => `- ${f}`)
+            : ['_No known integrations detected._'],
+        'technical/infrastructure.md': infraLines.length > 0 ? infraLines.map((f) => `- ${f}`) : ['_No deployment signal found in repo._']
+    };
+    const written = [];
+    for (const { relFile, heading } of TARGETS) {
+        const absPath = join(memoryRoot, relFile);
+        // Checked before locking, not just left to upsertDetectedBlock's own 'missing-file' return:
+        // withLockSync's openSync(..., O_CREAT) needs the file's parent directory to already exist to
+        // create the `.lock` file in - an uninitialized project (no .memoryintel/technical/ at all)
+        // would otherwise throw ENOENT here instead of the intended silent no-op.
+        if (!existsSync(absPath))
+            continue;
+        const lockPath = `${absPath}.lock`;
+        // Same lock-file naming as update()'s per-file locking (`${absPath}.lock`) - a concurrent
+        // agent-driven update() and this auto-sync touching the same file correctly serialize
+        // against each other instead of racing.
+        const result = withLockSync(lockPath, () => upsertDetectedBlock(absPath, heading, contentByTarget[relFile]));
+        if (result === 'written') {
+            upsertIndexEntry(join(memoryRoot, 'memory-index.json'), relFile, 'Auto-detected stack/integration facts (memoryintel sync)');
+            appendEvent(join(memoryRoot, 'memory-events.jsonl'), {
+                timestamp: new Date().toISOString(),
+                type: 'fact-sync',
+                summary: `Auto-detected facts written to ${relFile}`,
+                affectedFiles: [relFile],
+                source: 'auto-detect'
+            });
+            written.push(relFile);
+        }
+    }
+    return { written };
+}

package/dist/core/infraSignals.js

@@ -0,0 +1,75 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+// Presence-only, no version/config parsing. Vercel gets two independent signals
+// (vercel.json and .vercel/) since either alone is common depending on whether the project was
+// ever linked locally via `vercel link` vs. only ever deployed through the dashboard/CI.
+const FILE_SIGNALS = [
+    { relPath: 'vercel.json', fact: 'Vercel' },
+    { relPath: '.vercel', fact: 'Vercel' },
+    { relPath: 'netlify.toml', fact: 'Netlify' },
+    { relPath: 'Dockerfile', fact: 'Docker' },
+    { relPath: 'docker-compose.yml', fact: 'Docker Compose' },
+    { relPath: 'fly.toml', fact: 'Fly.io' },
+    { relPath: 'render.yaml', fact: 'Render' },
+    { relPath: 'wrangler.toml', fact: 'Cloudflare Workers (via Wrangler)' },
+    { relPath: 'Procfile', fact: 'Heroku (or Heroku-compatible, via Procfile)' }
+];
+// Known deploy-action name fragments to grep for inside .github/workflows/*.yml - deliberately
+// substring matches (not parsing the `uses:` field structurally), since a real YAML parser is
+// more machinery than a best-effort signal needs and every real deploy-action reference contains
+// one of these fragments regardless of version pin or org fork.
+const WORKFLOW_DEPLOY_ACTIONS = [
+    { fragment: 'vercel-action', fact: 'Vercel' },
+    { fragment: 'amondnet/vercel', fact: 'Vercel' },
+    { fragment: 'netlify/actions', fact: 'Netlify' },
+    { fragment: 'nwtgck/actions-netlify', fact: 'Netlify' },
+    { fragment: 'superfly/flyctl-actions', fact: 'Fly.io' },
+    { fragment: 'aws-actions/', fact: 'AWS (via GitHub Actions)' },
+    { fragment: 'google-github-actions/', fact: 'Google Cloud (via GitHub Actions)' },
+    { fragment: 'azure/webapps-deploy', fact: 'Azure' }
+];
+function detectWorkflowSignals(targetDir) {
+    const workflowsDir = join(targetDir, '.github', 'workflows');
+    if (!existsSync(workflowsDir))
+        return [];
+    let files;
+    try {
+        files = readdirSync(workflowsDir).filter((f) => f.endsWith('.yml') || f.endsWith('.yaml'));
+    }
+    catch {
+        return [];
+    }
+    const found = new Set();
+    for (const file of files) {
+        let content;
+        try {
+            content = readFileSync(join(workflowsDir, file), 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        for (const { fragment, fact } of WORKFLOW_DEPLOY_ACTIONS) {
+            if (content.includes(fragment)) {
+                found.add(`${fact} — via \`${file}\` GitHub Actions workflow`);
+            }
+        }
+    }
+    return [...found];
+}
+// Best-effort only, by design: no dependency-based signal exists for "where is this deployed"
+// (a project deployed via a hosting platform's dashboard, connected straight to its git remote,
+// can leave zero trace in the repo itself - confirmed on a real project during this feature's own
+// design). Returns an empty array when nothing is found; the caller decides how to render that
+// as an explicit "no signal" statement rather than silence (see factSync.ts).
+export function detectInfraSignals(targetDir) {
+    const found = new Set();
+    for (const { relPath, fact } of FILE_SIGNALS) {
+        if (existsSync(join(targetDir, relPath))) {
+            found.add(`${fact} — via \`${relPath}\``);
+        }
+    }
+    for (const line of detectWorkflowSignals(targetDir)) {
+        found.add(line);
+    }
+    return [...found];
+}

package/dist/core/knownFacts.js

@@ -0,0 +1,53 @@
+// A curated, deliberately small starter set covering common frameworks, CMS, DB, payment, and
+// auth libraries. Extending this is a one-line PR to this file - no plugin system needed at this
+// scale (see spec's "Non-goals").
+export const KNOWN_FACTS = [
+    { match: 'next', fact: 'Next.js (React framework)', target: 'techContext' },
+    { match: 'react', fact: 'React', target: 'techContext' },
+    { match: 'vue', fact: 'Vue', target: 'techContext' },
+    { match: 'svelte', fact: 'Svelte', target: 'techContext' },
+    { match: 'typescript', fact: 'TypeScript', target: 'techContext' },
+    { match: 'express', fact: 'Express', target: 'techContext' },
+    { match: 'fastify', fact: 'Fastify', target: 'techContext' },
+    { match: 'prisma', fact: 'Prisma (ORM)', target: 'techContext' },
+    { match: 'mongoose', fact: 'MongoDB (via Mongoose)', target: 'techContext' },
+    { match: 'tailwindcss', fact: 'Tailwind CSS', target: 'techContext' },
+    { match: ['@sanity/client', 'sanity'], fact: 'Sanity (headless CMS)', target: 'integrations' },
+    { match: 'contentful', fact: 'Contentful (headless CMS)', target: 'integrations' },
+    { match: 'stripe', fact: 'Stripe (payments)', target: 'integrations' },
+    { match: '@supabase/supabase-js', fact: 'Supabase', target: 'integrations' },
+    { match: 'firebase', fact: 'Firebase', target: 'integrations' },
+    { match: 'firebase-admin', fact: 'Firebase Admin SDK', target: 'integrations' },
+    { match: 'next-auth', fact: 'NextAuth.js (authentication)', target: 'integrations' },
+    { match: '@auth0/nextjs-auth0', fact: 'Auth0 (authentication)', target: 'integrations' },
+    { match: '@clerk/nextjs', fact: 'Clerk (authentication)', target: 'integrations' },
+    { match: '@sendgrid/mail', fact: 'SendGrid (email)', target: 'integrations' },
+    { match: 'resend', fact: 'Resend (email)', target: 'integrations' },
+    { match: 'twilio', fact: 'Twilio', target: 'integrations' },
+    { match: '@aws-sdk/client-s3', fact: 'AWS S3', target: 'integrations' },
+    { match: 'openai', fact: 'OpenAI API', target: 'integrations' },
+    { match: '@anthropic-ai/sdk', fact: 'Anthropic API', target: 'integrations' },
+    { match: '@sentry/node', fact: 'Sentry (error tracking)', target: 'integrations' },
+    { match: '@sentry/nextjs', fact: 'Sentry (error tracking)', target: 'integrations' },
+    { match: 'posthog-js', fact: 'PostHog (analytics)', target: 'integrations' },
+    { match: '@vercel/analytics', fact: 'Vercel Analytics', target: 'integrations' },
+    { match: 'graphql', fact: 'GraphQL', target: 'techContext' },
+    { match: 'redis', fact: 'Redis', target: 'techContext' },
+    { match: 'pg', fact: 'PostgreSQL (via pg)', target: 'techContext' }
+];
+// Each returned fact line is self-documenting about its evidence (which exact dependency name
+// triggered it) - a reader should never have to take the tool's word for a fact it can't trace
+// back to something real in the repo. `${matched}` is deliberately the specific name that was
+// actually present, not `known.match` itself, since that may be an array of aliases.
+export function matchKnownFacts(dependencies) {
+    const deps = new Set(dependencies);
+    const result = { techContext: [], integrations: [] };
+    for (const known of KNOWN_FACTS) {
+        const candidates = Array.isArray(known.match) ? known.match : [known.match];
+        const matched = candidates.find((c) => deps.has(c));
+        if (matched) {
+            result[known.target].push(`${known.fact} — via \`${matched}\` in package.json`);
+        }
+    }
+    return result;
+}

package/package.json

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

package/skills/memoryintel/SKILL.md

@@ -47,6 +47,9 @@ Commands:
   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
+  sync                      Re-scan for stack/integration/deployment facts and write any new
+                            findings - runs automatically via load/check-stop; this is the
+                            manual/debugging entry point
   dashboard <enable|disable>  Turn the shared local dashboard on or off
   doctor [--force]         Refresh memoryintel's own generated files (instructions.md, pointer
                            blocks) to the current template wherever it's provably safe;