agentlas 0.9.9 → 1.0.1

package/engine/mcp/plan.cjs

@@ -0,0 +1,286 @@
+"use strict";
+/*
+ * mcp/plan — 요구사항 해소 + MCP 빌드 플랜 구성 + 빌더 지시문.
+ *
+ * 계약(v1 그대로):
+ *  - 플랜은 추천일 뿐이다. 명시적 1회 동의 전에는 어떤 MCP도 attach되지 않는다.
+ *  - 네트워크 발견/키 프로브/설치는 절대 수행하지 않는다.
+ *  - 부족(shortage)은 요구사항 단위로 격리된다 — 빌드는 중단되지 않고 degrade만 한다.
+ *  - 신뢰 레지스트리가 자격증명 매핑을 소유한다: 패키지가 env 메타데이터 선언만으로
+ *    무자격 레지스트리 행을 "key present"로 둔갑시킬 수 없다.
+ */
+const crypto = require("node:crypto");
+const {
+  MAX_APPROVED_MCP_PER_BUILD,
+  assertId,
+} = require("./contract.cjs");
+
+const MAX_BUILD_DIRECTIVE_CHARS = 1400;
+
+function syntheticRequirement(catalogId, required, priority) {
+  const suffix = crypto.createHash("sha256").update(catalogId).digest("hex").slice(0, 24);
+  return {
+    schemaVersion: "agentlas.mcp-requirement.v1",
+    kind: "agentlas-mcp-requirement",
+    requirementId: `terminal-requirement:${suffix}`,
+    catalogId,
+    reason: required ? "Explicitly required for this Terminal build" : "Explicitly recommended for this Terminal build",
+    capabilities: [`terminal-mcp:${suffix}`],
+    required,
+    requiresKey: false,
+    priority,
+    permissions: [],
+    alternatives: [],
+    unavailablePolicy: {
+      build: "degrade",
+      rental: required ? "exclude-variant" : "continue-degraded",
+      execution: required ? "use-alternative" : "continue-degraded",
+    },
+  };
+}
+
+// 이름 휴리스틱은 "추천 후보 회수"만 담당한다 — 최종 선택/attach 권한이 아니다.
+const HEURISTIC_GROUPS = [
+  [/(browser|playwright|chrome|web)/i, /(?:browser|website|web page|웹|브라우저|사이트|페이지|로그인)/i],
+  [/(github|gitlab|source)/i, /(?:github|gitlab|repository|pull request|issue|깃허브|레포|저장소)/i],
+  [/(figma|design)/i, /(?:figma|mockup|design|ui|ux|피그마|디자인)/i],
+  [/(postgres|mysql|sqlite|database|mongo)/i, /(?:database|sql|query|schema|db|데이터베이스|쿼리)/i],
+  [/(notion|docs|drive)/i, /(?:notion|document|docs|drive|노션|문서|드라이브)/i],
+  [/(slack|teams|discord)/i, /(?:slack|teams|discord|message|슬랙|메시지)/i],
+  [/(search|research)/i, /(?:search|research|lookup|검색|리서치|조사)/i],
+];
+
+function inferRequirements(request, inventory) {
+  const text = String(request || "");
+  const results = [];
+  for (const item of inventory) {
+    const direct = text.toLowerCase().includes(item.catalogId.toLowerCase()) || text.toLowerCase().includes(item.name.toLowerCase());
+    const heuristic = HEURISTIC_GROUPS.some(([nameRe, taskRe]) => nameRe.test(`${item.catalogId} ${item.name}`) && taskRe.test(text));
+    if (direct || heuristic) results.push(syntheticRequirement(item.catalogId, false, results.length + 100));
+  }
+  return results.slice(0, 8);
+}
+
+function indexInventory(inventory) {
+  return new Map((inventory || []).map((item) => [item.catalogId, item]));
+}
+
+function resolveMcpRequirement(requirement, inventoryById) {
+  const order = [requirement.catalogId, ...(requirement.alternatives || [])];
+  const attempted = [];
+  const candidates = [];
+  for (const catalogId of order) {
+    const item = inventoryById.get(catalogId);
+    if (!item) {
+      attempted.push({ catalogId, status: "unavailable" });
+      continue;
+    }
+    if (item.transport !== "stdio") {
+      attempted.push({ catalogId, status: "runtime-incompatible" });
+      continue;
+    }
+    const keyRequired = requirement.requiresKey || item.keyRequired;
+    // The trusted registry owns credential mapping. A package cannot turn an
+    // uncredentialed registry row into "key present" merely by declaring env metadata.
+    const keyPresent = keyRequired ? (item.keyRequired && item.keyPresent) : true;
+    if (!keyPresent) {
+      attempted.push({ catalogId, status: "missing-key" });
+      continue;
+    }
+    candidates.push({ item, keyRequired, keyPresent: true });
+  }
+  if (candidates.length) {
+    return {
+      selected: candidates[0].item,
+      candidates,
+      status: "available",
+      attempted,
+      keyRequired: candidates[0].keyRequired,
+      keyPresent: true,
+    };
+  }
+  const primary = inventoryById.get(requirement.catalogId);
+  const keyRequired = requirement.requiresKey || Boolean(primary && primary.keyRequired);
+  const missingKey = attempted.some((attempt) => attempt.status === "missing-key");
+  return { selected: null, candidates: [], status: missingKey ? "missing-key" : "unavailable", attempted, keyRequired, keyPresent: false };
+}
+
+function buildMcpPlan(options) {
+  const inventory = options.inventory || [];
+  const inventoryById = indexInventory(inventory);
+  const policyRequirements = options.policy ? options.policy.requirements : [];
+  const requirements = [...policyRequirements];
+  const known = new Set(requirements.map((requirement) => requirement.catalogId));
+  for (const catalogId of options.requiredIds || []) {
+    assertId(catalogId, "--require-mcp");
+    if (!known.has(catalogId)) { requirements.push(syntheticRequirement(catalogId, true, 1)); known.add(catalogId); }
+  }
+  for (const catalogId of options.recommendedIds || []) {
+    assertId(catalogId, "--recommend-mcp");
+    if (!known.has(catalogId)) { requirements.push(syntheticRequirement(catalogId, false, 500)); known.add(catalogId); }
+  }
+  if (!requirements.length) requirements.push(...inferRequirements(options.request, inventory));
+  const entries = requirements
+    .map((requirement) => {
+      const resolution = resolveMcpRequirement(requirement, inventoryById);
+      const entry = {
+        requirementId: requirement.requirementId,
+        requestedCatalogId: requirement.catalogId,
+        resolvedCatalogId: resolution.selected ? resolution.selected.catalogId : null,
+        name: resolution.selected ? resolution.selected.name : requirement.catalogId,
+        source: resolution.selected ? resolution.selected.source : null,
+        required: requirement.required,
+        priority: requirement.priority,
+        reason: requirement.reason,
+        status: resolution.status,
+        keyRequired: resolution.keyRequired,
+        keyPresent: resolution.keyRequired ? resolution.keyPresent : null,
+        permissions: [...(requirement.permissions || [])],
+        permissionBasis: "package-declared",
+        permissionEnforced: false,
+        fallbackCatalogIds: resolution.candidates.slice(1).map((candidate) => candidate.item.catalogId),
+        alternativesTried: resolution.attempted.map((attempt) => ({ catalogId: attempt.catalogId, status: attempt.status })),
+        unavailableBuildPolicy: "degrade",
+      };
+      // 레지스트리 행 id/지문은 post-consent 재검증 재료 — 공개 투영에서 제외.
+      Object.defineProperty(entry, "registryServerId", {
+        value: resolution.selected?.registryServerId || null,
+        enumerable: false,
+      });
+      Object.defineProperty(entry, "credentialKeyFingerprint", {
+        value: resolution.selected?.credentialKeyFingerprint || null,
+        enumerable: false,
+      });
+      Object.defineProperty(entry, "runtimeCandidates", {
+        value: resolution.candidates.map((candidate) => ({
+          resolvedCatalogId: candidate.item.catalogId,
+          registryServerId: candidate.item.registryServerId || null,
+          credentialKeyFingerprint: candidate.item.credentialKeyFingerprint || null,
+        })),
+        enumerable: false,
+      });
+      return entry;
+    })
+    .sort((a, b) => Number(b.required) - Number(a.required) || a.priority - b.priority || a.requestedCatalogId.localeCompare(b.requestedCatalogId));
+  return {
+    schemaVersion: "agentlas.terminal-mcp-build-plan.v1",
+    planId: crypto.randomUUID(),
+    registryStatus: options.registryStatus || inventory.registryStatus || "complete",
+    registryResolutionOrder: options.policy ? [...options.policy.registryResolutionOrder] : ["system-global"],
+    discoveryNetworkUsed: false,
+    consentMode: "one-pass",
+    entries,
+    availableCatalogIds: [...new Set(entries.flatMap((entry) =>
+      entry.status === "available" ? (entry.runtimeCandidates || []).map((candidate) => candidate.resolvedCatalogId) : []
+    ))],
+    maxApprovedMcp: MAX_APPROVED_MCP_PER_BUILD,
+    shortages: entries.filter((entry) => entry.status !== "available").map((entry) => ({
+      requirementId: entry.requirementId,
+      catalogId: entry.requestedCatalogId,
+      required: entry.required,
+      status: entry.status,
+      effect: "build-degraded-only",
+    })),
+  };
+}
+
+function renderMcpPlan(plan) {
+  const lines = [`MCP BUILD PLAN · system-global registry first · registry: ${plan.registryStatus} · no network discovery`];
+  if (plan.registryStatus === "unavailable") lines.push("- System-global registry could not be read. Build continues safely in empty-MCP mode; no install/network fallback was attempted.");
+  if (!plan.entries.length) lines.push("- No relevant MCP recommended. Build continues in empty-MCP mode.");
+  for (const entry of plan.entries) {
+    const key = entry.keyRequired ? (entry.keyPresent ? "key: present" : "key: missing") : "key: not needed";
+    const requirement = entry.required ? "required" : "optional";
+    const permissions = entry.permissions.length ? entry.permissions.join(",") : "none";
+    lines.push(`- P${entry.priority} ${entry.name} [${entry.resolvedCatalogId || entry.requestedCatalogId}] · ${requirement} · ${entry.status} · ${key}`);
+    lines.push(`  ${entry.reason}`);
+    if (entry.fallbackCatalogIds?.length) lines.push(`  approved fallback order: ${entry.fallbackCatalogIds.join(",")}`);
+    lines.push(`  permissions: ${permissions} · declared only; host enforcement not yet verified`);
+  }
+  if (plan.shortages.length) lines.push(`Shortages are isolated: ${plan.shortages.length} requirement(s) degrade only; the build does not abort.`);
+  lines.push("Recommendation only: no MCP is attached until one explicit consent; this plan performs no network key probe or install.");
+  return lines.join("\n");
+}
+
+function fitApprovedMcpIds(plan, requestedIds) {
+  const available = new Set(plan.availableCatalogIds || []);
+  const requested = [...new Set((requestedIds || []).filter((id) => available.has(id)))].slice(0, MAX_APPROVED_MCP_PER_BUILD);
+  const accepted = [];
+  const fixedReserve = 520; // frozen instruction + minimum shortage/degrade clause
+  for (const id of requested) {
+    const clause = `Approved catalog IDs: ${accepted.concat(id).join(",")}.`;
+    if (clause.length + fixedReserve > MAX_BUILD_DIRECTIVE_CHARS) break;
+    accepted.push(id);
+  }
+  return accepted;
+}
+
+function buildMcpDirective(plan, approvedIds) {
+  const approved = fitApprovedMcpIds(plan, approvedIds);
+  const shortages = plan.shortages.map((item) => item.catalogId);
+  const base = [
+    "[AGENTLAS_MCP_BUILD_CONTEXT v1]",
+    "Resolve MCP only from the host system-global registry; package IDs/requirements only, never server definitions or credentials.",
+  ].join(" ");
+  const approvedClause = `Approved catalog IDs: ${approved.length ? approved.join(",") : "none"}.`;
+  const shortagePrefix = "Unavailable or missing-key IDs: ";
+  const shortageSuffix = "; degrade each capability independently and continue the build.";
+  const fittedShortages = [];
+  for (const id of shortages.slice(0, 16)) {
+    const omitted = shortages.length - fittedShortages.length - 1;
+    const proposal = `${shortagePrefix}${fittedShortages.concat(id).join(",")}${omitted > 0 ? ` (+${omitted} more)` : ""}${shortageSuffix}`;
+    if (`${base} ${approvedClause} ${proposal}`.length > MAX_BUILD_DIRECTIVE_CHARS) break;
+    fittedShortages.push(id);
+  }
+  const omittedShortages = shortages.length - fittedShortages.length;
+  const shortageValue = shortages.length === 0
+    ? "none"
+    : fittedShortages.length
+      ? `${fittedShortages.join(",")}${omittedShortages > 0 ? ` (+${omittedShortages} more)` : ""}`
+      : `${shortages.length} unresolved (IDs omitted from prompt; declared policy remains source)`;
+  const shortageClause = `${shortagePrefix}${shortageValue}${shortageSuffix}`;
+  const line = `${base} ${approvedClause} ${shortageClause}`;
+  if (line.length > MAX_BUILD_DIRECTIVE_CHARS) throw new Error("internal MCP builder directive exceeded its context limit");
+  return line;
+}
+
+function renderBuildMcpResult(plan, approvedIds, runtimeAllowlist = null) {
+  const approved = new Set(approvedIds || []);
+  const attached = new Set((runtimeAllowlist?.attached || []).map((item) => item.catalogId));
+  const failed = new Map((runtimeAllowlist?.failed || []).map((item) => [item.catalogId, item.reason]));
+  const lines = ["MCP BUILD RESULT"];
+  for (const entry of plan.entries) {
+    let status = entry.status;
+    if (entry.status === "available") {
+      const candidateIds = [entry.resolvedCatalogId, ...(entry.fallbackCatalogIds || [])].filter(Boolean);
+      const attachedId = candidateIds.find((id) => attached.has(id));
+      const approvedId = candidateIds.find((id) => approved.has(id));
+      const failedId = candidateIds.find((id) => failed.has(id));
+      status = attachedId
+        ? attachedId === entry.resolvedCatalogId ? "connected-and-allowlisted" : `fallback-connected-and-allowlisted:${attachedId}`
+        : failedId
+          ? `failed-isolated:${failedId}:${failed.get(failedId)}`
+          : approvedId
+            ? "approved-but-not-attached"
+            : "skipped";
+    }
+    lines.push(`- ${entry.resolvedCatalogId || entry.requestedCatalogId}: ${status}`);
+  }
+  if (!runtimeAllowlist || runtimeAllowlist.emptyMode) lines.push("- Build continued in empty-MCP mode.");
+  if (runtimeAllowlist && runtimeAllowlist.consentPersisted === false) lines.push("- Runtime consent was one-pass only because its local fingerprint receipt could not be saved.");
+  lines.push("Only the post-consent host allowlist reached the builder; tool-call success is not implied by connection readiness.");
+  return lines.join("\n");
+}
+
+module.exports = {
+  MAX_BUILD_DIRECTIVE_CHARS,
+  syntheticRequirement,
+  inferRequirements,
+  indexInventory,
+  resolveMcpRequirement,
+  buildMcpPlan,
+  renderMcpPlan,
+  fitApprovedMcpIds,
+  buildMcpDirective,
+  renderBuildMcpResult,
+};

package/engine/mcp/probe.cjs

@@ -0,0 +1,151 @@
+"use strict";
+/*
+ * mcp/probe — stdio MCP 서버 연결 프리플라이트.
+ *
+ * initialize → notifications/initialized → tools/list 핸드셰이크만 수행하고
+ * 즉시 종료한다. 툴 호출은 절대 하지 않는다("연결됨 ≠ 툴 성공" 계약).
+ * 자식 env는 agentlas-mcp-env의 buildMcpChildEnv 경계(agentlas.mcp-child-launch.v1)
+ * 를 그대로 재사용한다 — 여기서 env를 따로 구성하면 격리 계약이 깨진다.
+ */
+const { spawn } = require("node:child_process");
+const { buildMcpChildEnv, mcpRuntimeHome } = require("../agentlas-mcp-env.cjs");
+const { parseRuntimeServerArgs } = require("./contract.cjs");
+
+const MCP_PROBE_CONCURRENCY = 3;
+const MCP_PROBE_PER_SERVER_TIMEOUT_MS = 8_000;
+const MCP_PROBE_TOTAL_TIMEOUT_MS = 12_000;
+
+function probeSystemMcpServerConnection(server, options = {}) {
+  const requestedTimeout = Number(options.timeoutMs);
+  const timeoutMs = Number.isFinite(requestedTimeout)
+    ? Math.max(50, Math.min(30_000, Math.trunc(requestedTimeout)))
+    : MCP_PROBE_PER_SERVER_TIMEOUT_MS;
+  const spawnImpl = options.spawn || spawn;
+  return new Promise((resolve) => {
+    let child = null;
+    let settled = false;
+    let buffer = Buffer.alloc(0);
+    let totalBytes = 0;
+    let initialized = false;
+    let abortHandler = null;
+    let forceKillTimer = null;
+    let childClosed = false;
+    const terminateChild = (signal) => {
+      const pid = Number(child?.pid);
+      // detached 자식은 프로세스 그룹(-pid)째로 종료해야 패키지 매니저가 띄운
+      // 손자 프로세스가 고아로 남지 않는다.
+      if (process.platform !== "win32" && Number.isInteger(pid) && pid > 1) {
+        try { process.kill(-pid, signal); return; } catch { /* fall through */ }
+      }
+      try { child?.kill(signal); } catch { /* noop */ }
+    };
+    const finish = (connected, reason, tools = []) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (options.signal && abortHandler) options.signal.removeEventListener?.("abort", abortHandler);
+      try { child?.stdin?.end(); } catch { /* noop */ }
+      if (!childClosed) {
+        terminateChild("SIGTERM");
+        forceKillTimer = setTimeout(() => terminateChild("SIGKILL"), 250);
+        forceKillTimer.unref?.();
+      }
+      const result = { connected, reason };
+      // tools 목록은 프리플라이트 참고 정보일 뿐 공개 투영에 실리면 안 된다.
+      Object.defineProperty(result, "tools", {
+        value: Array.isArray(tools) ? tools : [],
+        enumerable: false,
+      });
+      resolve(result);
+    };
+    const onMessage = (message) => {
+      if (!message || message.jsonrpc !== "2.0") return;
+      if (message.id === 1) {
+        if (message.error || !message.result) return finish(false, "initialize_failed");
+        initialized = true;
+        try {
+          child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized", params: {} })}\n`);
+          child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} })}\n`);
+        } catch {
+          finish(false, "connection_failed");
+        }
+      } else if (message.id === 2 && initialized) {
+        finish(
+          !message.error && Boolean(message.result),
+          message.error ? "tools_list_failed" : "connected",
+          message.result?.tools,
+        );
+      }
+    };
+    const drain = () => {
+      // 서버가 Content-Length 프레이밍과 개행 구분 JSON 중 무엇을 쓰든 수용한다.
+      while (buffer.length) {
+        const header = buffer.toString("ascii", 0, Math.min(buffer.length, 64 * 1024)).match(/^Content-Length:\s*(\d+)\r?\n\r?\n/i);
+        if (header) {
+          const headerBytes = Buffer.byteLength(header[0], "ascii");
+          const bodyBytes = Number(header[1]);
+          if (!Number.isSafeInteger(bodyBytes) || bodyBytes < 0 || bodyBytes > 1024 * 1024) return finish(false, "invalid_protocol_frame");
+          if (buffer.length < headerBytes + bodyBytes) return;
+          const body = buffer.subarray(headerBytes, headerBytes + bodyBytes).toString("utf8");
+          buffer = buffer.subarray(headerBytes + bodyBytes);
+          try { onMessage(JSON.parse(body)); } catch { /* ignore non-JSON noise */ }
+          continue;
+        }
+        const newline = buffer.indexOf(0x0a);
+        if (newline < 0) return;
+        const line = buffer.subarray(0, newline).toString("utf8").trim();
+        buffer = buffer.subarray(newline + 1);
+        if (!line || /^Content-Length:/i.test(line)) continue;
+        try { onMessage(JSON.parse(line)); } catch { /* ignore banners */ }
+      }
+    };
+    const timer = setTimeout(() => finish(false, "connection_timeout"), timeoutMs);
+    try {
+      child = spawnImpl(server.command, parseRuntimeServerArgs(server.args_json) || [], {
+        cwd: options.cwd || process.cwd(),
+        env: buildMcpChildEnv(options.env || process.env, server.credentialKeyNames || [], {
+          runtimeHome: server.mcpRuntimeHome || mcpRuntimeHome(options.userDataDir, server.catalog_id || server.id || server.command),
+        }),
+        detached: process.platform !== "win32",
+        stdio: ["pipe", "pipe", "ignore"],
+      });
+      child.once("error", () => finish(false, "connection_failed"));
+      child.once("close", () => {
+        childClosed = true;
+        if (forceKillTimer) clearTimeout(forceKillTimer);
+        forceKillTimer = null;
+        finish(false, "connection_closed");
+      });
+      child.stdout.on("data", (chunk) => {
+        totalBytes += chunk.length;
+        if (totalBytes > 1024 * 1024) return finish(false, "protocol_output_limit");
+        buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
+        drain();
+      });
+      child.stdin.write(`${JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "agentlas-terminal-build", version: "1" },
+        },
+      })}\n`);
+      if (options.signal) {
+        abortHandler = () => finish(false, "connection_timeout");
+        if (options.signal.aborted) abortHandler();
+        else options.signal.addEventListener?.("abort", abortHandler, { once: true });
+      }
+    } catch {
+      finish(false, "connection_failed");
+    }
+  });
+}
+
+module.exports = {
+  MCP_PROBE_CONCURRENCY,
+  MCP_PROBE_PER_SERVER_TIMEOUT_MS,
+  MCP_PROBE_TOTAL_TIMEOUT_MS,
+  probeSystemMcpServerConnection,
+};

package/engine/memory-cli/curate.cjs

@@ -0,0 +1,163 @@
+"use strict";
+
+/*
+ * memory-cli/curate — 어시스턴트 응답의 `## Memory Events` 큐레이션 파서/게이트.
+ *
+ * v1 모놀리스(engine/agentlas.cjs)의 parseMemoryEventsCli/curateCliReply
+ * 슬라이스를 이식했다. 큐레이터(LLM)는 후보를 "제안"만 하고, 여기의 결정적
+ * 게이트가 실제 durable 쓰기를 결정한다(제안 ≠ 승인).
+ *
+ * 불변식(v1 그대로):
+ *  - permission=read 턴은 어떤 durable 쓰기도 하지 않는다(응답 정리만).
+ *  - SECRET_RE에 걸리는 후보와 sensitivity=secret 후보는 무조건 버린다.
+ *  - user_identity 승격은 confidence=high + 허용 kind에서만; 아니면 session 강등.
+ *  - session/discard는 프로젝트 로그(memory-log.jsonl)로만 남는다.
+ *  - 중복(scope+kind+content+project) 행은 재삽입하지 않고 기존 행을 재사용한다.
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { tableExists, columnExists } = require("../core/db.cjs");
+
+// 앱과 동일한 컴파일된 manifest — 빌트인 에이전트 + 메모리 아키텍처 상수.
+let _arch = null;
+function loadArch() {
+  if (_arch) return _arch;
+  try {
+    _arch = require("../architecture.data.json");
+  } catch {
+    _arch = { version: "0", agents: [], emitterBlock: "", eventsHeading: "## Memory Events", memoryDir: ".agentlas", soulFile: "project-soul-memory.md", sitemapFile: "sitemap.json", logFile: "memory-log.jsonl", kinds: [], scopes: [] };
+  }
+  return _arch;
+}
+
+function ensureMemoryContextColumn(db) {
+  try {
+    if (tableExists(db, "memory_entries") && !columnExists(db, "memory_entries", "context_json")) {
+      db.exec("ALTER TABLE memory_entries ADD COLUMN context_json TEXT NOT NULL DEFAULT '{}'");
+    }
+  } catch { /* ignore */ }
+}
+
+const SECRET_RE = [/\b(?:sk|pk|rk)-[A-Za-z0-9]{16,}/, /AKIA[0-9A-Z]{16}/, /ghp_[A-Za-z0-9]{20,}/, /xox[baprs]-[A-Za-z0-9-]{10,}/, /-----BEGIN [A-Z ]*PRIVATE KEY-----/, /\b(?:password|passwd|secret|api[_-]?key|access[_-]?token|bearer)\b\s*[:=]\s*\S+/i];
+
+/*
+ * 프로젝트 메모리 로그 한 줄 추가. v1은 ensureProjectMemoryCli(전체 프로젝트
+ * 스캐폴딩: soul/sitemap/ontology 등)를 거쳤지만, 그 스캐폴딩은 v2에서 프로젝트
+ * 부트스트랩 모듈 소관이다. 큐레이션 관점의 계약(=.agentlas/memory-log.jsonl에
+ * 결정 로그가 남는다)만 여기서 보장한다 — 로그 누락은 없고, 스캐폴딩 생성은
+ * 이 모듈이 위장하지 않는다.
+ */
+function logCli(projectPath, rec) {
+  if (!projectPath) return;
+  try {
+    const arch = loadArch();
+    const dir = path.join(projectPath, arch.memoryDir);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.appendFileSync(path.join(dir, arch.logFile), JSON.stringify(rec) + "\n", "utf8");
+  } catch { /* ignore */ }
+}
+
+function coerceText(v, max) {
+  if (typeof v !== "string") return undefined;
+  const s = v.trim();
+  return s ? s.slice(0, max) : undefined;
+}
+
+function coerceNullableText(v, max) {
+  if (v === null) return null;
+  return coerceText(v, max);
+}
+
+function normalizeRequestContext(ev, ctx, projectPath) {
+  const raw = ev && ev.request_context && typeof ev.request_context === "object" ? ev.request_context : {};
+  const triggerTerms = Array.isArray(raw.trigger_terms)
+    ? [...new Set(raw.trigger_terms.filter((x) => typeof x === "string").map((x) => x.trim()).filter(Boolean))]
+        .slice(0, 12)
+        .map((x) => x.slice(0, 40))
+    : undefined;
+  const cwd = coerceNullableText(raw.cwd_at_request, 500) ?? ctx.cwdAtRequest ?? ctx.cwd ?? ctx.projectPath ?? null;
+  const targetProject = coerceNullableText(raw.target_project, 120) ?? ctx.projectId ?? null;
+  const targetPath = coerceNullableText(raw.target_path, 500) ?? projectPath ?? null;
+  const out = {};
+  const userIntent = coerceText(raw.user_intent, 240);
+  const outcome = coerceNullableText(raw.outcome, 240);
+  if (userIntent) out.user_intent = userIntent;
+  if (triggerTerms && triggerTerms.length) out.trigger_terms = triggerTerms;
+  if (cwd !== undefined) out.cwd_at_request = cwd;
+  if (targetProject !== undefined) out.target_project = targetProject;
+  if (targetPath !== undefined) out.target_path = targetPath;
+  out.cross_context = typeof raw.cross_context === "boolean" ? raw.cross_context : !!(cwd && targetPath && cwd !== targetPath);
+  if (outcome !== undefined) out.outcome = outcome;
+  if (SECRET_RE.some((re) => re.test(JSON.stringify(out)))) return {};
+  return Object.keys(out).length ? out : {};
+}
+
+function parseMemoryEventsCli(text) {
+  const heading = loadArch().eventsHeading;
+  const idx = text.lastIndexOf(heading);
+  if (idx < 0) return { events: [], cleaned: text.trim() };
+  const after = text.slice(idx + heading.length);
+  const fence = after.match(/```(?:json)?\s*([\s\S]*?)```/);
+  let events = [];
+  if (fence) { try { const d = JSON.parse(fence[1].trim()); if (Array.isArray(d)) events = d; } catch { /* ignore */ } }
+  let cut = text.length;
+  if (fence && fence.index != null) cut = idx + heading.length + fence.index + fence[0].length;
+  const before = text.slice(0, idx).replace(/<!--\s*$/u, "");
+  const remainder = text.slice(cut).replace(/^\s*-->/u, "");
+  return { events, cleaned: (before + remainder).trim() };
+}
+
+function curateCliReply(db, text, ctx) {
+  const { events, cleaned } = parseMemoryEventsCli(text);
+  const style = require("../agentlas-style.cjs");
+  if (ctx && ctx.permission === "read") return style.sanitizeAssistantText(cleaned);
+  if (!events.length || !tableExists(db, "memory_entries")) return style.sanitizeAssistantText(cleaned);
+  ensureMemoryContextColumn(db);
+  const arch = loadArch();
+  const { randomUUID } = require("node:crypto");
+  const now = new Date().toISOString();
+  const rememberCurated = (memory) => {
+    if (!ctx || !Array.isArray(ctx.curatedMemories) || !memory) return;
+    if (!ctx.curatedMemories.some((item) => item.id === memory.id)) ctx.curatedMemories.push(memory);
+  };
+  for (const ev of events) {
+    const content = ev && typeof ev.content === "string" ? ev.content.trim() : "";
+    if (!content) continue;
+    if (ev.sensitivity === "secret" || SECRET_RE.some((re) => re.test(content))) continue;
+    const kind = arch.kinds.includes(ev.memory_kind) ? ev.memory_kind : "fact";
+    let scope = ev.suggested_scope === "agent_team"
+      ? "team_memory"
+      : arch.scopes.includes(ev.suggested_scope) ? ev.suggested_scope : "session";
+    const kindAllowsUserIdentity = ["fact", "decision", "preference", "procedure"].includes(kind);
+    if (scope === "user_identity" && (ev.confidence !== "high" || !kindAllowsUserIdentity)) scope = "session";
+    if (scope === "discard" || scope === "session") { logCli(ctx.projectPath, { action: scope, kind, content, at: now }); continue; }
+    if (scope === "project" && !ctx.projectPath) scope = "team_memory";
+    const ppath = scope === "project" ? ctx.projectPath : null;
+    const requestContext = normalizeRequestContext(ev, ctx, ppath);
+    try {
+      const dup = db.prepare("SELECT id,scope,kind,content,confidence,sensitivity,context_json FROM memory_entries WHERE scope=? AND kind=? AND lower(trim(content))=? AND superseded_at IS NULL AND (project_path IS ? OR project_path=?) LIMIT 1").get(scope, kind, content.toLowerCase(), ppath, ppath);
+      if (dup) {
+        rememberCurated({ ...dup, requestContext });
+        continue;
+      }
+      const memoryId = randomUUID();
+      const confidence = ev.confidence || "medium";
+      const sensitivity = ev.sensitivity || "internal";
+      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,?)").run(memoryId, scope, kind, content, ctx.projectId || null, ppath, ctx.agentId || null, null, confidence, sensitivity, JSON.stringify(Array.isArray(ev.evidence_refs) ? ev.evidence_refs : []), JSON.stringify(requestContext), now);
+      rememberCurated({ id: memoryId, scope, kind, content, confidence, sensitivity, requestContext });
+      logCli(ctx.projectPath, { action: "written", scope, kind, content, request_context: requestContext, at: now });
+    } catch { /* ignore */ }
+  }
+  return style.sanitizeAssistantText(cleaned);
+}
+
+module.exports = {
+  SECRET_RE,
+  loadArch,
+  ensureMemoryContextColumn,
+  logCli,
+  normalizeRequestContext,
+  parseMemoryEventsCli,
+  curateCliReply,
+};

package/engine/oberon/common.cjs

@@ -0,0 +1,69 @@
+"use strict";
+/*
+ * oberon/common — Oberon 필름 스튜디오 공용 유틸.
+ * v1 모놀리스(engine/agentlas.cjs, legacy-v1-engine-snapshot §12213-12580)의
+ * oberonParseFlags / oberonBar / oberonBytes / slugifyOberon 충실 포팅.
+ *
+ * v2 규칙: v1의 fail()은 process.exit(1)로 즉사했지만, v2 명령은 exit code를
+ * 반환해야 한다. 그래서 사용자-레벨 실패는 OberonFail throw → 명령 래퍼가
+ * "✖ <msg>" + return 1 로 변환한다 (v1 fail의 "✖ " 접두 계약 유지).
+ */
+
+class OberonFail extends Error {
+  constructor(message, code) {
+    super(message);
+    this.oberonFail = true;
+    if (code) this.code = code;
+  }
+}
+
+function fail(msg, code) {
+  throw new OberonFail(String(msg ?? ""), code);
+}
+
+// v1 oberonParseFlags 그대로: `--key value` / `--key`(불리언) / 나머지는 위치 인자.
+// 다음 토큰이 `--`로 시작하면 값이 아니라 다른 플래그로 본다.
+function parseFlags(args) {
+  const flags = {};
+  const rest = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      const next = args[i + 1];
+      if (next === undefined || next.startsWith("--")) flags[key] = true;
+      else {
+        flags[key] = next;
+        i++;
+      }
+    } else rest.push(a);
+  }
+  return { flags, rest };
+}
+
+// 20-셀 진행률 바 (v1 oberonBar)
+function oberonBar(pct) {
+  const n = Math.max(0, Math.min(20, Math.round((pct / 100) * 20)));
+  return "█".repeat(n) + "░".repeat(20 - n);
+}
+
+// 사람이 읽는 바이트 표기 (v1 oberonBytes)
+function oberonBytes(n) {
+  if (n > 1e6) return (n / 1e6).toFixed(1) + "MB";
+  if (n > 1e3) return (n / 1e3).toFixed(0) + "KB";
+  return n + "B";
+}
+
+// 딜리버리 폴더 이름용 슬러그 (v1 slugifyOberon).
+// 한국어 제목이 흔해서 가-힣을 보존한다 — ASCII만 남기면 폴더명이 전부 "_"가 된다.
+function slugifyOberon(value) {
+  return (
+    String(value || "")
+      .trim()
+      .replace(/[^\w가-힣-]+/g, "_")
+      .replace(/_{2,}/g, "_")
+      .slice(0, 48) || "oberon"
+  );
+}
+
+module.exports = { OberonFail, fail, parseFlags, oberonBar, oberonBytes, slugifyOberon };