@aman_asmuei/aman 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aman Asmuei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+<div align="center">
+
+<br>
+
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://img.shields.io/badge/aman-AI_companion-white?style=for-the-badge&labelColor=0d1117&color=58a6ff">
+  <img alt="aman" src="https://img.shields.io/badge/aman-AI_companion-black?style=for-the-badge&labelColor=f6f8fa&color=24292f">
+</picture>
+
+### Your complete AI companion.
+
+Identity + Memory + Tools — one command, any AI.
+
+<br>
+
+[![npm](https://img.shields.io/npm/v/@aman_asmuei/aman?style=flat-square&color=cb3837)](https://www.npmjs.com/package/@aman_asmuei/aman)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)](LICENSE)
+
+</div>
+
+---
+
+## One Command
+
+```bash
+npx @aman_asmuei/aman
+```
+
+Sets up your complete AI ecosystem:
+
+```
+◆ aman — your complete AI companion
+
+✔ Created ~/.acore/core.md (identity)
+✔ Memory: run npx @aman_asmuei/amem to add automated memory
+✔ Tools: run npx @aman_asmuei/akit add github to add capabilities
+
+  ✔ Your AI companion is ready.
+
+  aman status             See your full ecosystem
+  acore customize         Change personality
+  akit add <tool>         Add tools
+  npx @aman_asmuei/amem   Enable automated memory
+```
+
+---
+
+## The Ecosystem
+
+```
+aman
+├── acore     →  identity    →  who your AI IS
+├── amem      →  memory      →  what your AI KNOWS
+└── akit      →  tools       →  what your AI CAN DO
+```
+
+| Layer | Package | What it does |
+|:------|:--------|:-------------|
+| Identity | [acore](https://github.com/amanasmuei/acore) | Personality, values, relationship memory |
+| Memory | [amem](https://github.com/amanasmuei/amem) | Automated knowledge storage (MCP) |
+| Tools | [akit](https://github.com/amanasmuei/akit) | Portable AI capabilities (MCP + manual) |
+| **Unified** | **aman** | **One command to set up everything** |
+
+Each package works independently. `aman` is the front door.
+
+---
+
+## Commands
+
+| Command | What it does |
+|:--------|:------------|
+| `aman` | First run: setup. After that: show status |
+| `aman setup` | Set up identity + memory + tools |
+| `aman status` | View your full ecosystem status |
+
+After setup, use the individual CLIs for detailed management:
+
+```bash
+acore customize         # change AI personality
+acore show              # view identity
+akit add github         # add tools
+akit search database    # find tools
+acore doctor            # health check identity
+akit doctor             # health check tools
+```
+
+---
+
+## Ecosystem Status
+
+```bash
+$ aman status
+
+◆ aman — ecosystem status
+
+✔ Identity: Companion + Aman
+✔ Memory: amem connected (automated)
+✔ Tools: 3 installed
+✔ Platform: Claude Code (auto-save + MCP)
+
+  Ecosystem: Complete ecosystem (3/3 layers active)
+```
+
+---
+
+## Works With
+
+ChatGPT, Claude, Claude Code, Cursor, Windsurf, Gemini, and any AI that accepts a system prompt.
+
+## License
+
+[MIT](LICENSE)
+
+---
+
+<div align="center">
+
+**One command. Complete AI companion. Any platform.**
+
+</div>

package/bin/aman.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/index.js";

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,428 @@
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/setup.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import fs4 from "fs";
+import path3 from "path";
+import os2 from "os";
+
+// src/lib/detect.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { execFileSync } from "child_process";
+function detectUserName() {
+  try {
+    const name = execFileSync("git", ["config", "user.name"], {
+      encoding: "utf-8",
+      timeout: 3e3
+    }).trim();
+    return name || null;
+  } catch {
+    return null;
+  }
+}
+function detectPlatform(cwd) {
+  const dir = cwd ?? process.cwd();
+  const configPath = path.join(dir, ".acore", "config.json");
+  if (fs.existsSync(configPath)) {
+    try {
+      const raw = fs.readFileSync(configPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.platform === "string") {
+        const p3 = parsed.platform;
+        if (p3 === "claude-code" || p3 === "cursor" || p3 === "windsurf") return p3;
+      }
+    } catch {
+    }
+  }
+  if (fs.existsSync(path.join(dir, "CLAUDE.md"))) return "claude-code";
+  if (fs.existsSync(path.join(dir, ".cursorrules"))) return "cursor";
+  if (fs.existsSync(path.join(dir, ".windsurfrules"))) return "windsurf";
+  return "other";
+}
+function detectStack(cwd) {
+  const dir = cwd ?? process.cwd();
+  const parts = [];
+  const hasTs = fs.existsSync(path.join(dir, "tsconfig.json"));
+  if (hasTs) parts.push("TypeScript");
+  if (fs.existsSync(path.join(dir, "Cargo.toml"))) parts.push("Rust");
+  if (fs.existsSync(path.join(dir, "go.mod"))) parts.push("Go");
+  if (fs.existsSync(path.join(dir, "pyproject.toml")) || fs.existsSync(path.join(dir, "requirements.txt"))) parts.push("Python");
+  if (fs.existsSync(path.join(dir, "package.json"))) {
+    try {
+      const raw = fs.readFileSync(path.join(dir, "package.json"), "utf-8");
+      const pkg = JSON.parse(raw);
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      const frameworks = [["react", "React"], ["next", "Next.js"], ["vue", "Vue"], ["svelte", "Svelte"], ["express", "Express"]];
+      for (const [dep, label] of frameworks) {
+        if (dep in deps) {
+          if (!hasTs && !parts.includes("JavaScript")) parts.push("JavaScript");
+          parts.push(label);
+        }
+      }
+    } catch {
+    }
+  }
+  return parts.join(", ");
+}
+function detectRole(cwd) {
+  const dir = cwd ?? process.cwd();
+  const manifests = ["package.json", "tsconfig.json", "Cargo.toml", "go.mod", "pyproject.toml", "requirements.txt"];
+  return manifests.some((m) => fs.existsSync(path.join(dir, m))) ? "Developer" : "Professional";
+}
+function isMcpPlatform(platform) {
+  return platform === "claude-code" || platform === "cursor" || platform === "windsurf";
+}
+function detectEcosystem() {
+  const home = os.homedir();
+  const acorePath = path.join(home, ".acore", "core.md");
+  const akitPath = path.join(home, ".akit", "kit.md");
+  const akitInstalledPath = path.join(home, ".akit", "installed.json");
+  let akitToolCount = 0;
+  if (fs.existsSync(akitInstalledPath)) {
+    try {
+      const tools = JSON.parse(fs.readFileSync(akitInstalledPath, "utf-8"));
+      akitToolCount = Array.isArray(tools) ? tools.length : 0;
+    } catch {
+    }
+  }
+  let amemInstalled = false;
+  const mcpPaths = [
+    path.join(home, ".claude", "settings.json"),
+    path.join(process.cwd(), ".cursor", "mcp.json"),
+    path.join(home, ".windsurf", "mcp.json")
+  ];
+  for (const mcpPath of mcpPaths) {
+    if (fs.existsSync(mcpPath)) {
+      try {
+        const raw = fs.readFileSync(mcpPath, "utf-8");
+        if (raw.includes("amem")) amemInstalled = true;
+      } catch {
+      }
+    }
+  }
+  return {
+    acore: { installed: fs.existsSync(acorePath), path: acorePath },
+    amem: { installed: amemInstalled },
+    akit: { installed: fs.existsSync(akitPath), path: akitPath, toolCount: akitToolCount }
+  };
+}
+
+// src/lib/template.ts
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+function getTemplatePath(name) {
+  const fromDist = path2.join(__dirname, "..", "template", `${name}.md`);
+  if (fs2.existsSync(fromDist)) return fromDist;
+  const fromSrc = path2.join(__dirname, "..", "..", "template", `${name}.md`);
+  return fromSrc;
+}
+function loadTemplate(name) {
+  return fs2.readFileSync(getTemplatePath(name), "utf-8");
+}
+function fillTemplate(template, values) {
+  let result = template;
+  for (const [key, value] of Object.entries(values)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  return result;
+}
+
+// src/lib/instructions.ts
+var FILE_BASED_INSTRUCTIONS = `### Update Protocol
+When user says "update core" OR when session is winding down:
+1. Review conversation for new insights
+2. Flag any Identity-level changes for explicit approval BEFORE proceeding
+3. Read current ~/.acore/core.md
+4. Write updated version directly to ~/.acore/core.md
+5. Confirm what changed in 1-2 sentences
+
+If file write fails for any reason, fall back to outputting the updated core.md in a code block.
+
+### Update Permissions
+- Auto-update (no approval needed): Session, Relationship.Work, Relationship.Learned patterns
+- Approval required: Identity (any field), adding new sections
+- Suggest only: structural changes to core.md
+
+### Session Awareness
+When the conversation is winding down:
+- Proactively offer: "I noticed a few things this session. Want me to save them to your core?"
+- If yes: follow Update Protocol (write directly)
+- If no: respect it, don't ask again`;
+var CLIPBOARD_INSTRUCTIONS = `### Update Protocol
+When user says "update core" OR when session is winding down:
+1. Review conversation for new insights
+2. Flag any Identity-level changes for explicit approval
+3. Output the complete updated core.md in a code block
+4. User saves manually (paste into acore pull or replace file directly)
+
+### Update Permissions
+- Auto-update (no approval needed): Session, Relationship.Work, Relationship.Learned patterns
+- Approval required: Identity (any field), adding new sections
+- Suggest only: structural changes to core.md
+
+### Session Awareness
+When the conversation is winding down:
+- Proactively offer: "Want me to generate an updated core.md with what I learned this session?"
+- If yes: follow Update Protocol
+- If no: respect it, don't ask again`;
+function getUpdateInstructions(platform) {
+  if (platform === "claude-code" || platform === "cursor" || platform === "windsurf") {
+    return FILE_BASED_INSTRUCTIONS;
+  }
+  return CLIPBOARD_INSTRUCTIONS;
+}
+
+// src/lib/inject.ts
+import fs3 from "fs";
+var START_MARKER = "<!-- acore:start -->";
+var END_MARKER = "<!-- acore:end -->";
+function injectIntoFile(filePath, content) {
+  const wrapped = `${START_MARKER}
+${content}
+${END_MARKER}`;
+  if (!fs3.existsSync(filePath)) {
+    fs3.writeFileSync(filePath, wrapped + "\n", "utf-8");
+    return { created: true };
+  }
+  const existing = fs3.readFileSync(filePath, "utf-8");
+  const startIdx = existing.indexOf(START_MARKER);
+  const endIdx = existing.indexOf(END_MARKER);
+  if (startIdx !== -1 && endIdx !== -1) {
+    const before = existing.slice(0, startIdx);
+    const after = existing.slice(endIdx + END_MARKER.length);
+    fs3.writeFileSync(filePath, before + wrapped + after, "utf-8");
+  } else {
+    fs3.writeFileSync(filePath, existing + "\n" + wrapped + "\n", "utf-8");
+  }
+  return { created: false };
+}
+function getPlatformFile(platform) {
+  switch (platform) {
+    case "claude-code":
+      return "CLAUDE.md";
+    case "cursor":
+      return ".cursorrules";
+    case "windsurf":
+      return ".windsurfrules";
+    default:
+      return null;
+  }
+}
+
+// src/commands/setup.ts
+var ARCHETYPES = {
+  pragmatist: {
+    personality: "concise, practical, efficient",
+    communication: "lead with the answer, then explain if asked",
+    values: "simplicity over cleverness, shipping over perfection"
+  },
+  mentor: {
+    personality: "patient, thorough, encouraging",
+    communication: "explain step-by-step, celebrate progress",
+    values: "understanding over speed, safety over velocity"
+  },
+  "sparring-partner": {
+    personality: "direct, challenging, honest",
+    communication: "push back on weak ideas, ask hard questions",
+    values: "honesty over comfort, shipping over perfection"
+  },
+  collaborator: {
+    personality: "curious, supportive, adaptive",
+    communication: "explore ideas together, match your energy",
+    values: "understanding over speed"
+  },
+  architect: {
+    personality: "systematic, precise, forward-thinking",
+    communication: "plan before building, cover edge cases",
+    values: "safety over velocity, simplicity over cleverness"
+  }
+};
+async function setupCommand() {
+  p.intro(pc.bold("aman") + " \u2014 your complete AI companion");
+  const ecosystem = detectEcosystem();
+  if (ecosystem.acore.installed) {
+    p.log.success(`Identity: ${pc.dim("~/.acore/core.md")} already exists`);
+  } else {
+    p.log.step("Setting up your AI identity...");
+    let userName = detectUserName();
+    if (!userName) {
+      const prompted = await p.text({
+        message: "What's your name?",
+        validate: (v) => v.length === 0 ? "Name is required" : void 0
+      });
+      if (p.isCancel(prompted)) process.exit(0);
+      userName = prompted;
+    }
+    const platform = detectPlatform();
+    const stack = detectStack();
+    const userRole = detectRole();
+    const archetype = await p.select({
+      message: "Choose your AI's personality",
+      options: [
+        { value: "collaborator", label: "Collaborator", hint: "curious, supportive, adaptive (recommended)" },
+        { value: "pragmatist", label: "Pragmatist", hint: "concise, practical, efficient" },
+        { value: "mentor", label: "Mentor", hint: "patient, thorough, encouraging" },
+        { value: "sparring-partner", label: "Sparring Partner", hint: "direct, challenging, honest" },
+        { value: "architect", label: "Architect", hint: "systematic, precise, forward-thinking" }
+      ],
+      initialValue: "collaborator"
+    });
+    if (p.isCancel(archetype)) process.exit(0);
+    const arch = ARCHETYPES[archetype];
+    const aiName = await p.text({
+      message: "Name your AI companion",
+      placeholder: "Companion",
+      defaultValue: "Companion"
+    });
+    if (p.isCancel(aiName)) process.exit(0);
+    const template = loadTemplate("core-starter");
+    const content = fillTemplate(template, {
+      AI_NAME: aiName || "Companion",
+      USER_NAME: userName,
+      USER_ROLE: userRole,
+      PERSONALITY: arch.personality,
+      COMMUNICATION: arch.communication,
+      VALUES: arch.values,
+      BOUNDARIES: "won't pretend to be human, flags when out of depth",
+      DATE: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+      UPDATE_INSTRUCTIONS: getUpdateInstructions(platform)
+    });
+    const globalDir = path3.join(os2.homedir(), ".acore");
+    fs4.mkdirSync(globalDir, { recursive: true });
+    fs4.writeFileSync(path3.join(globalDir, "core.md"), content, "utf-8");
+    p.log.success(`Created ${pc.dim("~/.acore/core.md")} (identity)`);
+    if (stack) {
+      const localDir = path3.join(process.cwd(), ".acore");
+      fs4.mkdirSync(localDir, { recursive: true });
+      const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const contextContent = `## Work
+- Stack: ${stack}
+- Domain: 
+- Focus: 
+
+## Session
+- Last updated: ${today}
+- Resume: [starting fresh]
+- Active topics: []
+- Recent decisions: []
+- Temp notes: []
+
+## Project Patterns
+- [observations specific to this project \u2014 built over time]
+`;
+      fs4.writeFileSync(path3.join(localDir, "context.md"), contextContent, "utf-8");
+      const configContent = JSON.stringify({ platform: platform || "other" }, null, 2) + "\n";
+      fs4.writeFileSync(path3.join(localDir, "config.json"), configContent, "utf-8");
+    }
+    const platformFile = getPlatformFile(platform);
+    if (platformFile) {
+      const globalContent = fs4.readFileSync(path3.join(globalDir, "core.md"), "utf-8");
+      const filePath = path3.join(process.cwd(), platformFile);
+      const result = injectIntoFile(filePath, globalContent);
+      if (result.created) {
+        p.log.success(`Created ${pc.dim(platformFile)} with identity`);
+      } else {
+        p.log.success(`Updated ${pc.dim(platformFile)} with identity`);
+      }
+    }
+    const inferredParts = [userName, userRole];
+    if (stack) inferredParts.push(stack);
+    p.log.info(`Inferred: ${pc.dim(inferredParts.join(" \xB7 "))}`);
+  }
+  if (ecosystem.amem.installed) {
+    p.log.success("Memory: amem connected");
+  } else {
+    const platform = detectPlatform();
+    if (isMcpPlatform(platform)) {
+      p.log.info(`Memory: run ${pc.bold("npx @aman_asmuei/amem")} to add automated memory`);
+    } else {
+      p.log.info(`Memory: built-in via core.md (upgrade with ${pc.bold("npx @aman_asmuei/amem")})`);
+    }
+  }
+  if (ecosystem.akit.installed) {
+    p.log.success(`Tools: ${ecosystem.akit.toolCount} tools configured`);
+  } else {
+    p.log.info(`Tools: run ${pc.bold("npx @aman_asmuei/akit add github")} to add capabilities`);
+  }
+  const card = [
+    "",
+    `  ${pc.green("\u2714")} Your AI companion is ready.`,
+    "",
+    `  ${pc.bold("aman status")}             See your full ecosystem`,
+    `  ${pc.bold("acore customize")}         Change personality`,
+    `  ${pc.bold("akit add <tool>")}         Add tools`,
+    `  ${pc.bold("npx @aman_asmuei/amem")}   Enable automated memory`,
+    ""
+  ];
+  p.note(card.join("\n"), "");
+  p.outro(pc.dim("Identity + Memory + Tools \u2014 one ecosystem."));
+}
+
+// src/commands/status.ts
+import * as p2 from "@clack/prompts";
+import pc2 from "picocolors";
+import fs5 from "fs";
+function statusCommand() {
+  p2.intro(pc2.bold("aman") + " \u2014 ecosystem status");
+  const ecosystem = detectEcosystem();
+  const platform = detectPlatform();
+  if (ecosystem.acore.installed) {
+    const content = fs5.readFileSync(ecosystem.acore.path, "utf-8");
+    const aiName = content.match(/^# (.+)$/m)?.[1] || "Companion";
+    const userName = content.match(/- Name: (.+)$/m)?.[1] || "Unknown";
+    p2.log.success(`Identity: ${pc2.bold(aiName)} + ${pc2.bold(userName)}`);
+  } else {
+    p2.log.error(`Identity: not set up \u2014 run ${pc2.bold("aman setup")}`);
+  }
+  if (ecosystem.amem.installed) {
+    p2.log.success("Memory: amem connected (automated)");
+  } else {
+    p2.log.warning(`Memory: standalone mode \u2014 ${pc2.dim("npx @aman_asmuei/amem to upgrade")}`);
+  }
+  if (ecosystem.akit.installed) {
+    p2.log.success(`Tools: ${ecosystem.akit.toolCount} installed \u2014 ${pc2.dim("akit list for details")}`);
+  } else {
+    p2.log.warning(`Tools: none \u2014 ${pc2.dim("npx @aman_asmuei/akit add github")}`);
+  }
+  const platformLabels = {
+    "claude-code": "Claude Code",
+    cursor: "Cursor",
+    windsurf: "Windsurf",
+    other: "Manual"
+  };
+  const platLabel = platformLabels[platform] || platform;
+  if (isMcpPlatform(platform)) {
+    p2.log.success(`Platform: ${pc2.bold(platLabel)} (auto-save + MCP)`);
+  } else {
+    p2.log.info(`Platform: ${pc2.bold(platLabel)}`);
+  }
+  let score = 0;
+  if (ecosystem.acore.installed) score += 1;
+  if (ecosystem.amem.installed) score += 1;
+  if (ecosystem.akit.installed) score += 1;
+  const levels = ["Not started", "Getting started", "Growing", "Complete ecosystem"];
+  const colors = [pc2.red, pc2.yellow, pc2.cyan, pc2.green];
+  p2.log.message("");
+  p2.log.info(`Ecosystem: ${colors[score](levels[score])} (${score}/3 layers active)`);
+  p2.outro("");
+}
+
+// src/index.ts
+var program = new Command();
+program.name("aman").description("Your complete AI companion \u2014 identity, memory, and tools in one command").version("0.1.0").action(() => {
+  const ecosystem = detectEcosystem();
+  if (ecosystem.acore.installed) {
+    statusCommand();
+  } else {
+    setupCommand();
+  }
+});
+program.command("setup").description("Set up your AI companion (identity + memory + tools)").action(() => setupCommand());
+program.command("status").description("View your full ecosystem status").action(() => statusCommand());
+program.parse();

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@aman_asmuei/aman",
+  "version": "0.1.0",
+  "description": "Your complete AI companion — identity, memory, and tools in one command",
+  "type": "module",
+  "bin": {
+    "aman": "./bin/aman.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "bin",
+    "template"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "ai",
+    "llm",
+    "identity",
+    "memory",
+    "tools",
+    "agent",
+    "cli",
+    "acore",
+    "amem",
+    "akit"
+  ],
+  "author": "Aman Asmuei",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/amanasmuei/aman.git"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.1",
+    "commander": "^13.1.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}

package/template/core-starter.md

@@ -0,0 +1,47 @@
+# {{AI_NAME}}
+
+## Identity
+- Role: {{AI_NAME}} is {{USER_NAME}}'s personal AI partner ({{USER_ROLE}})
+- Personality: {{PERSONALITY}}
+- Communication: {{COMMUNICATION}}
+- Values: {{VALUES}}
+- Boundaries: {{BOUNDARIES}}
+
+---
+
+## Relationship
+- Name: {{USER_NAME}}
+- Role: {{USER_ROLE}}
+- Communication: [learns over time]
+- Work: [set per project]
+- Learned patterns: [builds over time]
+
+---
+
+## Session
+- Last updated: {{DATE}}
+- Resume: [first session]
+
+---
+
+## Instructions
+
+{{UPDATE_INSTRUCTIONS}}
+
+### Growth Protocol
+After 3 sessions: suggest adding Dynamics (trust, emotional patterns, conflict history)
+After 5 sessions: suggest adding Context Modes (coding, creative, personal behavior)
+After 10 sessions: suggest adding Memory Lifecycle rules (consolidation, compression, forgetting)
+Each addition requires explicit user approval.
+
+### amem Integration (full mode)
+When amem MCP tools are available:
+- Session start: call `memory_recall` to enrich context
+- During session: call `memory_store` for significant observations
+- Session end: call `memory_context` for consolidation candidates
+- Overflow: move details to amem, keep `[→ amem: topic]` pointer
+
+### Without amem (standalone mode)
+- All updates via "update core" command or automatic file write
+- AI follows Memory Lifecycle rules when generating updates
+- AI reminds user to update if 3+ sessions have passed