agentlas 1.0.60 → 1.0.61

package/engine/cloud-assets/cas.cjs

@@ -68,6 +68,22 @@ function cloudCasResponseError(response, label) {
 }
 
 /** 등록(생성/갱신). 성공 시 검증된 리비전 디스크립터(+operation/url)를 반환한다. */
+// 서버는 받은 것보다 적게 저장할 수 있고, 그건 증명 실패가 아니다.
+//
+// 등록은 제출 해시를 검증한 뒤, 자체 스캔이 자격증명으로 판정한 파일을 빼고
+// 나머지를 새 해시로 저장한다(uploadReceipt.omissions가 뺀 경로를 전부 적는다).
+// 저장 해시만 대조하면, 이미 허브에 게시가 끝난 뒤에 "잘못된 등록 영수증"으로
+// 실패하게 된다 — 에이전트는 검색·호출되는데 올린 사람은 실패로 듣는다.
+// 증명의 목적은 "서버가 바로 이 패키지를 봤다"이고 submittedPackageHash가 그
+// 증거이므로, 둘 중 하나가 우리 해시와 같으면 통과시킨다. 둘 다 아니면 그대로 실패.
+function registrationSawOurPackage(json, manifest) {
+  const ours = String(manifest.packageHash || "").toLowerCase();
+  if (String(json.packageHash || "").toLowerCase() === ours) return true;
+  const receipt = json && typeof json === "object" ? json.uploadReceipt : null;
+  if (!receipt || typeof receipt !== "object") return false;
+  return String(receipt.submittedPackageHash || "").toLowerCase() === ours;
+}
+
 async function registerCloudAgent(manifest, bundlePath, review, visibility, options = {}) {
   const cookie = await cloudSessionCookie();
   if (!cookie) throw new Error("Agent Cloud sign-in is required. Sign in through Desktop or set AGENTLAS_SESSION.");
@@ -119,7 +135,7 @@ async function registerCloudAgent(manifest, bundlePath, review, visibility, opti
     json.dryRun !== false ||
     typeof json.cloudId !== "string" || !json.cloudId.trim() ||
     json.slug !== manifest.slug ||
-    json.packageHash !== manifest.packageHash ||
+    !registrationSawOurPackage(json, manifest) ||
     json.packageHashVersion !== manifest.packageHashVersion ||
     typeof json.revision !== "string" || etag !== cloudRevisionEtag(json.revision) ||
     typeof json.registeredAt !== "string" || !Number.isFinite(Date.parse(json.registeredAt)) ||
@@ -138,11 +154,21 @@ async function registerCloudAgent(manifest, bundlePath, review, visibility, opti
     etag,
     updatedAt: json.savedAt || json.registeredAt,
   }, "registration receipt");
+  // 서버가 자기 스캔으로 뺀 파일은 사용자에게 보여야 한다. 영수증 안에만 있으면
+  // "내 파일이 안 올라갔다"는 사실을 아무도 읽지 않는다.
+  const serverWithheld = (() => {
+    const receipt = json && typeof json === "object" ? json.uploadReceipt : null;
+    const omissions = receipt && Array.isArray(receipt.omissions) ? receipt.omissions : [];
+    return omissions
+      .map((entry) => (entry && typeof entry.path === "string" ? entry.path : ""))
+      .filter(Boolean);
+  })();
   return {
     ...descriptor,
     operation: json.operation,
     ...(typeof json.url === "string" ? { url: json.url } : {}),
     ...(typeof json.marketplaceUrl === "string" ? { marketplaceUrl: json.marketplaceUrl } : {}),
+    ...(serverWithheld.length ? { serverWithheld } : {}),
     registeredAt: json.registeredAt,
     dryRun: false,
   };

package/engine/cloud-assets/package.cjs

@@ -368,6 +368,34 @@ function cloudPortableExecutableForFile(relativePath, statMode, restoredExecutab
   return Boolean(statMode & 0o111);
 }
 
+// 잘라내기는 에이전트의 능력을 대가로 하면 안 된다 (오너 결정 2026-08-18).
+//
+// 한도에 닿으면 폴더에서 나오는 순서대로 잘렸다. 그 순서엔 의미가 없어서,
+// 벤치마크 파일이 살고 skills/ 가 통째로 빠지는 일이 실제로 일어난다(데스크탑에서
+// 실측: 벤치마크 13개 실림, skills 3개 전멸). 순위 0은 에이전트 자신이므로 절대
+// 버리지 않고, 자리가 없으면 이미 넣은 낮은 순위 중 가장 큰 것을 대신 빼서 만든다.
+// 뺀 파일은 전부 영수증(trimmed-for-package-limits)을 남긴다.
+// 엔진(agentlas_cloud/upload.py)·데스크탑(cloud-agents/package.ts)의 rankOf와 같은 축.
+const CLOUD_CAPABILITY_DIR_RE = /(^|\/)(knowledge|skills?|prompts?|presets?|agents|workers|contracts|shotplans|playbooks|templates)\//;
+const CLOUD_BUILD_OUTPUT_RE = /(^|\/)(node_modules|dist|build|out|coverage|\.next|\.venv|__pycache__|\.git)\//;
+const CLOUD_MEDIA_RE = /\.(png|jpe?g|gif|webp|svg|mp4|mov|mp3|wav|pdf|zip|tar|gz|tgz|bin|so|dylib|dll|wasm|sqlite|db)$/;
+const CLOUD_SIDE_MATERIAL_RE = /(^|\/)(tests?|__tests__|fixtures?|benchmarks?|logs?|examples?)\//;
+const CLOUD_BULK_DATA_RE = /\.(log|jsonl|csv|tsv|lock)$/;
+
+function cloudTrimRank(rel, bytes) {
+  const lower = String(rel || "").toLowerCase();
+  const base = lower.split("/").pop() || lower;
+  if (CLOUD_AGENT_FILES.has(base)) return 0;
+  if (lower.startsWith(".agentlas/")) return 0;
+  if (base === "agentlas.json" || base === "manifest.json" || base === "package.json") return 0;
+  if (CLOUD_CAPABILITY_DIR_RE.test(lower)) return 0;
+  if (CLOUD_BUILD_OUTPUT_RE.test(lower)) return 1;
+  if (CLOUD_MEDIA_RE.test(lower)) return 2;
+  if (CLOUD_SIDE_MATERIAL_RE.test(lower)) return 3;
+  if (CLOUD_BULK_DATA_RE.test(lower)) return 4;
+  return bytes > 64 * 1024 ? 5 : 6;
+}
+
 // ── 폴더 스캔 (TOCTOU-안전) ──
 
 function scanCloudFolder(rootPath) {
@@ -392,6 +420,37 @@ function scanCloudFolder(rootPath) {
       sourceHashKind: source?.hashKind || "unavailable-observation",
     });
   }
+  /** 순위 0 파일이 들어갈 자리를, 이미 넣은 낮은 순위 중 큰 것부터 빼서 만든다.
+   *  뺀 바이트 수를 돌려준다(0이면 뺄 것이 없었다는 뜻). */
+  function evictLowestRankToFit(rel, needBytes) {
+    if (cloudTrimRank(rel, needBytes) !== 0) return 0;
+    let freed = 0;
+    while (totalBytes - freed + needBytes > CLOUD_MAX_TOTAL_BYTES) {
+      let victimIndex = -1;
+      let victimRank = 0;
+      let victimBytes = -1;
+      for (let index = 0; index < included.length; index += 1) {
+        const candidate = included[index];
+        const rank = cloudTrimRank(candidate.path, candidate.bytes);
+        if (rank === 0) continue;
+        if (rank > victimRank || (rank === victimRank && candidate.bytes > victimBytes)) {
+          victimIndex = index;
+          victimRank = rank;
+          victimBytes = candidate.bytes;
+        }
+      }
+      if (victimIndex < 0) return freed;
+      const victim = included.splice(victimIndex, 1)[0];
+      freed += victim.bytes;
+      addOmission(victim.path, "trimmed-for-package-limits", { bytes: victim.bytes, sha256: victim.sha256, hashKind: "content" });
+      const record = files.find((item) => item.path === victim.path && item.included);
+      if (record) {
+        record.included = false;
+        record.reason = "trimmed-for-package-limits";
+      }
+    }
+    return freed;
+  }
   function insideRoot(candidate) {
     const relative = path.relative(rootPath, candidate);
     return relative === "" || (relative && !relative.startsWith("..") && !path.isAbsolute(relative));
@@ -599,6 +658,10 @@ function scanCloudFolder(rootPath) {
           continue;
         }
       }
+      if (totalBytes + content.length > CLOUD_MAX_TOTAL_BYTES) {
+        // 순위 0(에이전트 정의·카드·skills·knowledge …)이면 자리를 만든다.
+        totalBytes -= evictLowestRankToFit(rel, content.length);
+      }
       if (totalBytes + content.length > CLOUD_MAX_TOTAL_BYTES) {
         addFinding("package-size-limit", "blocker", "size", `Including this file would exceed ${CLOUD_MAX_TOTAL_BYTES} package bytes.`, rel, "Publish a smaller agent folder.");
         addOmission(rel, "package-total-bytes-limit", source);
@@ -713,6 +776,18 @@ function cloudRoutingCardProblem(card) {
         values.some((value) => typeof value !== "string" || !pattern.test(value))) {
       return `workforce.${field} contains an invalid or duplicate semantic ID`;
     }
+    // Scaffold slots that were never filled in. `{{SKILL_ID_1}}` slugifies into
+    // `skill:skill-id-1` — a well-formed id that names nothing and matches no
+    // work. A skill is named by its <host>/skills/<name>/SKILL.md folder, so an
+    // unfilled slot means "not declared", never "declared as skill-id-1".
+    // 접두는 필드명이 아니라 패턴에서 뽑는다 — communities 는 community 이지 communitie 가 아니다.
+    const prefix = (/\^([a-z]+):/.exec(pattern.source) || [, field])[1];
+    const unfilled = values.filter((value) =>
+      /\{\{.*?\}\}/.test(String(value)) ||
+      new RegExp(`^${prefix}:${prefix}-id-\\d+$`).test(String(value)));
+    if (unfilled.length) {
+      return `workforce.${field} still carries unfilled scaffold slots: ${unfilled.slice(0, 3).join(", ")}`;
+    }
   }
   for (const field of ["languages", "modalities"]) {
     const values = workforce[field];
@@ -830,6 +905,54 @@ function cloudReadPublicCareerCard(snapshot, findings) {
   return cloudSanitizePublicCareerCard(parsed);
 }
 
+/**
+ * 업로드 사본의 `agentlas.json` 에 불변 신원을 채운다 — **사용자 폴더는 안 건드린다.**
+ *
+ * 터미널은 엔진(`upload.py`)을 부르지 않고 자체 포장기를 쓴다. 그래서 여기로 올린
+ * 패키지에는 지금까지 `agentId` 가 실린 적이 없고, 서버는 그 패키지의 신원을 바뀌는
+ * 문자열 다섯 개의 지문으로만 정할 수 있었다 — 같은 폴더를 `hep upload` 로 올리면
+ * 신원이 실리고 `agentlas upload` 로 올리면 안 실려 정의가 둘로 갈렸다.
+ *
+ * 엔진과 같은 규칙을 쓴다: 팀은 `agt_team_…`, 단일은 `agt_…`, 이름 해시로 결정론적.
+ * 이미 선언돼 있으면 절대 덮어쓰지 않는다.
+ */
+function cloudEnsureAgentIdentity(scan, snapshot, fallbackName) {
+  const relativePath = "agentlas.json";
+  const manifest = cloudReadSnapshotJson(snapshot, relativePath);
+  const declared = typeof manifest.agentId === "string" ? manifest.agentId.trim() : "";
+  if (declared) return declared;
+
+  const isTeam = scan.included.some((file) => /^agents\/[^/]+\/agent\.md$/.test(file.path));
+  const seed = String(
+    manifest.slug || manifest.name || fallbackName || "",
+  ).trim().toLowerCase();
+  if (!seed) return "";
+  const digest = crypto.createHash("sha256")
+    .update(`agentlas-upload-agent-id-v1\0${seed}`, "utf8")
+    .digest("hex");
+  const agentId = `agt_${isTeam ? "team_" : ""}${digest.slice(0, 32)}`;
+
+  const next = { ...manifest, agentId };
+  const bytes = Buffer.from(JSON.stringify(next, null, 2) + "\n", "utf8");
+  const replacement = {
+    path: relativePath,
+    bytes: bytes.length,
+    sha256: sha(bytes),
+    contentBase64: bytes.toString("base64"),
+    executable: false,
+  };
+  const index = scan.included.findIndex((file) => file.path === relativePath);
+  const existing = index >= 0 ? scan.included[index] : null;
+  if (index >= 0) scan.included.splice(index, 1);
+  scan.included.push(replacement);
+  scan.included.sort(cloudCodePointPathOrder);
+  scan.totalBytes += bytes.length - (existing?.bytes || 0);
+  const fileRecord = scan.files.find((file) => file.path === relativePath);
+  if (fileRecord) Object.assign(fileRecord, { bytes: bytes.length, sha256: replacement.sha256, kind: "text", executable: false, included: true, reason: undefined });
+  else scan.files.push({ path: relativePath, bytes: bytes.length, sha256: replacement.sha256, kind: "text", executable: false, included: true });
+  return agentId;
+}
+
 function cloudReplacePublicCareerCard(scan, card) {
   const relativePath = ".agentlas/public-career-card.json";
   const includedIndex = scan.included.findIndex((file) => file.path === relativePath);
@@ -949,6 +1072,9 @@ async function packageCloudAgent(db, root, opts = {}) {
     cloudReplacePublicCareerCard(scan, careerGraph);
     snapshot = cloudPackageSnapshot(scan.included);
   }
+  // 신원은 해시 계산 전에 채운다 — 클라우드 해시는 agentlas.json 을 포함한다.
+  cloudEnsureAgentIdentity(scan, snapshot, rootPath.split("/").pop());
+  snapshot = cloudPackageSnapshot(scan.included);
   const routingCard = isPublicHubPublish ? readCloudRoutingCard(snapshot) : {};
   if (routingCard.finding) scan.findings.push(routingCard.finding);
   if (isPublicHubPublish) {

package/engine/cloud-assets/upload-scan-catalog.generated.cjs

@@ -93,10 +93,23 @@ const FOLDER_SCAN_AGENT_DEFINITION_FILES = Object.freeze([
   "persona.md",
 ]);
 
+const PACKAGE_MAX_TOTAL_BYTES = 31457280;
+const PACKAGE_MAX_FILE_BYTES = 6291456;
+const PACKAGE_MAX_UNCOMPRESSED_TOTAL_BYTES = 125829120;
+const PACKAGE_MAX_UNCOMPRESSED_FILE_BYTES = 25165824;
+const PACKAGE_MAX_FILES = 400;
+const PACKAGE_MAX_REQUEST_BYTES = 47185920;
+
 module.exports = {
   SECRET_SCAN_TEXT_EXTENSIONS,
   UPLOAD_SKIP_DIRECTORIES,
   AGENT_DEFINITION_FILES,
   UPLOAD_AGENT_DEFINITION_FILES,
   FOLDER_SCAN_AGENT_DEFINITION_FILES,
+  PACKAGE_MAX_TOTAL_BYTES,
+  PACKAGE_MAX_FILE_BYTES,
+  PACKAGE_MAX_UNCOMPRESSED_TOTAL_BYTES,
+  PACKAGE_MAX_UNCOMPRESSED_FILE_BYTES,
+  PACKAGE_MAX_FILES,
+  PACKAGE_MAX_REQUEST_BYTES,
 };

package/engine/commands/career-graph.cjs

@@ -34,7 +34,7 @@ async function run(ctx, args) {
     });
   }
   try {
-    const lines = runCareerGraphCli(args, {
+    const lines = await runCareerGraphCli(args, {
       cwd: process.cwd(),
       projectPath: process.cwd(),
       lang: ctx.lang,

package/engine/commands/graph.cjs

@@ -1,4 +1,6 @@
 "use strict";
+
+const { nodeDeclaresOutwardEffect: reachesOutside } = require("../graph/node-effect.cjs");
 /*
  * graph — 저장된 자동화 그래프를 터미널에서 보고 vendored Desktop Core로 직접 실행한다.
  *
@@ -14,6 +16,8 @@ const path = require("node:path");
 const pkgLib = require("../graph/package.cjs");
 const desktopCore = require("../core/desktop-core.cjs");
 
+
+
 function graphRows(ctx, db) {
   if (!ctx.tableExists(db, "automations")) return [];
   const hasGraph = ctx.columnExists(db, "automations", "graph_json");
@@ -441,7 +445,7 @@ function nodeLine(ctx, node, en) {
   //   묻지 않는다. "확인 후 실행" 표시는 거짓이므로 없앴다. 옛 그래프의 approval
   //   선언이 남아 있어도 마찬가지다. 사실 그대로의 고지는 "바깥을 바꿈" 하나다.
   const marks = [
-    effect === "mutation" ? (en ? "changes things outside" : "바깥을 바꿈") : null,
+    reachesOutside(node) ? (en ? "changes things outside" : "바깥을 바꿈") : null,
     node.config?.consumes ? `${en ? "uses" : "사용"} {{${node.config.consumes}}}` : null,
     node.config?.produces ? `${en ? "makes" : "생성"} {{${node.config.produces}}}` : null,
   ].filter(Boolean);
@@ -940,7 +944,7 @@ async function newGraph(ctx, request, flags) {
     ctx.out(ctx.ui.dim(`  ${bp.goal}`));
     ctx.out("");
     renderGraphTree(ctx, built.graph, en);
-    const mutations = built.graph.nodes.filter((n) => n.config && n.config.effect === "mutation");
+    const mutations = built.graph.nodes.filter((n) => reachesOutside(n));
     if (mutations.length) {
       ctx.out("");
       // ★사실 그대로의 고지 — 이 단계들은 실행 중에 멈춰 묻지 않는다(승인 게이트 폐지,

package/engine/commands/index.cjs

@@ -18,6 +18,10 @@ const COMMANDS = {
   mcp: () => require("./mcp.cjs"),
   help: () => require("./help.cjs"),
   run: () => require("./run.cjs"),
+  // One 축 — 데스크탑/모바일과 **같은 공유 DB 의 One 대화**를 이어간다.
+  // (2026-08-20까지 DESKTOP_ONLY_SURFACES 에 있었다. 대화는 이미 공유 DB 에 있었고
+  //  터미널만 그것을 못 봤을 뿐이다 — 표면 부재를 제품 경계로 착각한 선언이었다.)
+  one: () => require("./one.cjs"),
   login: () => require("./login.cjs"),
   logout: () => require("./logout.cjs"),
   whoami: () => require("./whoami.cjs"),
@@ -97,7 +101,6 @@ const DESKTOP_ONLY_SURFACES = {
   apps: "Apps surface is Desktop-only.",
   quests: "Quests are Desktop-only.",
   bookmarks: "Hub bookmarks: run `AGENTLAS_TUI=1 agentlas` then /marketplace.",
-  one: "Agentlas One is a separate Desktop/Mobile product surface.",
 };
 
 /*

package/engine/commands/one.cjs

@@ -0,0 +1,307 @@
+"use strict";
+/*
+ * one — Agentlas One 축을 터미널에 연다.
+ *
+ * 배경(감사 2026-08-20): 터미널에는 One 축이 **아예 없었다**. commands/index 는
+ * `one` 을 DESKTOP_ONLY_SURFACES 에 올려 "One 은 Desktop/Mobile 표면"이라고 선언했다.
+ * 그런데 One 은 제품의 개인 에이전트 축이고 대화는 **공유 DB 에 이미 있다** — 터미널만
+ * 그 대화를 못 봤다. 그래서 이 명령은 새 개념을 만들지 않는다:
+ *
+ *   · One = 빌트인 에이전트 `builtin-agentlas-one` (데스크탑 architecture/manifest.ts)
+ *   · One 소유 대화 = chats.origin_surface = 'one'
+ *   · 실행 = 터미널의 기존 세션 경로(sessions/orchestrator + sessions/session)
+ *
+ * 러너를 손으로 재구현하지 않는다. 이 파일이 하는 일은 (1) One 신원을 정확히 고르고
+ * (2) 이어 갈 One 대화를 고르거나 만들고 (3) 기존 세션을 그 chatId 로 띄우는 것뿐이다.
+ *
+ * 사용법
+ *   agentlas one                       최근 One 대화를 이어서 대화형
+ *   agentlas one "<프롬프트>"            한 턴 실행
+ *   agentlas one --list                One 대화 목록
+ *   agentlas one --new "<프롬프트>"      새 One 대화로 시작
+ *   agentlas one --chat <id> "<p>"     특정 One 대화에 이어 붙임
+ *   공통: -p/--print · --runtime · --model · --effort · --permission
+ */
+const readline = require("node:readline");
+const { rowToAgent } = require("../agents/registry.cjs");
+const { resolveRuntimeForAgent } = require("../runtimes/overrides.cjs");
+const { Orchestrator } = require("../sessions/orchestrator.cjs");
+const { Renderer } = require("../ui/renderer.cjs");
+const permissions = require("../agentlas-permissions.cjs");
+const { EFFORTS } = require("../agentlas-workload-routing.cjs");
+const { projectCwd } = require("../project/paths.cjs");
+const { columnExists, runWriteTransaction } = require("../core/db.cjs");
+const store = require("../sessions/store.cjs");
+
+/** 데스크탑 정본 신원(electron/architecture/manifest.ts + builtinAgentId). */
+const ONE_AGENT_ID = "builtin-agentlas-one";
+const ONE_AGENT_SLUG = "agentlas-one";
+const ONE_ORIGIN_SURFACE = "one";
+
+/**
+ * One 신원을 공유 DB 에서 읽는다.
+ *
+ * findAgent() 를 쓰지 않는 이유: One 은 visibility='background' 라 listRoutableAgents 가
+ * 걸러 낸다(설계). One 은 라우팅 후보가 아니라 **신원 행**이므로 직접 읽는다.
+ */
+function resolveOneAgent(db) {
+  let row = null;
+  try {
+    row = db.prepare("SELECT * FROM installed_agents WHERE id=?").get(ONE_AGENT_ID)
+      || db.prepare("SELECT * FROM installed_agents WHERE slug=?").get(ONE_AGENT_SLUG);
+  } catch {
+    row = null;
+  }
+  return rowToAgent(row);
+}
+
+/**
+ * One 페르소나의 정본은 데스크탑 계약이다. 벤더된 컴파일 매니페스트에서 읽을 수 있으면
+ * 그것을 쓰고(항상 최신 계약), 없으면 그 사실을 사유로 돌려준다 — 조용히 다른 문장으로
+ * 대체하지 않는다.
+ */
+function desktopOnePersona() {
+  try {
+    const { findCoreRoot } = require("../core/desktop-core.cjs");
+    const root = findCoreRoot();
+    if (!root) return { prompt: null, source: null, reason: "no Desktop core is available on this machine" };
+    const path = require("node:path");
+    const manifest = require(path.join(root, "electron", "architecture", "manifest.js"));
+    const def = (manifest.BUILTIN_AGENTS || []).find((agent) => agent.slug === ONE_AGENT_SLUG);
+    if (!def || !def.systemPrompt) {
+      return { prompt: null, source: null, reason: "the Desktop core on this machine predates the Agentlas One built-in" };
+    }
+    return { prompt: def.systemPrompt, source: "desktop-core", reason: null };
+  } catch (error) {
+    return { prompt: null, source: null, reason: `Desktop core manifest unreadable: ${(error && error.message) || error}` };
+  }
+}
+
+function chatsHaveOriginSurface(db) {
+  return columnExists(db, "chats", "origin_surface");
+}
+
+/** One 소유 대화 목록(최근 순). origin_surface 열이 없는 구형 DB 는 에이전트 소유로 폴백. */
+function listOneChats(db, limit = 20) {
+  const bounded = Math.max(1, Math.min(Number(limit) || 20, 200));
+  try {
+    if (chatsHaveOriginSurface(db)) {
+      return db.prepare(
+        "SELECT id, title, updated_at, origin_surface FROM chats " +
+        "WHERE origin_surface = ? ORDER BY updated_at DESC, rowid DESC LIMIT ?",
+      ).all(ONE_ORIGIN_SURFACE, bounded);
+    }
+    return db.prepare(
+      "SELECT id, title, updated_at FROM chats WHERE agent_id IN (?, ?) AND (kind IS NULL OR kind <> 'division') " +
+      "ORDER BY updated_at DESC, rowid DESC LIMIT ?",
+    ).all(ONE_AGENT_ID, ONE_AGENT_SLUG, bounded);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * One 대화를 만든다. origin_surface 열이 있으면 반드시 'one' 으로 찍는다 —
+ * 이 한 칸이 데스크탑/모바일이 이 대화를 One 대화로 보는 유일한 근거다.
+ * 열이 없는 구형 DB 에서는 만들되, 호출부가 그 사실을 사용자에게 알린다.
+ */
+function createOneChat(db, { agentId, title, workingFolder }) {
+  if (!chatsHaveOriginSurface(db)) {
+    return { chatId: store.createChat(db, { agentId, title, kind: "user", workingFolder }), originSurfaceStamped: false };
+  }
+  const id = store.newId();
+  const now = new Date().toISOString();
+  runWriteTransaction(db, () => {
+    db.prepare(
+      "INSERT INTO chats (id, agent_id, title, created_at, updated_at, kind, parent_chat_id, working_folder, origin_surface) " +
+      "VALUES (?,?,?,?,?,?,?,?,?)",
+    ).run(id, agentId, title || "One", now, now, "user", null, workingFolder, ONE_ORIGIN_SURFACE);
+  });
+  return { chatId: id, originSurfaceStamped: true };
+}
+
+function parseArgs(args) {
+  const out = { print: false, list: false, fresh: false, chatId: null, runtime: null, model: null, effort: null, permission: null, rest: [] };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "-p" || a === "--print") out.print = true;
+    else if (a === "--list" || a === "list") out.list = true;
+    else if (a === "--new" || a === "new") out.fresh = true;
+    else if (a === "--chat") out.chatId = args[++i];
+    else if (a === "--runtime") out.runtime = args[++i];
+    else if (a === "--model") out.model = args[++i];
+    else if (a === "--effort") out.effort = args[++i];
+    else if (a === "--permission") out.permission = args[++i];
+    else out.rest.push(a);
+  }
+  return out;
+}
+
+function renderList(ctx, rows) {
+  if (!rows.length) {
+    ctx.out(ctx.lang === "ko"
+      ? "One 대화가 아직 없습니다. `agentlas one \"<하고 싶은 일>\"` 로 시작하세요."
+      : "No One conversations yet. Start one with: agentlas one \"<what you want>\"");
+    return 0;
+  }
+  for (const row of rows) {
+    const when = String(row.updated_at || "").slice(0, 16).replace("T", " ");
+    ctx.out(`${row.id}  ${when}  ${String(row.title || "One").slice(0, 60)}`);
+  }
+  return 0;
+}
+
+async function runOne(ctx, args) {
+  const parsed = parseArgs(args);
+  if (parsed.permission && !permissions.LEVELS.includes(String(parsed.permission))) {
+    ctx.err(`unknown --permission ${parsed.permission} (use: ${permissions.LEVELS.join(" | ")})`);
+    return 1;
+  }
+  if (parsed.effort && !EFFORTS.includes(String(parsed.effort))) {
+    ctx.err(`unknown --effort ${parsed.effort} (use: ${EFFORTS.join(" | ")})`);
+    return 1;
+  }
+
+  const db = ctx.db();
+
+  // 목록은 신원 행이 없어도 답할 수 있어야 한다 — 대화는 chats 에 있고, One 행은
+  // 실행에만 필요하다. 조회를 실행 전제조건 뒤에 두면 "볼 수도 없는" 화면이 된다.
+  if (parsed.list) return renderList(ctx, listOneChats(db, 20));
+
+  const agent = resolveOneAgent(db);
+  if (!agent) {
+    ctx.err(
+      "Agentlas One is not present in the shared database yet.\n" +
+      "One is a built-in identity row (builtin-agentlas-one) seeded by the shared architecture.\n" +
+      "Run `agentlas doctor`, or launch the Agentlas Desktop app once, then retry.",
+    );
+    return 1;
+  }
+
+  // 페르소나 정본은 데스크탑 계약. 읽을 수 있으면 그것을 쓰고, 못 읽으면 DB 행을 쓰되
+  // **무엇을 못 읽었는지 말한다**(조용한 대체 금지).
+  const persona = desktopOnePersona();
+  if (persona.prompt) agent.systemPrompt = persona.prompt;
+  else if (persona.reason) {
+    ctx.err(ctx.uiInstance.c.dim(
+      `One persona came from the shared database row, not the Desktop contract — ${persona.reason}`,
+    ));
+  }
+
+  let runtime;
+  try {
+    runtime = resolveRuntimeForAgent({
+      db,
+      prefs: ctx.prefs,
+      explicit: parsed.runtime,
+      model: parsed.model,
+      effort: parsed.effort,
+      role: "orchestrator",
+      agentId: agent.id,
+    });
+  } catch (e) {
+    ctx.err(String((e && e.message) || e));
+    return 1;
+  }
+
+  const permission = permissions.normalize(parsed.permission || (ctx.prefs && ctx.prefs.permission) || "write");
+  const cwd = projectCwd();
+  const prompt = parsed.rest.join(" ").trim();
+
+  // 이어 갈 대화 고르기 — 새 개념을 만들지 않고 기존 One 대화를 쓴다.
+  let chatId = null;
+  let created = false;
+  if (parsed.chatId) {
+    const row = listOneChats(db, 200).find((item) => item.id === parsed.chatId);
+    if (!row) {
+      ctx.err(`No One conversation with id ${parsed.chatId} (see: agentlas one --list)`);
+      return 1;
+    }
+    chatId = row.id;
+  } else if (!parsed.fresh) {
+    const recent = listOneChats(db, 1);
+    if (recent.length) chatId = recent[0].id;
+  }
+  if (!chatId) {
+    const result = createOneChat(db, {
+      agentId: agent.id,
+      title: prompt ? prompt.slice(0, 60) : "One",
+      workingFolder: cwd,
+    });
+    chatId = result.chatId;
+    created = true;
+    if (!result.originSurfaceStamped) {
+      ctx.err(ctx.uiInstance.c.dim(
+        "This shared database has no chats.origin_surface column, so the conversation could not be stamped " +
+        "as a One conversation. Desktop and Mobile will show it as a normal chat until the store is migrated.",
+      ));
+    }
+  }
+
+  const orch = new Orchestrator({ db, lang: ctx.lang });
+  const session = orch.spawn({ agent, runtime, permission, cwd, chatId, title: prompt ? prompt.slice(0, 60) : "One" });
+
+  const interactive = !prompt;
+  let renderer = null;
+  if (!parsed.print) {
+    renderer = new Renderer(ctx.uiInstance);
+    renderer.attach(session, { replay: false });
+    ctx.err(ctx.uiInstance.c.dim(
+      `one · ${runtime.kind}${runtime.model ? ` · ${runtime.model}` : ""} · ${permission} · ` +
+      `${created ? "new conversation" : "continuing"} ${chatId}`,
+    ));
+  }
+
+  if (!interactive) {
+    const res = await session.send(prompt);
+    if (renderer) renderer.detach();
+    if (parsed.print) {
+      const finalText = (res && (res.finalText || res.text)) || "";
+      if (finalText) process.stdout.write(finalText.trimEnd() + "\n");
+      if (session.status === "failed" && session.lastError) ctx.err(session.lastError);
+    }
+    return session.status === "failed" ? 1 : 0;
+  }
+
+  // 대화형 — 답할 사람이 있는 자리에서만 연다. 파이프/자동화에서는 정직하게 멈춘다.
+  if (!process.stdin.isTTY) {
+    if (renderer) renderer.detach();
+    ctx.err("Usage: agentlas one \"<prompt>\"   (interactive One needs a TTY)");
+    return 1;
+  }
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr, terminal: true });
+  let failed = false;
+  try {
+    for (;;) {
+      const line = await new Promise((resolve) => rl.question("one › ", resolve));
+      const text = String(line || "").trim();
+      if (!text) continue;
+      if (/^(?:\/quit|\/exit|quit|exit)$/i.test(text)) break;
+      await session.send(text);
+      if (session.status === "failed") {
+        failed = true;
+        if (session.lastError) ctx.err(session.lastError);
+      }
+    }
+  } finally {
+    rl.close();
+    if (renderer) renderer.detach();
+  }
+  return failed ? 1 : 0;
+}
+
+function run(ctx, args) {
+  return runOne(ctx, args);
+}
+
+module.exports = {
+  run,
+  parseArgs,
+  resolveOneAgent,
+  listOneChats,
+  createOneChat,
+  desktopOnePersona,
+  ONE_AGENT_ID,
+  ONE_AGENT_SLUG,
+  ONE_ORIGIN_SURFACE,
+};

package/engine/commands/ontology.cjs

@@ -5,9 +5,9 @@
  */
 const { runOntologyCli } = require("../project/ontology.cjs");
 
-function run(ctx, args) {
+async function run(ctx, args) {
   try {
-    const lines = runOntologyCli(args, {
+    const lines = await runOntologyCli(args, {
       cwd: process.cwd(),
       projectPath: process.cwd(),
       lang: ctx.lang,