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

package/README.md

@@ -13,6 +13,13 @@ This repository is itself running Memory Intel on itself — see `.memoryintel/`
 current state, decisions, and open todo items. Any agent with the skill below active will read it
 automatically.
 
+![Memory Intel's dashboard: a registry of projects and one project's mental model](assets/dashboard-demo.gif)
+
+*The local dashboard (`memoryintel dashboard enable`) — a read-only view of every initialized
+project on the machine. Demo data shown above; captured against the real running server, not
+mocked up. [Watch the full tour (mp4)](assets/dashboard-demo.mp4) for automation status, session
+activity, and the event timeline too.*
+
 ## Quick Start
 
 ```bash
@@ -88,7 +95,9 @@ depend on the agent noticing anything.
 ### If you don't want to touch Claude Code's plugin system at all
 
 The CLI works standalone, with no plugin/skill/hook involved — useful for scripting, for other
-tools, or just to try it out:
+tools, or just to try it out. This is exactly what a `SessionStart`/`Stop` hook runs for you
+automatically when a plugin is active — shown here run by hand so you can see what actually
+happens under the hood:
 
 ```bash
 memoryintel init      # once per project — scaffolds .memoryintel/, installs pointer files
@@ -97,6 +106,13 @@ memoryintel load       # print resolved context to stdout
 memoryintel update plan.toon   # apply an update-plan
 ```
 
+![Terminal walkthrough: memoryintel init, then load printing an empty scaffold](assets/cli-walkthrough.gif)
+
+*`init` → `load` → draft a real update-plan → `update` → `load` again, now auto-carrying the
+domain the update just touched. Every command above actually ran; nothing is a typed-out
+transcript. [Watch the full walkthrough (mp4)](assets/cli-walkthrough.mp4) for the update-plan and
+the auto-carry-domain payoff.*
+
 `memoryintel init` never touches a project's own `.claude/settings.json` — Claude Code automation
 comes entirely from the plugin's own `hooks/hooks.json` in this repo, active once the plugin
 itself is active. From then on, agents load and update project memory on their own, per that
@@ -106,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
@@ -113,12 +133,76 @@ assumed default.
 
 ## How it works
 
+![Architecture diagram: a session starts and calls load(), which pulls context from .memoryintel/ (auto-carrying whichever domain the last update touched) into the agent; the agent works; update() writes back to .memoryintel/ as an atomic, per-file-locked write; the next session repeats the cycle](assets/architecture-flow.svg)
+
+`.memoryintel/` is a structured, git-committed set of markdown/JSON files — the single source of
+truth both directions in the diagram above read from and write to. At session start, `load()`
+prints the always-loaded files plus whichever technical/business/research domain the most recent
+`update()` actually touched (an explicit `--domain` still overrides). The agent works, then drafts
+an update-plan and calls `update()`, which validates it, writes atomically under a per-file lock,
+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`. In short: `.memoryintel/` is a structured,
-git-committed set of markdown/JSON files an agent reads at session start and selectively updates
-when something meaningful changes — never a changelog, always a maintained understanding of the
-project as it currently is. See `.memoryintel/context/decisions.md` in this very repository for
-the specific design decisions behind that, with rationale.
+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.
+
+### What `memoryintel init` actually creates
+
+Exactly this, and nothing else — every file below is real output from a fresh `memoryintel init`,
+not a hand-typed example:
+
+```text
+.memoryintel/
+├── instructions.md              # what an agent reads every session — the mechanism, in full
+├── memory-config.json           # compression ceiling overrides, generated-file hashes (for `doctor`)
+├── memory-index.json            # lastUpdated + one-line summary per file, keyed by path
+├── memory-events.jsonl          # append-only log: every load/update/compression, ever
+│
+├── context/                     # always loaded in full — no --domain needed
+│   ├── currentMentalModel.md    # whole-file replace only; the one narrative summary, not a log
+│   ├── activeContext.md         # what session-to-session work is focused on right now
+│   ├── projectBrief.md          # what the project is, for someone who's never seen it
+│   ├── objectives.md            # goals the project is actually working toward
+│   ├── decisions.md             # append-only decision log, with rationale
+│   ├── progress.md              # what's done, what's in flight
+│   └── learnings.md             # things worth not re-learning the hard way
+│
+├── technical/                   # a --domain: architecture, stack, patterns
+│   ├── architecture.md
+│   ├── techContext.md
+│   ├── patterns.md
+│   ├── integrations.md
+│   └── infrastructure.md
+│
+├── business/                    # a --domain: product, roadmap, stakeholders
+│   ├── productContext.md
+│   ├── roadmap.md
+│   ├── stakeholders.md
+│   └── marketContext.md
+│
+└── research/                    # a --domain: findings, open questions
+    ├── findings.md
+    ├── references.md
+    └── hypotheses.md
+
+AGENTS.md                        # pointer file (or .cursor/rules/memoryintel.mdc, GEMINI.md) —
+                                  # tells tools with no native hook where instructions.md lives
+```
+
+`context/` loads on every session automatically; `technical/`, `business/`, and `research/` are
+domains — `load()` pulls in whichever one the most recent `update()` touched, or you can ask for
+one explicitly (`memoryintel load --domain technical`). Every file starts as an empty, headed
+scaffold; there's no separate "add a new memory type" step; you just write to any of the 19 files
+above via an update-plan, same as any other.
 
 ## Existing projects (not greenfield)
 
@@ -201,7 +285,7 @@ cd memoryintel
 npm install
 npm run build                # compiles dist/, regenerates skills/memoryintel/SKILL.md from src/skill.ts
 npm link                     # makes `memoryintel` resolve to this exact checkout instead of the published one
-npm test                     # 207 tests, vitest
+npm test                     # 300 tests, vitest
 npm run build:skill:check    # fails if skills/memoryintel/SKILL.md has drifted from src/skill.ts
 ```
 

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 };
@@ -56,15 +62,18 @@ function isWorkingTreeDirty(projectRoot) {
         return path !== '.memoryintel' && !path.startsWith('.memoryintel/');
     });
 }
+// Claude Code's Stop hook JSON schema only recognizes decision: "block" - there is no "allow"
+// value, so the non-blocking cases must return {} (decision omitted), not { decision: 'allow' },
+// or Claude Code rejects the hook output outright ("Hook JSON output validation failed").
 export function runCheckStop(memoryRoot) {
     const projectRoot = dirname(memoryRoot);
     const markerPath = join(memoryRoot, '.session-marker.json');
     const marker = readMarker(markerPath);
     const signature = computeDiffSignature(projectRoot);
     if (signature === null)
-        return { decision: 'allow' };
+        return {};
     if (signature === marker.lastFlaggedDiffSignature) {
-        return { decision: 'allow' };
+        return {};
     }
     // A brand-new marker (nothing has ever been flagged or resolved in this project) with a
     // currently-clean working tree has nothing actionable to report - baseline silently so a
@@ -73,13 +82,23 @@ export function runCheckStop(memoryRoot) {
     // project's very first Stop event.
     if (marker.lastFlaggedDiffSignature === null && !isWorkingTreeDirty(projectRoot)) {
         writeMarker(markerPath, { lastFlaggedDiffSignature: signature });
-        return { decision: 'allow' };
+        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/init.js

@@ -115,10 +115,12 @@ committed — not because updating was hard, but because nothing in the session
 before the worktree's job was considered done.
 
 ## Compaction
-A file marked \`status: over\` in \`load\`'s manifest has grown past its configured line ceiling.
-This is a signal, not a command — compact it only when it's a sensible moment to (the same
-judgment you already apply to whether to update at all), by adding a row to your update-plan with
-one extra field, \`kind: compress\`, and \`action: replace\` against the section that's grown large.
+A file marked \`status: over\` in \`load\`'s manifest has grown past its configured char ceiling —
+\`update\` also flags this itself, in the same call that pushes a file over, rather than waiting for
+the next \`load\`. This is a signal, not a command — compact it only when it's a sensible moment to
+(the same judgment you already apply to whether to update at all), by adding a row to your
+update-plan with one extra field, \`kind: compress\`, and \`action: replace\` against the section
+that's grown large.
 \`update\` will only apply that row if the target file is currently git-clean — if it isn't, the row
 is rejected and the file is left untouched; commit the current state first, then retry. Aim to
 compact to comfortably under the ceiling, not exactly at it.

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.3",
+  "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;