@shahmilsaari/memory-core 0.2.14 → 0.2.15

package/README.md

@@ -169,6 +169,7 @@ For the full CLI reference, examples, and command behavior notes, see [COMMANDS.
 
 New setup-management commands:
 - `memory-core status` — show project name, provider/model, agents, hook state, generated files, and health checks
+- `memory-core auto-sync` — show or change automatic agent file regeneration (`on`, `off`, or `status`)
 - `memory-core provider set <provider>` — switch code-checking provider without rerunning `init`
 - `memory-core model set <model>` — update chat or embedding model from the CLI
 - `memory-core model doctor` — verify database, Ollama, model installation, and cloud API key presence
@@ -189,7 +190,7 @@ Walks you through:
 - Hook mode — **advisory** (logs violations, never blocks) or **strict** (blocks commits)
 - Whether to enable caveman mode (optional token saver)
 
-Generates config files for every selected AI agent, saves your choices to `.memory-core.json`, and automatically adds all generated files to `.gitignore` under a `# memory-core generated files` block.
+Generates config files for every selected AI agent, saves your choices to `.memory-core.json`, enables auto-sync by default, and automatically adds all generated files to `.gitignore` under a `# memory-core generated files` block.
 
 At the end, the banner shows live ✓/✗ status for PostgreSQL and Ollama so you know everything is working.
 
@@ -197,7 +198,7 @@ At the end, the banner shows live ✓/✗ status for PostgreSQL and Ollama so yo
 
 ### `sync` — Refresh all agent files
 
-After saving new memories, regenerate every agent file to include them.
+Regenerate every agent file on demand. This still exists even though `remember`, `import`, `edit`, `remove`, `forget`, and `ignore` auto-sync by default after changing memories.
 
 ```bash
 npx @shahmilsaari/memory-core sync
@@ -209,6 +210,18 @@ Multi-selects which agents to sync (pre-checked from your `.memory-core.json` co
   3 updated, 11 already up to date
 ```
 
+Use `--no-sync` on memory-changing commands when you want to save database changes without regenerating files immediately.
+
+Manage the default:
+
+```bash
+npx @shahmilsaari/memory-core auto-sync        # show current setting
+npx @shahmilsaari/memory-core auto-sync off    # save only, sync manually later
+npx @shahmilsaari/memory-core auto-sync on     # restore default behavior
+```
+
+Auto-sync failures are non-fatal. If regeneration cannot run, memory-core prints the reason and tells you to run `memory-core sync` manually.
+
 ---
 
 ### `remember` — Save a decision
@@ -358,12 +371,14 @@ npx @shahmilsaari/memory-core hook uninstall   # remove the hook
 npx @shahmilsaari/memory-core list
 ```
 
-Shows all stored memories. Filter the results:
+By default, shows memories relevant to the current project context: detected stack, current project name, plus shared/global memories. Use `--all` for the old database-wide view.
 
 ```bash
+npx @shahmilsaari/memory-core list --all
 npx @shahmilsaari/memory-core list --type rule
 npx @shahmilsaari/memory-core list --scope global
 npx @shahmilsaari/memory-core list --arch clean-architecture
+npx @shahmilsaari/memory-core list --project my-api
 npx @shahmilsaari/memory-core list --limit 50
 ```
 
@@ -372,6 +387,9 @@ npx @shahmilsaari/memory-core list --limit 50
 | `--type <type>` | Filter by type: `decision` `rule` `pattern` `note` |
 | `--scope <scope>` | Filter by scope: `global` `project` |
 | `--arch <architecture>` | Filter by architecture profile |
+| `--project <name>` | Filter by project name |
+| `--all` | Show the full shared database |
+| `--current` | Explicitly use the current project context |
 | `--limit <n>` | Max results (default 200) |
 
 ---
@@ -568,7 +586,7 @@ npx @shahmilsaari/memory-core seed   # load 281 best-practice rules
 npx @shahmilsaari/memory-core remember "All auth goes through middleware, never in controllers" \
   --type decision --scope global
 
-# Refresh agent files after saving new memories
+# Optional: refresh agent files manually anytime
 npx @shahmilsaari/memory-core sync
 
 # Not sure how something was decided? Search.
@@ -656,6 +674,24 @@ Save an ignore pattern: `npx @shahmilsaari/memory-core ignore "your exception he
 
 ---
 
+## Release checks
+
+Before publishing, run the same checks as CI:
+
+```bash
+npm run lint
+npm run typecheck
+npm test
+npm run build
+npm run smoke:pack
+npm run smoke:npx
+```
+
+`smoke:pack` verifies the npm tarball includes the built CLI plus templates/profiles.
+`smoke:npx` installs that tarball into a fresh temporary project and runs `npx --no-install memory-core init --quick`.
+
+---
+
 ## Roadmap
 
 | | Feature |
@@ -669,6 +705,7 @@ Save an ignore pattern: `npx @shahmilsaari/memory-core ignore "your exception he
 | ✓ | CI/CD — `ci-setup` generates GitHub Actions workflow for PR enforcement |
 | ✓ | Violation stats — see which rules fire most and which files break most |
 | ✓ | Agent selection — choose which agents to generate files for during init |
+| ✓ | Auto-sync — memory-changing commands refresh selected agent files by default |
 | ✓ | Export / import — portable memories.json for version control and team sharing |
 | ✓ | List / remove / edit — full CRUD for stored memories |
 | ✓ | False positive tagging — `ignore` command saves exceptions for hook and watcher |

package/dist/{chunk-25Y2KI7M.js → chunk-DUUQHRIB.js}

@@ -84,12 +84,16 @@ async function listMemories(filters = {}) {
   if (filters.architecture) {
     if (Array.isArray(filters.architecture)) {
       params.push(filters.architecture);
-      where.push(`architecture = ANY($${params.length})`);
+      where.push(filters.includeGlobal ? `(architecture IS NULL OR architecture = ANY($${params.length}))` : `architecture = ANY($${params.length})`);
     } else {
       params.push(filters.architecture);
-      where.push(`architecture = $${params.length}`);
+      where.push(filters.includeGlobal ? `(architecture IS NULL OR architecture = $${params.length})` : `architecture = $${params.length}`);
     }
   }
+  if (filters.projectName) {
+    params.push(filters.projectName);
+    where.push(filters.includeGlobal ? `(project_name IS NULL OR project_name = $${params.length})` : `project_name = $${params.length}`);
+  }
   if (filters.tags?.length) {
     params.push(filters.tags);
     where.push(`tags && $${params.length}::text[]`);

package/dist/cli.js

@@ -7,13 +7,14 @@ import {
   deleteMemories,
   deleteMemory,
   getMemory,
+  getPool,
   listMemories,
   runMigrations,
   saveMemory,
   searchMemories,
   updateMemory,
   upsertMemory
-} from "./chunk-25Y2KI7M.js";
+} from "./chunk-DUUQHRIB.js";
 import "./chunk-KSLFLWB4.js";
 
 // src/cli.ts
@@ -24,7 +25,6 @@ import ora from "ora";
 import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync6, mkdirSync as mkdirSync2, appendFileSync, rmSync, unlinkSync as unlinkSync2 } from "fs";
 import { join as join6, dirname as dirname2 } from "path";
 import { homedir } from "os";
-import { execSync as execSync2 } from "child_process";
 
 // src/generator.ts
 import { readFileSync as readFileSync2, readdirSync, writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
@@ -112,6 +112,17 @@ var FRAMEWORK_ARCHITECTURE_MAP = {
   "Vue.js": ["vue"],
   Svelte: ["svelte"]
 };
+var KNOWN_ARCHITECTURE_KEYS = /* @__PURE__ */ new Set([
+  ...Object.values(FRAMEWORK_ARCHITECTURE_MAP).flat(),
+  "angular",
+  "clean-architecture",
+  "express",
+  "fastify",
+  "hexagonal",
+  "modular-monolith",
+  "mvc",
+  "react-native"
+]);
 function normalizeText(value) {
   return value.toLowerCase().replace(/[`"'()[\]{}.,:;!?/\\<>|=*+-]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -139,6 +150,33 @@ function mergeMemory(primary, secondary) {
     reason
   };
 }
+function memoryArchitectureKeys(memory) {
+  if (memory.architecture && memory.architecture !== "global") {
+    return [memory.architecture];
+  }
+  return (memory.tags ?? []).filter((tag) => KNOWN_ARCHITECTURE_KEYS.has(tag));
+}
+function getStackReason(memory, activeArchitectures) {
+  const architectureKeys = memoryArchitectureKeys(memory);
+  if (architectureKeys.length === 0) {
+    return {
+      included: true,
+      reason: "global memory: no architecture-specific tag"
+    };
+  }
+  const matched = architectureKeys.filter((architecture) => activeArchitectures.has(architecture));
+  if (matched.length > 0) {
+    return {
+      included: true,
+      reason: `matched active architecture: ${matched.join(", ")}`
+    };
+  }
+  const active = [...activeArchitectures].join(", ") || "none detected";
+  return {
+    included: false,
+    reason: `excluded: tagged for ${architectureKeys.join(", ")}; active stack is ${active}`
+  };
+}
 function dedupeMemories(memories, threshold = 0.8) {
   const deduped = [];
   for (const memory of memories) {
@@ -160,6 +198,9 @@ function inferProjectArchitectures(cwd = process.cwd(), config) {
   const inferred = /* @__PURE__ */ new Set();
   if (config?.backendArchitecture) inferred.add(config.backendArchitecture);
   if (config?.frontendFramework) inferred.add(config.frontendFramework);
+  if (config?.projectType === "backend" && !config.backendArchitecture) {
+    inferred.add("clean-architecture");
+  }
   const detected = detectProject(cwd);
   for (const architecture of FRAMEWORK_ARCHITECTURE_MAP[detected.framework] ?? []) {
     inferred.add(architecture);
@@ -169,13 +210,63 @@ function inferProjectArchitectures(cwd = process.cwd(), config) {
 function getAllowPatterns(config) {
   return [...new Set(config?.allowPatterns?.filter(Boolean) ?? [])];
 }
+function filterRelevantMemories(memories, config, cwd = process.cwd()) {
+  return explainMemorySelection(memories, config, cwd).included;
+}
+function explainMemorySelection(memories, config, cwd = process.cwd(), threshold = 0.8) {
+  const activeArchitectures = inferProjectArchitectures(cwd, config);
+  const activeSet = new Set(activeArchitectures);
+  const included = [];
+  const decisions = [];
+  for (const memory of memories) {
+    const stackDecision = getStackReason(memory, activeSet);
+    if (!stackDecision.included) {
+      decisions.push({
+        memory,
+        status: "excluded",
+        reason: stackDecision.reason
+      });
+      continue;
+    }
+    const existingIndex = included.findIndex((candidate) => {
+      if (candidate.content_hash && memory.content_hash && candidate.content_hash === memory.content_hash) {
+        return true;
+      }
+      return similarityScore(candidate.content, memory.content) >= threshold;
+    });
+    if (existingIndex === -1) {
+      included.push(memory);
+      decisions.push({
+        memory,
+        status: "included",
+        reason: stackDecision.reason
+      });
+      continue;
+    }
+    included[existingIndex] = mergeMemory(included[existingIndex], memory);
+    decisions.push({
+      memory,
+      status: "excluded",
+      reason: `duplicate or near-duplicate of memory #${included[existingIndex].id}`
+    });
+  }
+  return {
+    included,
+    excluded: decisions.filter((decision) => decision.status === "excluded"),
+    decisions,
+    activeArchitectures
+  };
+}
 function buildContextQuery(parts, maxLength = 1200) {
   return parts.filter(Boolean).join("\n").slice(0, maxLength);
 }
 async function retrieveContextualMemories(options) {
+  return (await retrieveMemorySelection(options)).included;
+}
+async function retrieveMemorySelection(options) {
   const architectures = inferProjectArchitectures(options.cwd, options.config);
   const memories = await retrieve(options.query, architectures, options.limit ?? 15);
-  return dedupeMemories(memories);
+  return explainMemorySelection(memories, options.config, options.cwd);
 }
 
 // src/generator.ts
@@ -229,10 +320,15 @@ function listProfiles(layer) {
   if (layer === "frontend") return all.filter((p) => p.layer === "frontend" || p.layer === "fullstack");
   return all;
 }
-function buildTemplateData(options) {
+function buildTemplateData(options, cwd = process.cwd()) {
   const backend = options.backendArchitecture ? loadProfile(options.backendArchitecture) : null;
   const frontend = options.frontendFramework ? loadProfile(options.frontendFramework) : null;
-  const dedupedMemories = dedupeMemories(options.memories);
+  const dedupedMemories = filterRelevantMemories(options.memories, {
+    projectType: options.projectType,
+    backendArchitecture: options.backendArchitecture,
+    frontendFramework: options.frontendFramework,
+    language: options.language
+  }, cwd);
   const allRules = [
     ...backend?.rules ?? [],
     ...frontend?.rules ?? []
@@ -300,7 +396,7 @@ function writeFile(filePath, content) {
   return "written";
 }
 async function generate(options, cwd = process.cwd(), onlyAgents) {
-  const data = buildTemplateData(options);
+  const data = buildTemplateData(options, cwd);
   const written = [];
   const skipped = [];
   const files = onlyAgents ? OUTPUT_FILES.filter((f) => onlyAgents.includes(f.agent)) : OUTPUT_FILES;
@@ -922,7 +1018,7 @@ async function promptToSaveViolations(violations) {
       default: selected.reason ?? selected.issue ?? ""
     });
     const { embed: embed2 } = await import("./embedding-PAYD2JYW.js");
-    const { upsertMemory: upsertMemory2 } = await import("./db-5X5LTUCB.js");
+    const { upsertMemory: upsertMemory2 } = await import("./db-VLOR7L6Q.js");
     await upsertMemory2({
       type: "rule",
       scope: "project",
@@ -939,7 +1035,7 @@ async function promptToSaveViolations(violations) {
 }
 async function loadIgnorePatterns() {
   try {
-    const { listMemories: listMemories2, closePool: closePool2 } = await import("./db-5X5LTUCB.js");
+    const { listMemories: listMemories2, closePool: closePool2 } = await import("./db-VLOR7L6Q.js");
     const ignores = await listMemories2({ type: "ignore", limit: 1e3 });
     await closePool2();
     return ignores.map((ignore) => ignore.content);
@@ -996,6 +1092,124 @@ ${violation.file}`.toLowerCase();
     return !allowPatterns.some((pattern) => haystack.includes(pattern.toLowerCase()));
   });
 }
+function normalizeViolation(value) {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value;
+  if (typeof candidate.rule !== "string" || typeof candidate.issue !== "string") return null;
+  return {
+    rule: candidate.rule,
+    file: typeof candidate.file === "string" ? candidate.file : "diff",
+    line: typeof candidate.line === "number" ? candidate.line : void 0,
+    issue: candidate.issue,
+    suggestion: typeof candidate.suggestion === "string" ? candidate.suggestion : void 0,
+    reason: typeof candidate.reason === "string" ? candidate.reason : void 0
+  };
+}
+function parseModelViolations(raw) {
+  const candidates = [
+    raw,
+    raw.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "")
+  ];
+  const objectStart = raw.indexOf("{");
+  const objectEnd = raw.lastIndexOf("}");
+  if (objectStart !== -1 && objectEnd > objectStart) {
+    candidates.push(raw.slice(objectStart, objectEnd + 1));
+  }
+  const arrayStart = raw.indexOf("[");
+  const arrayEnd = raw.lastIndexOf("]");
+  if (arrayStart !== -1 && arrayEnd > arrayStart) {
+    candidates.push(raw.slice(arrayStart, arrayEnd + 1));
+  }
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      const items = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.violations) ? parsed.violations : parsed?.rule ? [parsed] : null;
+      if (!items) continue;
+      return {
+        valid: true,
+        violations: items.map(normalizeViolation).filter((violation) => violation !== null)
+      };
+    } catch {
+    }
+  }
+  return { valid: false, violations: [] };
+}
+function getAddedLines(diff) {
+  const lines = [];
+  let currentFile = "diff";
+  let newLineNumber = 0;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+++ b/")) {
+      currentFile = line.slice("+++ b/".length);
+      continue;
+    }
+    const hunk = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+    if (hunk) {
+      newLineNumber = Number(hunk[1]);
+      continue;
+    }
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      lines.push({
+        file: currentFile,
+        line: Number.isFinite(newLineNumber) ? newLineNumber : void 0,
+        content: line.slice(1)
+      });
+      newLineNumber += 1;
+      continue;
+    }
+    if (!line.startsWith("-") && newLineNumber > 0) {
+      newLineNumber += 1;
+    }
+  }
+  return lines;
+}
+function dedupeViolations(violations) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const violation of violations) {
+    const key = [
+      violation.rule,
+      violation.file,
+      violation.line ?? "",
+      violation.issue
+    ].join("\0");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(violation);
+  }
+  return deduped;
+}
+function findDeterministicViolations(diff, rules, avoids, allowPatterns = []) {
+  const rulePhrases = rules.flatMap(
+    (rule) => extractForbiddenPhrases(rule).map((phrase) => ({ rule, phrase }))
+  );
+  const avoidPhrases = avoids.map((avoid) => ({
+    rule: `Avoid: ${avoid}`,
+    phrase: avoid.toLowerCase()
+  }));
+  const phrases = [...rulePhrases, ...avoidPhrases].filter((item) => item.phrase.length > 0);
+  if (phrases.length === 0) return [];
+  const violations = [];
+  for (const addedLine of getAddedLines(diff)) {
+    const normalizedLine = addedLine.content.toLowerCase();
+    if (allowPatterns.some((pattern) => normalizedLine.includes(pattern.toLowerCase()))) {
+      continue;
+    }
+    for (const { rule, phrase } of phrases) {
+      if (normalizedLine.includes(phrase)) {
+        violations.push({
+          rule,
+          file: addedLine.file,
+          line: addedLine.line,
+          issue: `Added line contains forbidden phrase: "${phrase}"`,
+          suggestion: "Remove this pattern or add an explicit ignore memory if it is intentional.",
+          reason: reasonMap.get(rule)
+        });
+      }
+    }
+  }
+  return dedupeViolations(violations);
+}
 async function verifyViolations(diff, violations, allowPatterns, debug) {
   if (violations.length === 0) return violations;
   const systemPrompt = `You are verifying candidate architecture violations.
@@ -1023,9 +1237,8 @@ ${JSON.stringify(violations, null, 2)}`;
       { role: "system", content: systemPrompt },
       { role: "user", content: userPrompt }
     ]);
-    const parsed = JSON.parse(raw);
-    if (Array.isArray(parsed?.violations)) return parsed.violations;
-    if (Array.isArray(parsed)) return parsed;
+    const parsed = parseModelViolations(raw);
+    if (parsed.valid) return parsed.violations;
     return violations;
   } catch {
     return violations;
@@ -1142,7 +1355,8 @@ Do not include any text outside the JSON object.`;
     console.log(chalk.dim(diffToSend));
     console.log(chalk.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   }
-  let violations = [];
+  const deterministicViolations = findDeterministicViolations(diff, rules, avoids, allowPatterns);
+  let modelViolations = [];
   try {
     const raw = await callChatModel([
       { role: "system", content: systemPrompt },
@@ -1153,36 +1367,29 @@ ${diffToSend}` }
     if (options.verbose || options.debug) {
       console.log(chalk.gray(`  raw response: ${options.debug ? raw : raw.slice(0, 200)}`));
     }
-    try {
-      const parsed = JSON.parse(raw);
-      if (Array.isArray(parsed)) {
-        violations = parsed;
-      } else if (Array.isArray(parsed?.violations)) {
-        violations = parsed.violations;
-      } else if (parsed?.rule) {
-        violations = [parsed];
-      } else {
-        violations = [];
-      }
-    } catch {
-      violations = [];
+    const parsed = parseModelViolations(raw);
+    if (parsed.valid) {
+      modelViolations = parsed.violations;
+    } else {
+      console.log(chalk.yellow("  \u26A0  AI returned invalid JSON \u2014 using deterministic checks only."));
     }
   } catch (err) {
     if (err.message?.startsWith("MODEL_NOT_FOUND:")) {
       printModelMissing(err.message.split(":")[1]);
-      return;
-    }
-    if (err.cause?.code === "ECONNREFUSED" || err.message?.includes("ECONNREFUSED")) {
-      console.log(chalk.yellow("\n  \u26A0  Ollama not running \u2014 skipping rule check."));
+      modelViolations = [];
+    } else if (err.cause?.code === "ECONNREFUSED" || err.message?.includes("ECONNREFUSED")) {
+      console.log(chalk.yellow("\n  \u26A0  Ollama not running \u2014 using deterministic checks only."));
       console.log(chalk.gray("     Start it: ollama serve\n"));
-      return;
+      modelViolations = [];
+    } else {
+      console.log(chalk.yellow(`
+  \u26A0  AI rule check failed: ${err.message}`));
+      console.log(chalk.gray("     Using deterministic checks only.\n"));
+      modelViolations = [];
     }
-    console.log(chalk.yellow(`
-  \u26A0  Rule check failed: ${err.message}
-`));
-    return;
   }
-  violations = await verifyViolations(diff, violations, allowPatterns, options.debug ?? false);
+  modelViolations = await verifyViolations(diff, modelViolations, allowPatterns, options.debug ?? false);
+  let violations = dedupeViolations([...deterministicViolations, ...modelViolations]);
   violations = applyAllowPatterns(violations, allowPatterns);
   if (violations.length === 0) {
     console.log(chalk.green("  \u2713 No rule violations \u2014 commit allowed.\n"));
@@ -1454,7 +1661,7 @@ ${JSON.stringify(violations, null, 2)}`;
 }
 async function loadIgnorePatterns2() {
   try {
-    const { listMemories: listMemories2, closePool: closePool2 } = await import("./db-5X5LTUCB.js");
+    const { listMemories: listMemories2, closePool: closePool2 } = await import("./db-VLOR7L6Q.js");
     const ignores = await listMemories2({ type: "ignore", limit: 1e3 });
     await closePool2();
     return ignores.map((ignore) => ignore.content);
@@ -1633,6 +1840,55 @@ async function startWatch(options = {}) {
   });
 }
 
+// src/remote-install.ts
+import { spawnSync as spawnSync3 } from "child_process";
+var CAVEMAN_INSTALL_URL = "https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh";
+var MAX_INSTALLER_BYTES = 2e5;
+var TRUSTED_INSTALL_HOSTS = /* @__PURE__ */ new Set(["raw.githubusercontent.com"]);
+function assertTrustedInstallerUrl(url) {
+  const parsed = new URL(url);
+  if (parsed.protocol !== "https:") {
+    throw new Error("Remote installer URL must use HTTPS");
+  }
+  if (!TRUSTED_INSTALL_HOSTS.has(parsed.hostname)) {
+    throw new Error(`Remote installer host is not trusted: ${parsed.hostname}`);
+  }
+}
+function defaultRunScript(script) {
+  return spawnSync3("bash", ["-s"], {
+    input: script,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+}
+async function fetchRemoteInstaller(url, fetchImpl = fetch) {
+  assertTrustedInstallerUrl(url);
+  const response = await fetchImpl(url, {
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to download installer (${response.status})`);
+  }
+  const script = await response.text();
+  if (script.length > MAX_INSTALLER_BYTES) {
+    throw new Error(`Installer is too large (${script.length} bytes)`);
+  }
+  if (script.includes("\0")) {
+    throw new Error("Installer contains null bytes");
+  }
+  return script;
+}
+async function installCavemanTokenSaver(options = {}) {
+  const url = options.url ?? CAVEMAN_INSTALL_URL;
+  const script = await fetchRemoteInstaller(url, options.fetchImpl ?? fetch);
+  const result = (options.runScript ?? defaultRunScript)(script);
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    const stderr = result.stderr ? String(result.stderr).trim() : "";
+    throw new Error(stderr || `Installer exited with status ${result.status}`);
+  }
+}
+
 // src/cli.ts
 function printBanner(projectName, agentCount, status) {
   const pg = status ? status.postgresOk ? chalk3.green("  \u2713 PostgreSQL ") + chalk3.bold("connected") : chalk3.red("  \u2717 PostgreSQL ") + chalk3.bold("not connected \u2014 check DATABASE_URL") : chalk3.green("  \u2713 Memory    ") + chalk3.bold("PostgreSQL + pgvector ready");
@@ -1697,6 +1953,7 @@ async function checkConnections(dbUrl, ollamaUrl, chatModel) {
 }
 var { version } = JSON.parse(readFileSync6(new URL("../package.json", import.meta.url), "utf-8"));
 var CONFIG_FILE = ".memory-core.json";
+var LOCAL_GENERATED_FILES = [".memory-core-stats.json"];
 var DEFAULT_OLLAMA_URL = "http://localhost:11434";
 var DEFAULT_EMBEDDING_MODEL = "nomic-embed-text";
 var DEFAULT_CHAT_MODEL = "llama3.2";
@@ -1772,6 +2029,22 @@ function ensureEnvFileIgnored(envPath = getEnvPath()) {
 `);
   }
 }
+function appendMissingGitignoreEntries(entries, heading) {
+  const gitignorePath = join6(process.cwd(), ".gitignore");
+  const existing = existsSync6(gitignorePath) ? readFileSync6(gitignorePath, "utf-8") : "";
+  const existingEntries = new Set(
+    existing.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+  );
+  const toAdd = entries.filter((entry) => !existingEntries.has(entry));
+  if (toAdd.length === 0) {
+    return 0;
+  }
+  const prefix = existing.trim().length > 0 ? "\n" : "";
+  appendFileSync(gitignorePath, `${prefix}${heading}
+${toAdd.join("\n")}
+`);
+  return toAdd.length;
+}
 function normalizeProvider(value) {
   const provider2 = value.trim().toLowerCase();
   if (provider2 === "ollama" || provider2 === "openai" || provider2 === "anthropic" || provider2 === "minimax") {
@@ -1877,6 +2150,9 @@ function printMemoryTable(memories, title = "Rules in memory") {
   });
   console.log(chalk3.gray("\n  Use: memory-core remove <id>  |  memory-core edit <id>\n"));
 }
+function getCurrentListArchitectures(config) {
+  return inferProjectArchitectures(process.cwd(), config).filter((architecture) => architecture !== "global");
+}
 function printStatusLine(label, value) {
   console.log(`  ${chalk3.dim(label.padEnd(18))} ${value}`);
 }
@@ -1974,6 +2250,7 @@ async function printProjectStatus() {
   printStatusLine("Architectures", architectures.length ? architectures.join(", ") : chalk3.gray("none detected"));
   printStatusLine("Agents", config?.agents?.length ? `${config.agents.length} selected` : chalk3.gray("none saved"));
   printStatusLine("Caveman", config?.caveman?.enabled ? `enabled (${config.caveman.intensity})` : "disabled");
+  printStatusLine("Auto sync", config?.autoSync === false ? "disabled" : "enabled");
   printStatusLine("Allow patterns", String(getAllowPatterns(config).length));
   printStatusLine("Env file", `${existsSync6(envPath) ? "present" : "missing"} (${envPath.split("/").pop()})`);
   printStatusLine("Memory file", existsSync6(memoryFilePath) ? MEMORY_FILE : chalk3.gray("not exported"));
@@ -2001,6 +2278,94 @@ async function printProjectStatus() {
   }
   console.log();
 }
+function printMemorySelection(selection, limit = 4) {
+  const active = selection.activeArchitectures.join(", ") || "none detected";
+  console.log(chalk3.gray(`    Stack filter: ${active}`));
+  const included = selection.decisions.filter((decision) => decision.status === "included");
+  if (included.length > 0) {
+    console.log(chalk3.gray(`    Included ${included.length}:`));
+    for (const decision of included.slice(0, limit)) {
+      console.log(chalk3.gray(`      + ${decision.memory.content} (${decision.reason})`));
+    }
+    if (included.length > limit) {
+      console.log(chalk3.gray(`      \u2026 ${included.length - limit} more included`));
+    }
+  }
+  if (selection.excluded.length > 0) {
+    console.log(chalk3.gray(`    Excluded ${selection.excluded.length}:`));
+    for (const decision of selection.excluded.slice(0, limit)) {
+      console.log(chalk3.gray(`      - ${decision.memory.content} (${decision.reason})`));
+    }
+    if (selection.excluded.length > limit) {
+      console.log(chalk3.gray(`      \u2026 ${selection.excluded.length - limit} more excluded`));
+    }
+  }
+}
+function getConfiguredAgents(config) {
+  const agents = config.agents?.length ? config.agents : AGENT_NAMES.filter((agent) => agent !== "Shared");
+  return [.../* @__PURE__ */ new Set([...agents, "Shared"])];
+}
+async function syncGeneratedFiles(config, agents, options = {}) {
+  const memorySpinner = ora(options.label ?? "Syncing memories\u2026").start();
+  let memories = [];
+  try {
+    const archQuery = [config.backendArchitecture, config.frontendFramework, config.language].filter(Boolean).join(" ");
+    const selection = await retrieveMemorySelection({
+      query: archQuery,
+      cwd: process.cwd(),
+      config,
+      limit: 25
+    });
+    memories = selection.included;
+    memorySpinner.succeed(`Found ${memories.length} memories`);
+    if (options.showSelection) {
+      printMemorySelection(selection);
+    }
+  } catch (err) {
+    memorySpinner.warn(`Could not retrieve memories: ${err.message}`);
+  }
+  const spinner = ora("Regenerating agent files\u2026").start();
+  const result = await generate(
+    {
+      projectName: config.projectName,
+      projectType: config.projectType,
+      backendArchitecture: config.backendArchitecture,
+      frontendFramework: config.frontendFramework,
+      language: config.language,
+      memories,
+      caveman: config.caveman
+    },
+    process.cwd(),
+    agents
+  );
+  spinner.succeed(
+    `Synced \u2014 ${chalk3.green(`${result.written.length} updated`)}, ${chalk3.dim(`${result.skipped.length} already up to date`)}`
+  );
+  if (result.written.length > 0) {
+    result.written.forEach((file) => console.log(chalk3.gray(`    \u2713 ${file}`)));
+  }
+}
+async function autoSyncGeneratedFiles(config, action, enabled = true) {
+  if (!enabled) {
+    console.log(chalk3.gray("  Auto-sync skipped (--no-sync). Run memory-core sync when ready."));
+    return;
+  }
+  if (!config) {
+    return;
+  }
+  if (config.autoSync === false) {
+    console.log(chalk3.gray("  Auto-sync disabled for this project. Run memory-core sync when ready."));
+    return;
+  }
+  try {
+    await syncGeneratedFiles(config, getConfiguredAgents(config), {
+      label: `Auto-syncing agent files after ${action}\u2026`
+    });
+  } catch (err) {
+    console.log(chalk3.yellow(`  Auto-sync skipped: ${err.message}`));
+    console.log(chalk3.gray("  Run memory-core sync manually when ready."));
+  }
+}
 var program = new Command();
 program.name("memory-core").description("Universal AI memory core \u2014 generate AI context files for all coding agents").version(version);
 program.command("init").description("Initialize memory-core in the current project").option("--quick", "Use smart defaults and skip optional prompts").action(async (opts) => {
@@ -2212,11 +2577,20 @@ program.command("init").description("Initialize memory-core in the current proje
     message: "Pull relevant memories from previous projects?",
     default: true
   });
-  const installCaveman = quick ? false : await confirm({
-    message: "Install caveman token saver? (~65-75% fewer tokens)",
+  let installCaveman = quick ? false : await confirm({
+    message: "Install caveman token saver? Downloads and runs the upstream installer.",
     default: false
   });
   let cavemanIntensity = "full";
+  if (installCaveman) {
+    const allowRemoteInstaller = await confirm({
+      message: `Security check: download and execute installer from ${CAVEMAN_INSTALL_URL}?`,
+      default: false
+    });
+    if (!allowRemoteInstaller) {
+      installCaveman = false;
+    }
+  }
   if (installCaveman) {
     cavemanIntensity = await select({
       message: "Caveman intensity?",
@@ -2258,20 +2632,23 @@ program.command("init").description("Initialize memory-core in the current proje
     language,
     caveman: { enabled: installCaveman, intensity: cavemanIntensity },
     agents: selectedAgents,
-    allowPatterns: []
+    allowPatterns: [],
+    autoSync: true
   };
   let memories = [];
   if (pullMemories) {
     const spinner2 = ora("Retrieving relevant memories\u2026").start();
     try {
       const archQuery = [backendArchitecture, frontendFramework, language].filter(Boolean).join(" ");
-      memories = await retrieveContextualMemories({
+      const selection = await retrieveMemorySelection({
         query: archQuery,
         cwd: process.cwd(),
         config,
         limit: 20
       });
+      memories = selection.included;
       spinner2.succeed(`Found ${memories.length} relevant memories`);
+      printMemorySelection(selection);
     } catch (err) {
       spinner2.warn(`Could not retrieve memories: ${err.message}`);
     }
@@ -2279,10 +2656,7 @@ program.command("init").description("Initialize memory-core in the current proje
   if (installCaveman) {
     const spinner2 = ora("Installing caveman token saver\u2026").start();
     try {
-      execSync2(
-        "curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash",
-        { stdio: "pipe", cwd: process.cwd() }
-      );
+      await installCavemanTokenSaver();
       spinner2.succeed("Caveman installed");
     } catch (err) {
       spinner2.warn(`Caveman install failed: ${err.message}`);
@@ -2296,15 +2670,11 @@ program.command("init").description("Initialize memory-core in the current proje
   );
   writeProjectConfig(config);
   spinner.succeed(`Generated ${written.written.length} files`);
-  const gitignorePath = join6(process.cwd(), ".gitignore");
-  const generatedPaths = written.written;
-  if (generatedPaths.length > 0) {
-    const existing = existsSync6(gitignorePath) ? readFileSync6(gitignorePath, "utf-8") : "";
-    const toAdd = generatedPaths.filter((p) => !existing.includes(p));
-    if (toAdd.length > 0) {
-      const block = "\n# memory-core generated files\n" + toAdd.join("\n") + "\n";
-      appendFileSync(gitignorePath, block);
-      console.log(chalk3.green(`  \u2713 Added ${toAdd.length} generated files to .gitignore`));
+  const gitignoreEntries = [...written.written, ...LOCAL_GENERATED_FILES];
+  if (gitignoreEntries.length > 0) {
+    const added = appendMissingGitignoreEntries(gitignoreEntries, "# memory-core generated files");
+    if (added > 0) {
+      console.log(chalk3.green(`  \u2713 Added ${added} generated files to .gitignore`));
     }
   }
   if (enableHook) {
@@ -2339,44 +2709,32 @@ program.command("sync").description("Re-pull memories and regenerate AI agent fi
     console.log(chalk3.yellow("  No agents selected \u2014 nothing to sync."));
     process.exit(0);
   }
-  const spinner = ora("Syncing memories\u2026").start();
-  let memories = [];
-  try {
-    const archQuery = [config.backendArchitecture, config.frontendFramework, config.language].filter(Boolean).join(" ");
-    memories = await retrieveContextualMemories({
-      query: archQuery,
-      cwd: process.cwd(),
-      config,
-      limit: 25
-    });
-    spinner.text = `Found ${memories.length} memories \u2014 regenerating files\u2026`;
-  } catch (err) {
-    spinner.warn(`Could not retrieve memories: ${err.message}`);
+  await syncGeneratedFiles(config, [...selectedAgents, "Shared"], { showSelection: true });
+  await closePool();
+});
+program.command("auto-sync [mode]").description("Show or change automatic agent file sync (on|off)").action((mode) => {
+  const config = readProjectConfig();
+  if (!config) {
+    console.error(chalk3.red("No .memory-core.json found. Run: memory-core init"));
+    process.exit(1);
   }
-  const result = await generate(
-    {
-      projectName: config.projectName,
-      projectType: config.projectType,
-      backendArchitecture: config.backendArchitecture,
-      frontendFramework: config.frontendFramework,
-      language: config.language,
-      memories,
-      caveman: config.caveman
-    },
-    process.cwd(),
-    [...selectedAgents, "Shared"]
-  );
-  const updatedCount = result.written.length;
-  const skippedCount = result.skipped.length;
-  spinner.succeed(
-    `Synced \u2014 ${chalk3.green(`${updatedCount} updated`)}, ${chalk3.dim(`${skippedCount} already up to date`)}`
-  );
-  if (result.written.length > 0) {
-    result.written.forEach((f) => console.log(chalk3.gray(`    \u2713 ${f}`)));
+  const normalized = mode?.trim().toLowerCase();
+  if (!normalized || normalized === "status") {
+    console.log(chalk3.bold("\n  Auto-sync\n"));
+    console.log(`  Status: ${config.autoSync === false ? chalk3.yellow("disabled") : chalk3.green("enabled")}`);
+    console.log(chalk3.gray("  Manual sync is always available: memory-core sync\n"));
+    return;
   }
-  await closePool();
+  if (normalized !== "on" && normalized !== "off") {
+    console.error(chalk3.red("Use: memory-core auto-sync [on|off|status]"));
+    process.exit(1);
+  }
+  const enabled = normalized === "on";
+  writeProjectConfig({ ...config, autoSync: enabled });
+  console.log(chalk3.green(`Auto-sync ${enabled ? "enabled" : "disabled"}`));
+  console.log(chalk3.gray("  Manual sync is always available: memory-core sync"));
 });
-program.command("remember <text>").description("Save a new memory to the central database").option("-t, --type <type>", "Memory type (decision|rule|pattern|note)", "decision").option("-s, --scope <scope>", "Scope (global|project)", "project").option("--tags <tags>", "Comma-separated tags").option("-r, --reason <reason>", "Why this rule exists \u2014 helps agents understand intent and debug violations").action(async (text, opts) => {
+program.command("remember <text>").description("Save a new memory to the central database").option("-t, --type <type>", "Memory type (decision|rule|pattern|note)", "decision").option("-s, --scope <scope>", "Scope (global|project)", "project").option("--tags <tags>", "Comma-separated tags").option("-r, --reason <reason>", "Why this rule exists \u2014 helps agents understand intent and debug violations").option("--no-sync", "Skip automatic agent file sync after saving").action(async (text, opts) => {
   const config = readProjectConfig();
   let reason = opts.reason;
   if (!reason) {
@@ -2401,6 +2759,7 @@ program.command("remember <text>").description("Save a new memory to the central
     const reasonLine = reason ? chalk3.gray(`
   Why: ${reason}`) : "";
     spinner.succeed(chalk3.green(`Memory saved: "${text}"`) + reasonLine);
+    await autoSyncGeneratedFiles(config, "remember", opts.sync);
   } catch (err) {
     spinner.fail(`Failed: ${err.message}`);
     process.exit(1);
@@ -2455,9 +2814,10 @@ program.command("export").description(`Export DB memories to ${MEMORY_FILE}`).op
     await closePool();
   }
 });
-program.command("import").description(`Import memories from ${MEMORY_FILE}`).option("--url <url>", "Import memories from a remote URL").option("-f, --file <file>", `Import file (default: ${MEMORY_FILE})`).action(async (opts) => {
+program.command("import").description(`Import memories from ${MEMORY_FILE}`).option("--url <url>", "Import memories from a remote URL").option("-f, --file <file>", `Import file (default: ${MEMORY_FILE})`).option("--no-sync", "Skip automatic agent file sync after import").action(async (opts) => {
   const spinner = ora("Reading memories\u2026").start();
   try {
+    const config = readProjectConfig();
     const memories = opts.url ? await readMemoryFileFromUrl(opts.url) : opts.file ? parseMemoryFile(readFileSync6(join6(process.cwd(), opts.file), "utf-8")) : readMemoryFile();
     let inserted = 0;
     let skipped = 0;
@@ -2479,6 +2839,9 @@ program.command("import").description(`Import memories from ${MEMORY_FILE}`).opt
       else skipped++;
     }
     spinner.succeed(`Imported ${inserted} memories, skipped ${skipped} duplicates`);
+    if (inserted > 0) {
+      await autoSyncGeneratedFiles(config, "import", opts.sync);
+    }
   } catch (err) {
     spinner.fail(`Import failed: ${err.message}`);
     process.exit(1);
@@ -2486,15 +2849,24 @@ program.command("import").description(`Import memories from ${MEMORY_FILE}`).opt
     await closePool();
   }
 });
-program.command("list").description("List memories from the local database").option("--type <type>", "Filter by type").option("--scope <scope>", "Filter by scope").option("--arch <architecture>", "Filter by architecture").option("-n, --limit <n>", "Maximum rows to show", "200").action(async (opts) => {
+program.command("list").description("List memories from the local database").option("--type <type>", "Filter by type").option("--scope <scope>", "Filter by scope").option("--arch <architecture>", "Filter by architecture").option("--project <name>", "Filter by project name").option("--current", "Only show memories relevant to the current project (default)").option("--all", "Show all memories in the database").option("-n, --limit <n>", "Maximum rows to show", "200").action(async (opts) => {
   try {
+    const config = readProjectConfig();
+    const architectures = opts.arch ? opts.arch : opts.all ? void 0 : getCurrentListArchitectures(config);
+    const projectName = opts.project ? opts.project : opts.all || opts.arch ? void 0 : config?.projectName;
     const memories = await listMemories({
       type: opts.type,
       scope: opts.scope,
-      architecture: opts.arch,
+      architecture: architectures,
+      projectName,
+      includeGlobal: !opts.all,
       limit: parseInt(opts.limit, 10)
     });
-    printMemoryTable(memories);
+    const title = opts.all ? "All memories" : `Current project memories${architectures ? ` (${Array.isArray(architectures) ? architectures.join(", ") : architectures})` : ""}`;
+    printMemoryTable(memories, title);
+    if (!opts.all) {
+      console.log(chalk3.gray("  Showing current project context plus shared/global memories. Use --all for the full database.\n"));
+    }
   } catch (err) {
     console.error(chalk3.red(`List failed: ${err.message}`));
     process.exit(1);
@@ -2502,14 +2874,16 @@ program.command("list").description("List memories from the local database").opt
     await closePool();
   }
 });
-program.command("remove <id>").description("Remove a memory by ID").action(async (id) => {
+program.command("remove <id>").description("Remove a memory by ID").option("--no-sync", "Skip automatic agent file sync after removal").action(async (id, opts) => {
   try {
+    const config = readProjectConfig();
     const deleted = await deleteMemory(parseInt(id, 10));
     if (!deleted) {
       console.log(chalk3.yellow(`No memory found with ID ${id}`));
       process.exit(1);
     }
     console.log(chalk3.green(`Removed memory ${id}`));
+    await autoSyncGeneratedFiles(config, "remove", opts.sync);
   } catch (err) {
     console.error(chalk3.red(`Remove failed: ${err.message}`));
     process.exit(1);
@@ -2517,8 +2891,9 @@ program.command("remove <id>").description("Remove a memory by ID").action(async
     await closePool();
   }
 });
-program.command("forget").description("Bulk-delete memories by tag, scope, type, or architecture").option("--tag <tag>", "Delete memories with this tag").option("--scope <scope>", "Filter by scope").option("--type <type>", "Filter by type").option("--arch <architecture>", "Filter by architecture").action(async (opts) => {
+program.command("forget").description("Bulk-delete memories by tag, scope, type, or architecture").option("--tag <tag>", "Delete memories with this tag").option("--scope <scope>", "Filter by scope").option("--type <type>", "Filter by type").option("--arch <architecture>", "Filter by architecture").option("--no-sync", "Skip automatic agent file sync after deletion").action(async (opts) => {
   try {
+    const config = readProjectConfig();
     const deleted = await deleteMemories({
       tag: opts.tag,
       scope: opts.scope,
@@ -2526,6 +2901,9 @@ program.command("forget").description("Bulk-delete memories by tag, scope, type,
       architecture: opts.arch
     });
     console.log(chalk3.green(`Deleted ${deleted} memories`));
+    if (deleted > 0) {
+      await autoSyncGeneratedFiles(config, "forget", opts.sync);
+    }
   } catch (err) {
     console.error(chalk3.red(`Forget failed: ${err.message}`));
     process.exit(1);
@@ -2533,9 +2911,10 @@ program.command("forget").description("Bulk-delete memories by tag, scope, type,
     await closePool();
   }
 });
-program.command("edit <id>").description("Edit a memory interactively").action(async (id) => {
+program.command("edit <id>").description("Edit a memory interactively").option("--no-sync", "Skip automatic agent file sync after editing").action(async (id, opts) => {
   const memoryId = parseInt(id, 10);
   try {
+    const config = readProjectConfig();
     const existing = await getMemory(memoryId);
     if (!existing) {
       console.log(chalk3.yellow(`No memory found with ID ${id}`));
@@ -2558,6 +2937,7 @@ program.command("edit <id>").description("Edit a memory interactively").action(a
       embedding
     });
     console.log(chalk3.green(`Updated memory ${id}`));
+    await autoSyncGeneratedFiles(config, "edit", opts.sync);
   } catch (err) {
     console.error(chalk3.red(`Edit failed: ${err.message}`));
     process.exit(1);
@@ -2565,8 +2945,9 @@ program.command("edit <id>").description("Edit a memory interactively").action(a
     await closePool();
   }
 });
-program.command("ignore [pattern]").description("Manage project-scoped false-positive ignore patterns").option("--list", "List ignored patterns").option("--remove <id>", "Remove an ignored pattern by ID").action(async (pattern, opts) => {
+program.command("ignore [pattern]").description("Manage project-scoped false-positive ignore patterns").option("--list", "List ignored patterns").option("--remove <id>", "Remove an ignored pattern by ID").option("--no-sync", "Skip automatic agent file sync after changing ignore patterns").action(async (pattern, opts) => {
   try {
+    const config = readProjectConfig();
     if (opts.list) {
       printMemoryTable(await listMemories({ type: "ignore", limit: 1e3 }), "Ignored patterns");
       return;
@@ -2578,13 +2959,13 @@ program.command("ignore [pattern]").description("Manage project-scoped false-pos
         process.exit(1);
       }
       console.log(chalk3.green(`Removed ignore pattern ${opts.remove}`));
+      await autoSyncGeneratedFiles(config, "ignore remove", opts.sync);
       return;
     }
     if (!pattern) {
       console.error(chalk3.red("Provide a pattern, --list, or --remove <id>"));
       process.exit(1);
     }
-    const config = readProjectConfig();
     const embedding = await embed(pattern);
     await upsertMemory({
       type: "ignore",
@@ -2596,6 +2977,7 @@ program.command("ignore [pattern]").description("Manage project-scoped false-pos
       embedding
     });
     console.log(chalk3.green(`Ignored pattern saved: "${pattern}"`));
+    await autoSyncGeneratedFiles(config, "ignore", opts.sync);
   } catch (err) {
     console.error(chalk3.red(`Ignore failed: ${err.message}`));
     process.exit(1);
@@ -2673,7 +3055,6 @@ program.command("reset").description("Remove memory-core generated files and loc
       default: false
     });
     if (ok) {
-      const { getPool } = await import("./db-5X5LTUCB.js");
       await getPool().query("DROP TABLE IF EXISTS memories");
       await closePool();
       console.log(chalk3.yellow("Dropped memories table"));

package/dist/{db-5X5LTUCB.js → db-VLOR7L6Q.js}

@@ -12,7 +12,7 @@ import {
   searchMemories,
   updateMemory,
   upsertMemory
-} from "./chunk-25Y2KI7M.js";
+} from "./chunk-DUUQHRIB.js";
 import "./chunk-KSLFLWB4.js";
 export {
   closePool,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shahmilsaari/memory-core",
-  "version": "0.2.14",
+  "version": "0.2.15",
   "description": "Universal AI memory core — generate AI context files from architecture profiles with RAG support",
   "type": "module",
   "bin": {
@@ -14,6 +14,9 @@
   "scripts": {
     "build": "tsup",
     "typecheck": "tsc --noEmit",
+    "lint": "node scripts/lint.mjs",
+    "smoke:pack": "node scripts/pack-smoke.mjs",
+    "smoke:npx": "node scripts/npx-init-smoke.mjs",
     "dev": "tsx src/cli.ts",
     "start": "node dist/cli.js",
     "test": "node --import tsx --test test/**/*.test.ts"

package/templates/AGENTS.md.hbs

@@ -1,11 +1,10 @@
 # AGENTS.md — {{projectName}}
-<!-- Generated by memory-core on {{generatedAt}} — run: memory-core sync -->
+<!-- Generated by memory-core on {{generatedAt}} — auto-sync keeps this fresh; manual refresh: memory-core sync -->
 
 **Type:** {{projectType}} | **Language:** {{language}}
 {{#if hasBackend}}**Backend:** {{backendArchitecture}}{{/if}}
 {{#if hasFrontend}}**Frontend:** {{frontendFramework}}{{/if}}
 
----
 {{#if hasBackend}}
 ## Backend Rules — {{backendArchitecture}}
 {{bullet backendRules}}
@@ -30,7 +29,7 @@
 {{#if hasMemories}}
 
 ---
-## Memory from Previous Projects
+## Relevant Memory from Previous Projects
 {{#each memories}}
 - [{{type}}{{#if this.architecture}} · {{this.architecture}}{{/if}}] {{content}}
 {{/each}}

package/templates/AI_RULES.md.hbs

@@ -7,7 +7,6 @@ These rules apply to ALL AI agents in this project.
 {{#if hasBackend}}**Backend:** {{backendArchitecture}}{{/if}}
 {{#if hasFrontend}}**Frontend:** {{frontendFramework}}{{/if}}
 
----
 {{#if hasBackend}}
 ## Backend — {{backendArchitecture}}
 {{numbered backendRules}}
@@ -26,7 +25,7 @@ These rules apply to ALL AI agents in this project.
 {{#if hasMemories}}
 
 ---
-## Inherited Decisions
+## Relevant Inherited Decisions
 {{#each memories}}
 {{@index}}. **[{{type}}]** {{content}}
    {{#if tags.length}}_tags: {{join tags ", "}}_{{/if}}

package/templates/CLAUDE.md.hbs

@@ -1,5 +1,5 @@
 # CLAUDE.md
-<!-- Generated by memory-core on {{generatedAt}} — run: memory-core sync to refresh -->
+<!-- Generated by memory-core on {{generatedAt}} — auto-sync keeps this fresh; manual refresh: memory-core sync -->
 
 ## Project
 **Name:** {{projectName}}

package/templates/PROJECT_MEMORY.md.hbs

@@ -1,5 +1,5 @@
 # Project Memory — {{projectName}}
-<!-- Generated by memory-core on {{generatedAt}} — run: memory-core sync to refresh -->
+<!-- Generated by memory-core on {{generatedAt}} — auto-sync keeps this fresh; manual refresh: memory-core sync -->
 
 Architecture: {{architecture}}
 Stack: {{language}}
@@ -28,4 +28,4 @@ memory-core remember "Your architectural decision here"
 ---
 _Add memories: `memory-core remember "..."`_
 _Search memories: `memory-core search "..."`_
-_Refresh: `memory-core sync`_
+_Auto-sync is enabled by default after memory changes. Manual refresh: `memory-core sync`._

package/templates/copilot-instructions.md.hbs

@@ -1,5 +1,5 @@
 # Copilot Instructions
-<!-- Generated by memory-core on {{generatedAt}} — run: memory-core sync to refresh -->
+<!-- Generated by memory-core on {{generatedAt}} — auto-sync keeps this fresh; manual refresh: memory-core sync -->
 
 Project: **{{projectName}}** · Type: **{{projectType}}** · Language: **{{language}}**
 {{#if hasBackend}}Backend: {{backendArchitecture}}{{/if}}{{#if hasFrontend}} | Frontend: {{frontendFramework}}{{/if}}

package/templates/cursorrules.hbs

@@ -1,5 +1,5 @@
 # Cursor Rules — {{projectName}}
-# Generated by memory-core on {{generatedAt}} — run: memory-core sync
+# Generated by memory-core on {{generatedAt}} — auto-sync keeps this fresh; manual refresh: memory-core sync
 
 Type: {{projectType}} | Language: {{language}}
 {{#if hasBackend}}Backend: {{backendArchitecture}}{{/if}}{{#if hasFrontend}} | Frontend: {{frontendFramework}}{{/if}}