agentlas 0.9.4 → 0.9.5

package/engine/agentlas-evolution.cjs

@@ -0,0 +1,299 @@
+"use strict";
+
+// `agentlas evolve [list|apply <id>|revert <id>]` — Phase 2 / 2+ (terminal 표면).
+//
+// 데스크탑 트리거가 만든 "성장 제안"을 공유 agentlas.sqlite에서 읽어 검토·적용·되돌린다.
+// hep/터미널 세션은 UI가 없으므로 이 명령이 4표면 발화 UX의 터미널 창구다.
+//   list  — 대기 중(고위험 candidate) + 자동적용(저위험) 제안을 사람이 읽는 3줄로.
+//   apply <id>  — 고위험 candidate를 명시 승인해 프롬프트에 적용(런타임 authority=system_prompt + 파일).
+//   revert <id> — 적용된 제안을 되돌린다.
+//
+// 적용/되돌리기 게이트는 도구 무관한 "타깃 파일 내용 해시(before_hash/after_hash)"로만 판정한다
+// (데스크탑이 생성 시 저장한 sha256). 그래서 데스크탑이 자동적용한 저위험 제안도 터미널에서
+// 안전하게 되돌릴 수 있다. 어떤 실패도 폴백 없이 상태로 노출한다.
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { createHash, randomUUID } = require("node:crypto");
+
+function sha256(content) {
+  return createHash("sha256").update(String(content), "utf8").digest("hex");
+}
+
+const ABSENT_TARGET_HASH = sha256("agentlas:absent-agent-asset:v1");
+const RULE_TARGETS = new Set([
+  "system-prompt.md",
+  "soul.md",
+  "agent.md",
+  "claude.md",
+  "agents.md",
+  "gemini.md",
+  "persona.md",
+  "prompt.md",
+]);
+
+function parseSource(json) {
+  try {
+    const parsed = JSON.parse(json || "{}");
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/** 대기 중(사람 결정 필요) 고위험 성장 제안 개수 — 터미널 홈 배너용. */
+function countPendingGrowthProposals(db) {
+  try {
+    const row = db
+      .prepare(
+        `SELECT COUNT(*) AS n FROM agent_evolution_proposals
+          WHERE json_extract(source_json, '$._growth') = 1 AND status = 'candidate'`,
+      )
+      .get();
+    return Number(row && row.n ? row.n : 0);
+  } catch {
+    return 0;
+  }
+}
+
+function listGrowthProposals(db, limit = 50) {
+  let rows = [];
+  try {
+    rows = db
+      .prepare(
+        `SELECT * FROM agent_evolution_proposals
+          WHERE json_extract(source_json, '$._growth') = 1
+            AND status IN ('candidate','applied','measured')
+          ORDER BY datetime(updated_at) DESC, datetime(created_at) DESC
+          LIMIT ?`,
+      )
+      .all(limit);
+  } catch {
+    rows = [];
+  }
+  const pending = [];
+  const autoApplied = [];
+  for (const row of rows) {
+    const source = parseSource(row.source_json);
+    const entry = { row, source };
+    if (row.status === "candidate") pending.push(entry);
+    else if (source._autoApplied === true) autoApplied.push(entry);
+  }
+  return { pending, autoApplied };
+}
+
+function agentById(db, id) {
+  try {
+    return db.prepare("SELECT * FROM installed_agents WHERE id = ?").get(id) || null;
+  } catch {
+    return null;
+  }
+}
+
+function targetFilePath(agentFolder, agent, targetPath) {
+  const dir = agentFolder(agent);
+  const safe = path.resolve(dir, targetPath);
+  if (safe !== path.join(dir, targetPath) && !safe.startsWith(path.resolve(dir) + path.sep)) {
+    throw new Error("Evolution target escapes the agent folder");
+  }
+  return safe;
+}
+
+function currentTargetHash(file) {
+  try {
+    const content = fs.readFileSync(file, "utf8");
+    return { exists: true, content, hash: sha256(content) };
+  } catch (error) {
+    if (error && error.code === "ENOENT") return { exists: false, content: "", hash: ABSENT_TARGET_HASH };
+    throw error;
+  }
+}
+
+function printCard(out, entry, index) {
+  const { row, source } = entry;
+  const card = source.humanCard && typeof source.humanCard === "object" ? source.humanCard : null;
+  const tier = source.riskTier === "high" ? "high" : "low";
+  out(`  [${index}] ${row.id}  (${tier} · ${row.status} · ${row.agent_id})`);
+  if (card) {
+    out(`      배운 것 : ${card.learned}`);
+    out(`      바뀌는 것: ${card.change}`);
+    out(`      되돌리기 : ${card.reversible}`);
+  } else {
+    out(`      ${row.summary}`);
+  }
+}
+
+function cmdList(db, out) {
+  const { pending, autoApplied } = listGrowthProposals(db);
+  out("== agent growth proposals ==");
+  out("");
+  out(`대기(승인 필요) ${pending.length}건:`);
+  if (!pending.length) out("  (없음)");
+  pending.forEach((entry, i) => printCard(out, entry, i + 1));
+  out("");
+  out(`자동 적용됨(저위험) ${autoApplied.length}건:`);
+  if (!autoApplied.length) out("  (없음)");
+  autoApplied.forEach((entry, i) => printCard(out, entry, i + 1));
+  out("");
+  out("적용:  agentlas evolve apply <id>   ·   되돌리기: agentlas evolve revert <id>");
+}
+
+function loadProposal(db, id, fail) {
+  const row = db.prepare("SELECT * FROM agent_evolution_proposals WHERE id = ?").get(id);
+  if (!row) return fail(`Proposal not found: ${id}`);
+  if (row.proposal_type !== "rule") {
+    return fail(`Terminal evolve applies rule (prompt) proposals only; ${id} is '${row.proposal_type}'. Use the desktop app.`);
+  }
+  if (!RULE_TARGETS.has(String(row.target_path).toLowerCase())) {
+    return fail(`Unsupported evolution target: ${row.target_path}`);
+  }
+  return row;
+}
+
+// 터미널이 부트스트랩한 DB는 v45라 진화 영수증 테이블이 없을 수 있다(데스크탑 v51+ 마이그레이션이
+// 추가). 앱과 동일한 스키마로 idempotent 생성 — 앱이 이미 만들었으면 no-op.
+function ensureReceiptTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_evolution_receipts (
+      id TEXT PRIMARY KEY,
+      proposal_id TEXT NOT NULL,
+      agent_id TEXT NOT NULL,
+      action TEXT NOT NULL,
+      target_path TEXT NOT NULL,
+      version_before INTEGER NOT NULL,
+      version_after INTEGER NOT NULL,
+      target_hash_before TEXT NOT NULL,
+      target_hash_after TEXT NOT NULL,
+      package_hash_before TEXT NOT NULL,
+      package_hash_after TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      UNIQUE(proposal_id, action)
+    );
+  `);
+}
+
+function insertReceipt(db, row, action, hashBefore, hashAfter, now) {
+  ensureReceiptTable(db);
+  db.prepare(
+    `INSERT INTO agent_evolution_receipts (
+       id, proposal_id, agent_id, action, target_path,
+       version_before, version_after, target_hash_before, target_hash_after,
+       package_hash_before, package_hash_after, created_at
+     ) VALUES (?, ?, ?, ?, ?, 1, 2, ?, ?, ?, ?, ?)
+     ON CONFLICT(proposal_id, action) DO NOTHING`,
+  ).run(
+    `evo_receipt_${randomUUID()}`,
+    row.id,
+    row.agent_id,
+    action,
+    row.target_path,
+    hashBefore,
+    hashAfter,
+    hashBefore,
+    hashAfter,
+    now,
+  );
+}
+
+function cmdApply(db, id, out, fail, agentFolder) {
+  const row = loadProposal(db, id, fail);
+  if (!row) return;
+  if (row.status !== "candidate") {
+    return fail(`Only a pending candidate can be applied; ${id} is '${row.status}'.`);
+  }
+  const agent = agentById(db, row.agent_id);
+  if (!agent) return fail(`Agent not found for proposal: ${row.agent_id}`);
+  const file = targetFilePath(agentFolder, agent, row.target_path);
+  const current = currentTargetHash(file);
+  if (current.hash !== row.before_hash) {
+    return fail("Agent prompt changed after this proposal was created; review it in the desktop app and re-propose.");
+  }
+  const now = new Date().toISOString();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, row.after_content, "utf8");
+  const verify = sha256(fs.readFileSync(file, "utf8"));
+  if (verify !== row.after_hash) {
+    // 원상복구 후 실패 노출(폴백 금지).
+    fs.writeFileSync(file, row.before_content, "utf8");
+    return fail("Applied content did not match the approved hash; restored the original.");
+  }
+  const tx = db.transaction(() => {
+    db.prepare("UPDATE installed_agents SET system_prompt = ? WHERE id = ?").run(row.after_content, row.agent_id);
+    insertReceipt(db, row, "apply", row.before_hash, row.after_hash, now);
+    db.prepare(
+      `UPDATE agent_evolution_proposals
+         SET status = 'applied', applied_at = COALESCE(applied_at, ?),
+             last_error = NULL, updated_at = ?
+       WHERE id = ? AND status = 'candidate'`,
+    ).run(now, now, row.id);
+  });
+  tx();
+  out(`applied ${id} → ${row.target_path} (agent ${row.agent_id}). Revert with: agentlas evolve revert ${id}`);
+}
+
+function cmdRevert(db, id, out, fail, agentFolder) {
+  const row = loadProposal(db, id, fail);
+  if (!row) return;
+  if (row.status !== "applied" && row.status !== "measured") {
+    return fail(`Only an applied proposal can be reverted; ${id} is '${row.status}'.`);
+  }
+  const applyReceipt = db
+    .prepare("SELECT 1 FROM agent_evolution_receipts WHERE proposal_id = ? AND action = 'apply' LIMIT 1")
+    .get(row.id);
+  if (!applyReceipt) return fail("Revert requires the verified apply receipt.");
+  const agent = agentById(db, row.agent_id);
+  if (!agent) return fail(`Agent not found for proposal: ${row.agent_id}`);
+  const file = targetFilePath(agentFolder, agent, row.target_path);
+  const current = currentTargetHash(file);
+  if (current.hash !== row.after_hash) {
+    return fail("Agent prompt changed after this proposal was applied; revert blocked to avoid clobbering newer edits.");
+  }
+  const now = new Date().toISOString();
+  fs.writeFileSync(file, row.before_content, "utf8");
+  const verify = sha256(fs.readFileSync(file, "utf8"));
+  if (verify !== row.before_hash) {
+    fs.writeFileSync(file, row.after_content, "utf8");
+    return fail("Reverted content did not match the original hash; restored the applied version.");
+  }
+  const tx = db.transaction(() => {
+    db.prepare("UPDATE installed_agents SET system_prompt = ? WHERE id = ?").run(row.before_content, row.agent_id);
+    insertReceipt(db, row, "rollback", row.after_hash, row.before_hash, now);
+    db.prepare(
+      `UPDATE agent_evolution_proposals
+         SET status = 'rolled_back', rolled_back_at = COALESCE(rolled_back_at, ?),
+             last_error = NULL, updated_at = ?
+       WHERE id = ? AND status IN ('applied','measured')`,
+    ).run(now, now, row.id);
+  });
+  tx();
+  out(`reverted ${id} → restored ${row.target_path} (agent ${row.agent_id}).`);
+}
+
+/**
+ * cmdEvolve — `agentlas evolve <sub> ...`.
+ * @param {{db:any,args:string[],out:(s:string)=>void,fail:(s:string)=>void,agentFolder:(a:any)=>string}} ctx
+ */
+function cmdEvolve(ctx) {
+  const { db, out, fail, agentFolder } = ctx;
+  const args = Array.isArray(ctx.args) ? ctx.args : [];
+  const sub = args[0] || "list";
+  if (sub === "help" || sub === "--help" || sub === "-h") {
+    out("usage: agentlas evolve [list | apply <id> | revert <id>]");
+    out("  list          — review pending (approval-needed) and auto-applied agent growth proposals");
+    out("  apply <id>    — approve and apply a pending proposal to the agent prompt");
+    out("  revert <id>   — roll back an applied proposal");
+    return;
+  }
+  if (sub === "list" || sub === "ls") return cmdList(db, out);
+  if (sub === "apply") {
+    if (!args[1]) return fail("usage: agentlas evolve apply <id>");
+    return cmdApply(db, args[1], out, fail, agentFolder);
+  }
+  if (sub === "revert" || sub === "rollback") {
+    if (!args[1]) return fail("usage: agentlas evolve revert <id>");
+    return cmdRevert(db, args[1], out, fail, agentFolder);
+  }
+  return fail(`Unknown evolve subcommand: ${sub} (list|apply|revert)`);
+}
+
+module.exports = { cmdEvolve, countPendingGrowthProposals, listGrowthProposals };

package/engine/agentlas-memory-import.cjs

@@ -0,0 +1,315 @@
+"use strict";
+
+// `agentlas memory import <path> [--apply]` — Phase 1b.
+//
+// Promote legacy markdown memory into the shared agentlas.sqlite the desktop
+// uses (same userData/agentlas.sqlite). Maps each substantive markdown section
+// to a durable memory_entries row owned by the right layer of a team (member
+// cell / orchestrator / shared team_memory) or a single agent. Mirrors the app's
+// electron/memory/import.ts mapping so app and terminal agree. Dry-run by
+// default (prints the preview table); --apply writes. Idempotent via a stable
+// per-section source-hash sentinel embedded in evidence. Secrets are dropped.
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { createHash, randomUUID } = require("node:crypto");
+
+const SOURCE_TOKEN_PREFIX = "mem-import:v1";
+const MAX_FILES = 400;
+const MAX_CONTENT = 4000;
+
+// ── Section extraction (parity with electron/memory/import.ts) ───────────────
+const TEMPLATE_LINE =
+  /^\s*[-*]?\s*(Add\b|Fill in\b|Example:|Record\b|Link\b|Prefer\b|Note\b|Which\b|Date:\s*$|Topic:\s*$|Decision:\s*$|Why:\s*$|Risk accepted:\s*$)/i;
+const META_HEADING =
+  /^(How To Use|사용 규칙|사용법|구조|형식|사전 참조|누가 업데이트|Entries|Read First|Memory Rules|Recent Activity|Recently Touched|CROSS-REFERENCES|LEARNINGS LOG|ANTIPATTERNS|GOTCHAS|Repeated Failures|성공 패턴|발견 사항|안티패턴|에이전트 구성)/i;
+const SHARED_HINT =
+  /(team[-_ ]?memory|team_memory|glossary|handoff|scope[-_ ]?ownership|common[-_ ]?safety|safety|tone|language|dossier|operating[-_ ]?architecture|memory[-_ ]?architecture|용어|공통|안전|인계|톤)/i;
+const RISK_HINT = /(security|attack|vuln|bug|gotcha|incident|보안|취약|버그|사고)/i;
+const ALWAYS_KEEP_HINT = /(team[-_ ]?memory|glossary|dossier|handoff|safety|scope[-_ ]?ownership|tone)/i;
+
+// Minimal secret guard (a subset of the shared secret-patterns chokepoint) so a
+// stray key in legacy notes never becomes a durable memory row.
+const SECRET_RE =
+  /(sk-[A-Za-z0-9]{20,}|sk_live_[A-Za-z0-9]{16,}|github_pat_[A-Za-z0-9_]{20,}|gh[opsu]_[A-Za-z0-9]{20,}|AIza[0-9A-Za-z_-]{20,}|glpat-[A-Za-z0-9_-]{16,}|xox[baprs]-[A-Za-z0-9-]{10,}|-----BEGIN [A-Z ]*PRIVATE KEY-----|AKIA[0-9A-Z]{16})/;
+
+function looksSecret(content) {
+  return SECRET_RE.test(String(content || ""));
+}
+
+function substantiveBody(body) {
+  const lines = body.split("\n").map((l) => l.trim()).filter(Boolean);
+  const real = lines.filter((l) => !TEMPLATE_LINE.test(l) && l.replace(/^#+\s*/, "").length >= 12);
+  return real.join("\n");
+}
+
+function kindForHeading(heading, fallback) {
+  const m = /\[([A-Z_]+)\]/.exec(heading);
+  const tag = m ? m[1] : "";
+  if (["SUCCESS", "DISCOVERY"].includes(tag)) return "procedure";
+  if (["ANTIPATTERN", "GOTCHA", "SECURITY", "CONFIRMED", "REGRESSION", "FALSE_POSITIVE", "BLOCKED_BY_GUARD", "FAILURE"].includes(tag)) {
+    return "risk";
+  }
+  return fallback;
+}
+
+function keepSection(heading, body, alwaysKeep) {
+  if (META_HEADING.test(heading.replace(/\[[A-Z_]+\]\s*/, "").trim())) return false;
+  const hasDate = /\(20\d\d-\d\d-\d\d\)|Date:\s*20\d\d-\d\d-\d\d/.test(heading + "\n" + body);
+  const hasTag = /\[[A-Z_]+\]/.test(heading);
+  const real = substantiveBody(body);
+  if (alwaysKeep) return real.length >= 60;
+  if (hasDate || hasTag) return real.length >= 40;
+  return real.length >= 160;
+}
+
+function splitSections(md) {
+  const lines = md.split("\n");
+  const sections = [];
+  let cur = null;
+  for (const line of lines) {
+    if (/^#{2,3}\s+\S/.test(line)) {
+      if (cur) sections.push(cur);
+      cur = { heading: line.replace(/^#{2,3}\s+/, "").trim(), body: "" };
+    } else if (cur) {
+      cur.body += line + "\n";
+    }
+  }
+  if (cur) sections.push(cur);
+  return sections;
+}
+
+function splitDatedBullets(md) {
+  const idx = md.indexOf("- Date:");
+  if (idx === -1) return [];
+  return md
+    .slice(idx)
+    .split(/\n(?=- Date:)/)
+    .map((p) => p.trim())
+    .filter((p) => /Date:\s*20\d\d-\d\d-\d\d/.test(p))
+    .map((p) => {
+      const topic = /Topic:\s*(.+)/.exec(p);
+      const date = /Date:\s*(20\d\d-\d\d-\d\d)/.exec(p);
+      return { heading: `Decision ${date ? date[1] : ""}: ${topic ? topic[1].trim() : ""}`.trim(), body: p };
+    });
+}
+
+function normalizeToken(value) {
+  return String(value || "").toLowerCase().replace(/[^a-z0-9가-힣]+/g, " ").trim();
+}
+
+function resolveTarget(db, agentId) {
+  let firms = [];
+  try {
+    firms = db.prepare("SELECT id, ceo_agent_id, org_chart_json FROM firms").all();
+  } catch {
+    firms = [];
+  }
+  const firm =
+    firms.find((f) => f.id === agentId) ||
+    firms.find((f) => f.ceo_agent_id === agentId) ||
+    null;
+  if (!firm) return { agentId, kind: "agent", members: [] };
+  let chart = [];
+  try {
+    const parsed = JSON.parse(firm.org_chart_json);
+    if (Array.isArray(parsed)) chart = parsed;
+  } catch {
+    chart = [];
+  }
+  const members = chart
+    .filter((node) => node && node.agentId && node.agentId !== firm.ceo_agent_id)
+    .map((node) => ({ agentId: node.agentId, role: node.role || node.agentSlug, slug: node.agentSlug }));
+  return { agentId: firm.ceo_agent_id, kind: "team", members };
+}
+
+function matchMember(fileTokens, target) {
+  if (!target.members.length) return null;
+  let best = null;
+  for (const member of target.members) {
+    const roleTokens = normalizeToken(member.role).split(" ").filter((t) => t.length >= 3);
+    const slugTokens = normalizeToken(member.slug).split(" ").filter((t) => t.length >= 3);
+    const tokens = [...new Set([...roleTokens, ...slugTokens])];
+    let score = 0;
+    for (const token of tokens) if (fileTokens.includes(token)) score += token.length;
+    if (score > 0 && (!best || score > best.score)) best = { agentId: member.agentId, role: member.role, score };
+  }
+  return best ? { agentId: best.agentId, role: best.role } : null;
+}
+
+function decideOwner(relFile, target) {
+  const lower = relFile.toLowerCase();
+  const fileTokens = normalizeToken(relFile);
+  const alwaysKeep = ALWAYS_KEEP_HINT.test(lower);
+  if (SHARED_HINT.test(lower)) {
+    return {
+      scope: "team_memory",
+      ownerAgentId: null,
+      ownerLabel: "team_memory",
+      fallbackKind: /glossary|dossier|용어/i.test(lower) ? "fact" : "procedure",
+      alwaysKeep,
+    };
+  }
+  if (target.kind === "team") {
+    const member = matchMember(fileTokens, target);
+    if (member) {
+      return { scope: "agent_repo", ownerAgentId: member.agentId, ownerLabel: member.role, fallbackKind: RISK_HINT.test(lower) ? "risk" : "procedure", alwaysKeep };
+    }
+    return { scope: "agent_repo", ownerAgentId: target.agentId, ownerLabel: "orchestrator", fallbackKind: RISK_HINT.test(lower) ? "risk" : "decision", alwaysKeep };
+  }
+  return { scope: "agent_repo", ownerAgentId: target.agentId, ownerLabel: "agent", fallbackKind: RISK_HINT.test(lower) ? "risk" : "procedure", alwaysKeep };
+}
+
+function collectMarkdown(root) {
+  const stat = fs.statSync(root);
+  if (stat.isFile()) {
+    return /\.(md|markdown|mdx|txt)$/i.test(root) ? [{ abs: root, rel: path.basename(root) }] : [];
+  }
+  const out = [];
+  const walk = (dir) => {
+    if (out.length >= MAX_FILES) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (out.length >= MAX_FILES) return;
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const abs = path.join(dir, entry.name);
+      if (entry.isDirectory()) walk(abs);
+      else if (entry.isFile() && /\.(md|markdown|mdx|txt)$/i.test(entry.name)) out.push({ abs, rel: path.relative(root, abs) });
+    }
+  };
+  walk(root);
+  return out.sort((a, b) => a.rel.localeCompare(b.rel));
+}
+
+function stableToken(relFile, heading) {
+  const hash = createHash("sha256").update(`${SOURCE_TOKEN_PREFIX}|${relFile}|${heading}`).digest("hex").slice(0, 16);
+  return `${SOURCE_TOKEN_PREFIX}:${hash}`;
+}
+
+function buildEntries(sourcePath, target) {
+  const built = [];
+  for (const { abs, rel } of collectMarkdown(sourcePath)) {
+    let md;
+    try {
+      md = fs.readFileSync(abs, "utf8");
+    } catch {
+      continue;
+    }
+    const owner = decideOwner(rel, target);
+    const sections = /decisions\.md$/i.test(rel) ? splitDatedBullets(md) : splitSections(md);
+    for (const sec of sections) {
+      if (!keepSection(sec.heading, sec.body, owner.alwaysKeep)) continue;
+      const bodyText = sec.body.replace(/\n{3,}/g, "\n\n").trim();
+      const content = `${sec.heading}\n${bodyText}`.trim().slice(0, MAX_CONTENT);
+      if (content.length < 40) continue;
+      built.push({
+        token: stableToken(rel, sec.heading),
+        relFile: rel,
+        heading: sec.heading,
+        content,
+        scope: owner.scope,
+        kind: kindForHeading(sec.heading, owner.fallbackKind),
+        ownerAgentId: owner.ownerAgentId,
+        ownerLabel: owner.ownerLabel,
+        redacted: looksSecret(content),
+      });
+    }
+  }
+  return built;
+}
+
+function existsByToken(db, token) {
+  try {
+    return Boolean(db.prepare("SELECT 1 FROM memory_entries WHERE evidence_json LIKE ? LIMIT 1").get(`%${token}%`));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * cmdMemory — `agentlas memory <sub> ...`. Currently: import.
+ * @param {{db:any,args:string[],out:(s:string)=>void,fail:(s:string)=>void}} ctx
+ */
+function cmdMemory(ctx) {
+  const { db, out, fail } = ctx;
+  const args = Array.isArray(ctx.args) ? ctx.args : [];
+  const sub = args[0] || "help";
+  if (sub === "help" || sub === "--help" || sub === "-h") {
+    out("usage: agentlas memory import <folder-or-file> --agent <agentId> [--apply]");
+    out("  dry-run by default (prints the preview table); --apply writes to the shared DB.");
+    return;
+  }
+  if (sub !== "import") return fail(`Unknown memory subcommand: ${sub} (import)`);
+
+  const apply = args.includes("--apply");
+  const agentIdx = args.indexOf("--agent");
+  const agentId = agentIdx >= 0 ? String(args[agentIdx + 1] || "").trim() : "";
+  const positional = args.slice(1).filter((a, i, arr) => a !== "--apply" && a !== "--agent" && arr[i - 1] !== "--agent");
+  const rawPath = positional[0];
+  if (!rawPath) return fail('usage: agentlas memory import <folder-or-file> --agent <agentId> [--apply]');
+  if (!agentId) return fail("memory import requires --agent <agentId> (the single agent or team to import into).");
+  const sourcePath = path.resolve(rawPath);
+  if (!fs.existsSync(sourcePath)) return fail(`Import source not found: ${sourcePath}`);
+
+  const target = resolveTarget(db, agentId);
+  const entries = buildEntries(sourcePath, target);
+
+  out(`== memory import (${apply ? "APPLY" : "DRY-RUN"}) ==`);
+  out(`source: ${sourcePath}`);
+  out(`target: ${agentId} (${target.kind})`);
+  out("");
+  out(pad("OWNER", 26) + pad("KIND", 10) + pad("STATUS", 8) + "SECTION");
+  const byOwner = {};
+  let newCount = 0;
+  let dupCount = 0;
+  let redacted = 0;
+  for (const e of entries) {
+    const status = e.redacted ? "skip" : existsByToken(db, e.token) ? "dup" : "new";
+    if (status === "new") {
+      newCount += 1;
+      byOwner[e.ownerLabel] = (byOwner[e.ownerLabel] || 0) + 1;
+    } else if (status === "dup") dupCount += 1;
+    else redacted += 1;
+    out(pad(e.ownerLabel, 26) + pad(e.kind, 10) + pad(status, 8) + e.heading.slice(0, 70));
+  }
+  out("");
+  out(`total ${entries.length} · new ${newCount} · duplicate ${dupCount} · redacted ${redacted}`);
+
+  if (!apply) {
+    out("");
+    out("dry-run — nothing written. Re-run with --apply to write to the shared agentlas.sqlite.");
+    return;
+  }
+
+  const now = new Date().toISOString();
+  let imported = 0;
+  const insert = db.prepare(
+    "INSERT INTO memory_entries (id,scope,kind,content,project_id,project_path,agent_id,chat_id,confidence,sensitivity,evidence_json,context_json,superseded_at,created_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,NULL,?)",
+  );
+  const write = db.transaction((list) => {
+    for (const e of list) {
+      if (e.redacted || existsByToken(db, e.token)) continue;
+      const confidence = /\(20\d\d-\d\d-\d\d\)|Date:\s*20\d\d/.test(e.content) ? "high" : "medium";
+      const context = JSON.stringify({ userIntent: `Imported memory: ${e.heading}`.slice(0, 200), outcome: "imported-from-existing-memory" });
+      const evidence = JSON.stringify([e.token, `source:memory-import/${e.relFile}`]);
+      insert.run(randomUUID(), e.scope, e.kind, e.content, null, null, e.ownerAgentId, null, confidence, "internal", evidence, context, now);
+      imported += 1;
+    }
+  });
+  write(entries);
+
+  out("");
+  out(`imported ${imported} memory entries into the shared DB. (Embedding runs in the desktop app on next open.)`);
+}
+
+function pad(value, width) {
+  const s = String(value == null ? "" : value);
+  return s.length >= width ? s.slice(0, width - 1) + " " : s + " ".repeat(width - s.length);
+}
+
+module.exports = { cmdMemory, buildEntries, resolveTarget, decideOwner };

package/engine/agentlas.cjs

@@ -10022,6 +10022,19 @@ function cmdList(db) {
         : "\n(Built-in orchestration agents run in the background. Find agents with `agentlas cloud search \"what you need\"`, or just open `agentlas` and type a task.)",
     );
   }
+  // Phase 2+: 검토 대기 중인 에이전트 성장 제안이 있으면 홈에 한 줄로 노출.
+  try {
+    const pendingGrowth = require("./agentlas-evolution.cjs").countPendingGrowthProposals(db);
+    if (pendingGrowth > 0) {
+      out(
+        lang === "ko"
+          ? `\n🧬 에이전트 성장 제안 ${pendingGrowth}건 · \`agentlas evolve\`로 검토`
+          : `\n🧬 ${pendingGrowth} agent growth proposal(s) · review with \`agentlas evolve\``,
+      );
+    }
+  } catch {
+    /* 홈 배너 실패는 무해 */
+  }
   out("\nRun: agentlas <agent>  ·  agentlas firm <firm>  ·  agentlas run <agent> \"...\"");
 }
 
@@ -11737,6 +11750,12 @@ async function main() {
       return cmdFirm(db, rest[1], rest.slice(2).join(" "), runtimeOverride);
     case "env":
       return cmdEnv(db);
+    case "memory":
+      // Phase 1b: 기존 마크다운 메모리 → 공유 agentlas.sqlite 이관(dry-run 기본, --apply).
+      return require("./agentlas-memory-import.cjs").cmdMemory({ db, args: rest.slice(1), out, fail });
+    case "evolve":
+      // Phase 2/2+: 데스크탑 트리거가 만든 성장 제안 검토·적용·되돌리기(공유 DB).
+      return require("./agentlas-evolution.cjs").cmdEvolve({ db, args: rest.slice(1), out, fail, agentFolder });
     case "multimodal":
       return cmdMultimodal(db, rest.slice(1));
     case "oberon":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlas",
-  "version": "0.9.4",
+  "version": "0.9.5",
   "description": "Agentlas agent terminal — chat with your installed AI agents and teams from the terminal, Claude Code style. Standalone: no desktop app required.",
   "bin": {
     "agentlas": "bin/agentlas.cjs"