agentlas 1.0.29 → 1.0.36

package/engine/commands/telegram.cjs

@@ -1,7 +1,12 @@
 "use strict";
-/* telegram — 바인딩 현황 (읽기 전용). 페어링·봇 발급은 Desktop Connect 소관. */
+/* telegram — 바인딩 현황 (읽기 전용). 페어링·봇 발급은 아직 Desktop Connect 소관. */
 
-function run(ctx) {
+/*
+ * 바인딩 표를 그린다. connect.cjs 도 같은 표를 쓰도록 공용화(2026-08-06):
+ * 예전 `connect telegram` 은 Hephaestus 플러그인으로 패스스루해 원시 라우터
+ * JSON(hub_candidates)을 사용자에게 그대로 덤프했다 — build 스텁과 같은 계열.
+ */
+function renderTelegram(ctx) {
   const ko = ctx.lang === "ko";
   const db = ctx.db();
   let rows;
@@ -11,22 +16,24 @@ function run(ctx) {
     rows = [];
   }
   if (!rows.length) {
-    ctx.out(ko
-      ? "Telegram 연결이 없습니다. Desktop Connect에서 기기를 연결하세요."
-      : "No Telegram bindings. Pair devices from Desktop Connect.");
-    return 0;
-  }
-  for (const r of rows) {
-    const bot = r.bot_username ? "@" + r.bot_username : "(bot not set)";
-    const chat = r.telegram_chat_title || r.telegram_chat_id || "(chat not connected)";
-    const status = r.status || (r.telegram_chat_id ? "paired" : "pending");
-    ctx.out(`${String(r.id).slice(0, 8)}  ${r.target_kind}:${String(r.target_id).slice(0, 20).padEnd(21)} ${String(bot).padEnd(24)} ${String(chat).slice(0, 28).padEnd(29)} ${status}`);
+    ctx.out(ko ? "Telegram 연결이 없습니다." : "No Telegram bindings.");
+  } else {
+    for (const r of rows) {
+      const bot = r.bot_username ? "@" + r.bot_username : "(bot not set)";
+      const chat = r.telegram_chat_title || r.telegram_chat_id || "(chat not connected)";
+      const status = r.status || (r.telegram_chat_id ? "paired" : "pending");
+      ctx.out(`${String(r.id).slice(0, 8)}  ${r.target_kind}:${String(r.target_id).slice(0, 20).padEnd(21)} ${String(bot).padEnd(24)} ${String(chat).slice(0, 28).padEnd(29)} ${status}`);
+    }
+    ctx.out("");
   }
-  ctx.out("");
   ctx.out(ctx.ui.dim(ko
-    ? "연결과 봇 발급은 Desktop Connect에서 수행하며, 이 명령은 상태만 보여줍니다."
-    : "Pairing and bot issuance happen in Desktop Connect; this command only shows status."));
+    ? "봇 발급·페어링은 현재 Agentlas Desktop Connect에서 수행합니다. 이 명령은 바인딩 상태를 보여줍니다."
+    : "Bot issuance and pairing currently happen in Agentlas Desktop Connect. This command shows binding status."));
   return 0;
 }
 
-module.exports = { run };
+function run(ctx) {
+  return renderTelegram(ctx);
+}
+
+module.exports = { run, renderTelegram };

package/engine/core/desktop-core-fetch.cjs

@@ -0,0 +1,98 @@
+"use strict";
+/*
+ * core/desktop-core-fetch — 데스크탑 코어를 필요할 때만 내려받는다 (2026-08-06).
+ *
+ * 배경(오너: "코덱스는 어떻게 했냐"): 코덱스 CLI는 무거운 실행파일을 npm 패키지 안에 미리
+ * 담지 않는다 — 설치 시점(postinstall)에 그 사람 플랫폼용 파일만 GitHub Release 에서 내려받는다.
+ * 우리도 같은 패턴을 쓴다: 그래프 실행 커널(52MB, engine/vendor/desktop-core.cjs 가 재사용하는
+ * 데스크탑 코어)은 git 에 커밋하지 않고, `graph run` 을 실제로 쓸 때만 GitHub Release 자산을
+ * 내려받아 로컬 캐시(userDataDir()/desktop-core-cache/<version>/)에 푼다. 다음부턴 캐시를 쓴다.
+ *
+ * 안전: 무엇을 왜 받는지 사용자에게 **말하고** 받는다(조용히 안 받는다). sha256 체크섬으로
+ * 무결성을 확인한 뒤에만 푼다 — 받아온 걸 검증 없이 실행하지 않는다.
+ *
+ * 매니페스트(engine/vendor/desktop-core.manifest.json, git 커밋 — 이 파일만 작다)가
+ * {version, url, sha256, sizeBytes} 를 담는다. 실물(52MB)은 그 url 이 가리키는 곳에서 온다.
+ */
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+const { userDataDir } = require("./paths.cjs");
+
+// env 오버라이드는 테스트 전용(게이트가 로컬 서버를 가리키는 가짜 매니페스트로 전 경로를 잠근다).
+function manifestPath() { return process.env.AGENTLAS_DESKTOP_CORE_MANIFEST || path.join(__dirname, "..", "vendor", "desktop-core.manifest.json"); }
+
+function readManifest() {
+  try { return JSON.parse(fs.readFileSync(manifestPath(), "utf8")); } catch { return null; }
+}
+
+function cacheDir(version) { return path.join(userDataDir(), "desktop-core-cache", String(version)); }
+function cacheDistDir(version) { return path.join(cacheDir(version), "dist"); }
+
+function sha256File(file) {
+  const hash = crypto.createHash("sha256");
+  hash.update(fs.readFileSync(file));
+  return hash.digest("hex");
+}
+
+/** 이미 캐시에 온전히 풀려 있으면 그 dist 경로, 아니면 null. */
+function cachedCoreRoot(manifest = readManifest()) {
+  if (!manifest) return null;
+  const dist = cacheDistDir(manifest.version);
+  const marker = path.join(cacheDir(manifest.version), ".complete");
+  if (fs.existsSync(marker) && fs.existsSync(path.join(dist, "electron", "workflow", "run-graph.js"))) return dist;
+  return null;
+}
+
+/**
+ * 매니페스트가 가리키는 데스크탑 코어를 내려받아 캐시에 푼다.
+ * onNotice(text): 사용자에게 보여줄 안내(무엇을·왜 받는지) — 조용히 받지 않는다.
+ * 반환: 성공 시 dist 경로, 실패 시 null(호출부가 정직하게 멈춘다).
+ */
+async function fetchDesktopCore({ onNotice } = {}) {
+  const manifest = readManifest();
+  if (!manifest || !manifest.url || !manifest.sha256) return null;
+
+  const existing = cachedCoreRoot(manifest);
+  if (existing) return existing;
+
+  const say = (t) => { if (typeof onNotice === "function") onNotice(t); };
+  say(`Downloading the graph-execution engine (${manifest.sizeBytes ? Math.round(manifest.sizeBytes / 1024 / 1024) + " MB" : "one-time"}) from ${manifest.url} …`);
+
+  const dir = cacheDir(manifest.version);
+  fs.rmSync(dir, { recursive: true, force: true });
+  fs.mkdirSync(dir, { recursive: true });
+  const tarPath = path.join(dir, "desktop-core.tar.gz");
+
+  const res = await fetch(manifest.url);
+  if (!res.ok) { say(`Download failed: HTTP ${res.status}`); return null; }
+  const buf = Buffer.from(await res.arrayBuffer());
+  fs.writeFileSync(tarPath, buf);
+
+  const digest = sha256File(tarPath);
+  if (digest !== manifest.sha256) {
+    say(`Checksum mismatch (expected ${manifest.sha256.slice(0, 12)}…, got ${digest.slice(0, 12)}…) — refusing to use it.`);
+    fs.rmSync(dir, { recursive: true, force: true });
+    return null;
+  }
+
+  const extract = spawnSync("tar", ["-xzf", tarPath, "-C", dir], { encoding: "utf8" });
+  if (extract.status !== 0) {
+    say(`Extraction failed: ${extract.stderr || extract.error || "unknown error"}`);
+    fs.rmSync(dir, { recursive: true, force: true });
+    return null;
+  }
+  fs.rmSync(tarPath);
+
+  if (!fs.existsSync(path.join(cacheDistDir(manifest.version), "electron", "workflow", "run-graph.js"))) {
+    say("Downloaded archive did not contain the expected engine files.");
+    fs.rmSync(dir, { recursive: true, force: true });
+    return null;
+  }
+  fs.writeFileSync(path.join(dir, ".complete"), new Date().toISOString());
+  say("Engine ready.");
+  return cacheDistDir(manifest.version);
+}
+
+module.exports = { readManifest, cachedCoreRoot, fetchDesktopCore, cacheDistDir };

package/engine/core/desktop-core.cjs

@@ -0,0 +1,170 @@
+"use strict";
+/*
+ * core/desktop-core — 데스크탑의 이미-컴파일된 코어를 터미널이 **재사용**한다 (2026-08-06).
+ *
+ * 배경(오너: "더 어려운 Electron 을 만들었는데 왜 더 쉬운 터미널을 못 만드냐 — 그래프 하나
+ * 문제가 아니다"): 정상 패턴은 CLI 를 먼저 만들고 그 위에 GUI 를 얹는 것이다. Agentlas 는
+ * 거꾸로 갔고, 터미널이 데스크탑 엔진을 손으로 재구현한 별도 사본이라 늘 뒤처졌다. 근본
+ * 수리는 기능을 하나씩 베끼는 게 아니라 **데스크탑의 컴파일된 코어를 그대로 불러 쓰는 것**이다.
+ *
+ * 그 코어(electron/workflow/run-graph.js + electron/mcp/* + electron/store/*)는 Electron 의존이
+ * 0이라(실측: `from "electron"`·BrowserWindow·app 전무, store/db 의 유일한 app.getPath 는
+ * AGENTLAS_STORE_PATH 로 이미 오버라이드 가능) 순수 Node 에서 그대로 require 된다.
+ *
+ * 이 로더는 컴파일된 코어의 위치를 찾아, **공유 DB 경로를 코어가 읽기 전에** 세팅하고 로드한다.
+ * 찾지 못하면 null 을 준다 — 호출부가 정직하게 멈춘다(가짜 성공 금지).
+ *
+ * 해석 순서:
+ *   1. env AGENTLAS_DESKTOP_CORE — 코어 루트(…/dist/electron 를 담는 디렉터리, 즉 dist)
+ *   2. 벤더본: <pkg>/engine/vendor/desktop-core/dist  (pack 시 복사되는 자립본)
+ *   3. 개발(동일 저장소 체크아웃): <pkg>/../agentlas_desktop/dist
+ */
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { dbPath, packageRoot, userDataDir } = require("./paths.cjs");
+
+/*
+ * 재사용 코어를 electron 없이 돌리는 셰임(2026-08-06).
+ * 재사용 클로저(200파일)의 electron 사용은 거의 전부 app.getPath(...) — 디렉터리 해석뿐이고,
+ * 나머지(BrowserWindow·dialog·session)는 헤드리스 실행 경로에서 쓰이지 않는다. 그래서 작은
+ * 가짜 electron 을 require 훅으로 돌려주면, electron 도 데스크탑 앱도 설치하지 않은 순수 Node
+ * 에서 데스크탑 코어가 그대로 돈다. GUI 전용 심볼은 실제로 불릴 때만 "CLI 에선 불가"로 던진다
+ * (조용히 no-op 하지 않는다 — 가짜 성공 금지).
+ */
+function makeElectronShim() {
+  const base = userDataDir();
+  const paths = {
+    userData: base,
+    appData: path.dirname(base),
+    home: os.homedir(),
+    temp: os.tmpdir(),
+    downloads: path.join(os.homedir(), "Downloads"),
+    documents: path.join(os.homedir(), "Documents"),
+    logs: path.join(base, "logs"),
+    sessionData: base,
+    exe: process.execPath,
+    module: process.execPath,
+  };
+  const app = {
+    getPath: (name) => paths[name] || base,
+    getName: () => "agentlas",
+    getVersion: () => { try { return require(path.join(packageRoot(), "package.json")).version; } catch { return "0.0.0"; } },
+    getLocale: () => "en-US",
+    isReady: () => true,
+    whenReady: () => Promise.resolve(),
+    isPackaged: true,
+    on() { return app; }, once() { return app; }, off() { return app; },
+    quit() {}, exit() {}, setPath() {},
+  };
+  const notAvailable = (what) => () => { throw new Error(`electron.${what} is not available in the Agentlas CLI (headless).`); };
+  const safeStorage = { isEncryptionAvailable: () => false, encryptString: notAvailable("safeStorage.encryptString"), decryptString: notAvailable("safeStorage.decryptString") };
+  class Notification { constructor() {} show() {} close() {} static isSupported() { return false; } }
+  const gui = new Proxy({}, { get: (_t, prop) => notAvailable(String(prop)) });
+  return { app, safeStorage, Notification, BrowserWindow: gui, dialog: gui, shell: gui, session: gui, ipcMain: gui, nativeTheme: {}, powerMonitor: gui };
+}
+
+function candidateRoots() {
+  const roots = [];
+  if (process.env.AGENTLAS_DESKTOP_CORE) roots.push(process.env.AGENTLAS_DESKTOP_CORE);
+  roots.push(path.join(packageRoot(), "engine", "vendor", "desktop-core", "dist"));
+  // 코덱스 CLI 패턴: 무거운 실행부는 git/npm 패키지에 미리 담지 않고, 처음 필요할 때만 내려받아
+  // 로컬에 캐시한다(userDataDir 아래) — 다음부턴 이 경로가 바로 잡힌다.
+  try { const cached = require("./desktop-core-fetch.cjs").cachedCoreRoot(); if (cached) roots.push(cached); } catch { /* 매니페스트 없음 */ }
+  roots.push(path.resolve(packageRoot(), "..", "agentlas_desktop", "dist"));
+  return roots;
+}
+
+/** 컴파일된 코어의 dist 루트를 찾는다(run-graph.js 존재로 판정). 없으면 null. */
+function findCoreRoot() {
+  for (const root of candidateRoots()) {
+    try {
+      if (fs.existsSync(path.join(root, "electron", "workflow", "run-graph.js"))) return root;
+    } catch { /* 다음 후보 */ }
+  }
+  return null;
+}
+
+/*
+ * 재사용 코어가 네이티브 모듈(better-sqlite3·keytar)을 **터미널 것**으로 쓰게 한다.
+ * 데스크탑 node_modules 의 것은 Electron ABI 로 빌드돼 순수 Node 와 호환되지 않는다
+ * (NODE_MODULE_VERSION 불일치). require 를 한 번 가로채 터미널의 바인딩으로 돌린다 — 같은
+ * 패키지의 ABI 만 맞추는 것이라 안전. ★다운로드 캐시(userDataDir 아래)는 터미널 패키지 트리
+ * 밖이라 node_modules 디렉터리 walk-up으로 자연 해결되지 않는다 — 이 훅이 위치와 무관하게 잡는다.
+ */
+let _nativeHookInstalled = false;
+function installNativeModuleHook() {
+  if (_nativeHookInstalled) return;
+  const Module = require("node:module");
+  const terminalBetterSqlite3 = require("better-sqlite3"); // 터미널 ABI 로 빌드된 것
+  let terminalKeytar = null;
+  try { terminalKeytar = require("keytar"); } catch { /* optionalDependency — 없을 수 있다 */ }
+  const electronShim = makeElectronShim();                 // electron 없이 코어를 돌리는 셰임
+  const orig = Module._load;
+  Module._load = function (request, parent, isMain) {
+    if (request === "better-sqlite3") return terminalBetterSqlite3;
+    if (request === "keytar" && terminalKeytar) return terminalKeytar;
+    if (request === "electron") return electronShim;
+    return orig.apply(this, arguments);
+  };
+  _nativeHookInstalled = true;
+}
+
+let _cache = undefined;
+
+/**
+ * 재사용 코어를 로드한다. 반환: { root, require(rel), runGraph, ... } 또는 null.
+ *  · require(rel): 코어 안의 임의 컴파일 모듈을 상대경로로 로드(예: "store/automations").
+ *  · runGraph: electron/workflow/run-graph.js 의 runGraph(automation, graph, opts).
+ * 공유 DB(AGENTLAS_STORE_PATH)를 코어 로드 전에 반드시 세팅한다 — store/db 가 모듈 로드 시 읽는다.
+ */
+function loadDesktopCore() {
+  if (_cache !== undefined) return _cache;
+  const root = findCoreRoot();
+  if (!root) { _cache = null; return null; }
+  installNativeModuleHook();
+  // 코어의 store 가 이 값을 모듈 로드 시점에 읽는다 — require 이전에 세팅해야 한다.
+  if (!process.env.AGENTLAS_STORE_PATH) process.env.AGENTLAS_STORE_PATH = dbPath();
+  const req = (rel) => require(path.join(root, "electron", rel.replace(/\.js$/, "") + ".js"));
+  let kernel;
+  try {
+    // 데스크탑은 app.whenReady 에서 initStore() 를 부른다 — 터미널도 코어를 쓰기 전에 부른다.
+    // initStore 가 스키마 마이그레이션까지 소유하므로(데스크탑과 같은 정본 스키마) 공유 DB 는
+    // 언제나 코어가 기대하는 모양이 된다. 이것이 "재구현"이 아니라 "재사용"의 핵심.
+    req("store/db").initStore();
+    kernel = req("workflow/run-graph");
+  } catch (e) { _cache = { root, error: e }; return _cache; }
+  _cache = {
+    root,
+    require: req,
+    initStore: req("store/db").initStore,
+    getDb: req("store/db").getDb,
+    runGraph: kernel.runGraph,
+    graphFailureOf: kernel.graphFailureOf,
+    planGraphLoops: kernel.planGraphLoops,
+  };
+  return _cache;
+}
+
+/** 재사용 코어가 이 머신에서 가용한가(정직한 가부). */
+function desktopCoreAvailable() {
+  const c = loadDesktopCore();
+  return !!(c && c.runGraph && !c.error);
+}
+
+/**
+ * 로컬에서 코어를 못 찾으면(개발용 형제 저장소도, 캐시도 없음) 필요한 순간에만 내려받는다
+ * (코덱스 CLI 패턴 — 조용히 안 받는다, onNotice 로 사용자에게 알린다). 매니페스트가 없으면
+ * (그래프 실행 기능이 이 배포에 아직 안 실렸으면) null 을 준다 — 정직한 실패.
+ */
+async function loadDesktopCoreAsync({ onNotice } = {}) {
+  const sync = loadDesktopCore();
+  if (sync && sync.runGraph && !sync.error) return sync;
+  const { fetchDesktopCore } = require("./desktop-core-fetch.cjs");
+  const dist = await fetchDesktopCore({ onNotice });
+  if (!dist) return null;
+  _cache = undefined; // 방금 캐시가 채워졌으니 후보 목록을 다시 계산해 태운다.
+  return loadDesktopCore();
+}
+
+module.exports = { findCoreRoot, loadDesktopCore, loadDesktopCoreAsync, desktopCoreAvailable };

package/engine/graph/ask-model.cjs

@@ -72,8 +72,13 @@ async function askModel(ctx, prompt, opts = {}) {
   if (!opts.runtime) {
     // listAvailableCliRuntimes()는 문자열이 아니라 {kind, bin, path} 객체를 돌려준다.
     // 문자열로 읽으면 후보가 하나도 안 쌓여 폴백이 통째로 죽는다(실측).
+    // ★그리고 **실행 드라이버가 있는 종류만** 후보다 — detect는 grok/kimi/cursor도
+    //   광고하는데 native host에 드라이버가 없어, 후보 슬롯 하나가 "unknown runtime"으로
+    //   낭비됐다(실측 2026-08-06). 판별 기준은 목록 복제가 아니라 resolve의 정본을 쓴다.
+    const { CLI_EXECUTABLE_KINDS } = require("../runtimes/resolve.cjs");
     for (const found of listAvailableCliRuntimes()) {
       if (!found || !found.kind || !found.path) continue;
+      if (!CLI_EXECUTABLE_KINDS.has(found.kind)) continue;
       if (candidates.some((c) => c.kind === found.kind)) continue;
       candidates.push({ kind: found.kind, bin: found.path });
     }
@@ -110,7 +115,29 @@ async function askModel(ctx, prompt, opts = {}) {
       failures.push(`${runtime.kind}: ${(err && err.message) || err}`);
       continue;
     }
-    const text = String((res && (res.finalText || res.text)) || "");
+    const text = String((res && res.text) || "");
+    /*
+     * ★런타임이 실패를 **이미 표식으로 말하고 있었다** — 우리가 안 읽었을 뿐이다.
+     *
+     * 실측 2026-08-06: claude-code가 한도 소진 시 `--output-format stream-json`으로
+     * `{"type":"rate_limit_event",...,"status":"rejected"}` → `"error":"rate_limit"` →
+     * 최종 `{"is_error":true,"api_error_status":429}`를 보내고 종료코드 1로 끝난다.
+     * 네이티브 호스트는 그것을 읽어 `res.error`까지 정확히 채워 놓았다. 그런데 여기서
+     * **`text.trim()`을 먼저 보고 ok를 반환**하는 바람에 그 error는 한 번도 읽히지 않았고,
+     * `You've hit your weekly limit`이라는 사람용 문장이 산출물 행세를 했다. 살아 있는
+     * codex로 넘어가지도 않았다.
+     *
+     * 그래서 판별은 문구 추측이 아니라 **표식**으로 한다. 표식이 있으면 그 런타임은 실패다.
+     * (표식조차 없는 런타임을 위한 마지막 그물은 runtime-refusal.cjs 한 곳뿐이다.)
+     */
+    const marked = res && res.error ? String(res.error).replace(/\s+/g, " ").slice(0, 240) : null;
+    const { detectRuntimeRefusal } = require("../runtime-refusal.cjs");
+    const heur = marked ? null : detectRuntimeRefusal(text);
+    const notice = marked || (heur && heur.message);
+    if (notice) {
+      failures.push(`${runtime.kind}: ${notice}`);
+      continue;
+    }
     if (text.trim()) {
       const out = { ok: true, text, runtime: runtime.kind };
       if (candidates[0] !== runtime) out.fellBackFrom = candidates[0].kind;
@@ -128,4 +155,5 @@ async function askModel(ctx, prompt, opts = {}) {
   };
 }
 
+
 module.exports = { askModel };

package/engine/graph/interview.cjs

@@ -62,8 +62,10 @@ const OPS = new Set(CONDITION_OPS);
 const VALUE_OPS = new Set(["contains", "eq", "ne", "gt", "lt"]);
 const VAR_RE = /^[A-Za-z_][\w-]*$/;
 
-function startInterview(request) {
-  return { request: String(request || "").trim(), answers: [], asked: [], round: 0, attempts: [] };
+function startInterview(request, { knownGraphs = [], selfId = null } = {}) {
+  // knownGraphs: 이 사람이 이미 가진 저장된 자동화들(id·name). runGraph 단계가 이 중에서만
+  //   고르게 하려고 인터뷰 프롬프트와 검증에 함께 흐른다(데스크탑과 같은 규칙).
+  return { request: String(request || "").trim(), answers: [], asked: [], round: 0, attempts: [], knownGraphs, selfId };
 }
 
 function recordAnswers(state, answers) {
@@ -133,6 +135,11 @@ const RULES = [
   "    If the script imports anything outside the Python standard library, declare the pip names in",
   '    packages:["yfinance"] on that step — the product installs them before the run. Prefer the',
   "    standard library when it can do the job; an undeclared import dies on the user's machine.",
+  "  · kind:\"runGraph\" when the person wants an automation they ALREADY have to run as one",
+  "    step of this one (\"then run my weekly report\"). Add graphRef:\"<id>\" chosen from the",
+  "    list of saved automations at the end of this prompt — never invent an id, and never use",
+  "    the name (names change, ids do not). If nothing in that list matches, do not guess:",
+  "    write the work as ordinary steps instead.",
   "  · kind:\"agent\" (the default, omit it) for judgement, writing, summarizing, deciding — anything",
   "    where being approximately right is fine. Split a step: fetch+compute in a code step, then",
   "    judge/write in an agent step. Do not put exact math inside an agent instruction.",
@@ -203,6 +210,11 @@ function buildInterviewPrompt(state, locale = "ko") {
   if (state.asked.length) {
     lines.push("", `Question ids already asked (do not repeat): ${state.asked.join(", ")}`);
   }
+  // ★부를 수 있는 자동화 목록을 그 순간 실물로 싣는다(데스크탑과 같은 규칙). 이것이 없으면
+  //   모델은 id를 지어내고, 그 그래프는 실행 때 죽는다.
+  if (state.knownGraphs && state.knownGraphs.length) {
+    lines.push("", "Saved automations you may call with kind:\"runGraph\" (use the id exactly):", ...state.knownGraphs.slice(0, 40).map((g) => `  ${g.id} — ${g.name}`));
+  }
   // ★산출 언어는 입력 언어가 아니라 **제품 설정**이 정한다(데스크탑과 같은 규칙).
   lines.push("", `PRODUCT LANGUAGE: ${locale === "ko" ? "Korean" : "English"}. Every user-facing string you emit is in this language.`);
   // ★지난 시도가 왜 지어지지 못했는지를 모델 앞에 놓는다. 데스크탑과 같은 규율이다 —
@@ -239,7 +251,7 @@ function triggerQuestion() {
 }
 
 /** 청사진이 그래프로 지어질 수 있는지. 모자란 곳은 기본값이 아니라 질문으로 돌려준다. */
-function validateBlueprint(bp) {
+function validateBlueprint(bp, ctx = {}) {
   const problems = [];
   const push = (reason, ask = null) => problems.push({ reason, ask });
   if (!bp || typeof bp !== "object") { push("만들 내용을 읽지 못했습니다."); return problems; }
@@ -305,6 +317,33 @@ function validateBlueprint(bp) {
         choices: ["아니요, 만들기만 합니다", "네, 바깥으로 나갑니다"],
       });
     }
+    // ★부를 자동화는 실재해야 한다(데스크탑 shared/graph-blueprint.ts와 같은 규칙). 이름이
+    //   아니라 id로 가리키는 이유도 같다 — 이름은 바뀌고 지어낸 id는 실행에서 죽는다.
+    //   목록을 모르는 호출부에서는 형식만 본다(ctx.knownGraphs 없으면 건너뜀).
+    if (step.kind === "runGraph") {
+      const ref = String(step.graphRef || "").trim();
+      if (!ref) {
+        push(`${at}가 어느 자동화를 부를지 정하지 않았습니다.`);
+      } else if (ctx.selfId && ref === ctx.selfId) {
+        push(`${at}가 자기 자신을 부릅니다 — 끝나지 않습니다.`);
+      } else if (ctx.knownGraphs && ctx.knownGraphs.length && !ctx.knownGraphs.some((g) => g.id === ref)) {
+        push(`${at}가 부르려는 자동화("${ref}")가 없습니다. 저장된 자동화 중에서 골라야 합니다.`);
+      }
+    }
+    // ★코드 스텝은 스크립트가 있어야 한다. 없으면 "코드로 하겠다"고 해 놓고 빈 채로 저장돼
+    //   실행에서 CODE_NODE_EMPTY로 죽는다(데스크탑과 같은 규칙, 저작 시점에 막는다).
+    if (step.kind === "code") {
+      if (!String(step.code || "").trim()) {
+        push(`${at}는 코드로 실행한다고 했는데 스크립트가 비어 있습니다.`, {
+          id: `step-${index}-code`,
+          question: `"${step.title || at}" 단계에서 무엇을 계산·가공하나요? (AI가 스크립트를 채웁니다)`,
+          why: "코드 단계는 스크립트가 없으면 실행되지 않습니다.",
+        });
+      }
+      if (step.codeLang && step.codeLang !== "python" && step.codeLang !== "js") {
+        push(`${at}의 코드 언어 "${step.codeLang}"을(를) 이 제품이 모릅니다(python 또는 js).`);
+      }
+    }
     for (const name of step.consumes || []) {
       if (!produced.has(name)) {
         push(`${at}가 쓰는 "${name}" 값을 아무도 만들지 않습니다.`, {
@@ -484,7 +523,7 @@ function describeBranches(bp, locale) {
   const lines = [];
   const title = (index) => (typeof index === "number" && bp.steps[index] ? bp.steps[index].title : (ko ? "끝" : "the end"));
   for (const branch of bp.branches || []) {
-    const rule = branchLabel(branch);
+    const rule = branchLabel(branch, locale);
     const repeatText = branch.repeatStep !== undefined
       ? (ko ? `"${title(branch.repeatStep)}"부터 다시 (최대 ${branch.maxRepeats}번)` : `back to "${title(branch.repeatStep)}" (up to ${branch.maxRepeats}x)`)
       : null;
@@ -502,8 +541,25 @@ function describeBranches(bp, locale) {
   return lines;
 }
 
-function branchLabel(branch) {
+/*
+ * ★언어를 받는다(데스크탑 shared/graph-blueprint.ts 미러). 예전에는 무조건 한국어라
+ * 영어로 만든 그래프에도 `verdict이(가) "fail"인가?`가 박혔고, 그 라벨이 공개
+ * 설명문에 실려 Hub 발행이 통째로 거절됐다("descriptionEn contains Hangul").
+ */
+function branchLabel(branch, locale = "ko") {
   const shown = typeof branch.value === "string" ? `"${branch.value}"` : String(branch.value ?? "");
+  if (locale === "en") {
+    switch (branch.op) {
+      case "contains": return `Does ${branch.var} contain ${shown}?`;
+      case "truthy": return `Does ${branch.var} have a value?`;
+      case "falsy": return `Is ${branch.var} empty?`;
+      case "eq": return `Is ${branch.var} ${shown}?`;
+      case "ne": return `Is ${branch.var} not ${shown}?`;
+      case "gt": return `Is ${branch.var} greater than ${shown}?`;
+      case "lt": return `Is ${branch.var} less than ${shown}?`;
+      default: return `Check ${branch.var}`;
+    }
+  }
   switch (branch.op) {
     case "contains": return `${branch.var}에 ${shown}이(가) 있나?`;
     case "truthy": return `${branch.var}에 값이 있나?`;
@@ -576,8 +632,8 @@ function clipAtWord(text, max) {
   return `${body.trimEnd()}…`;
 }
 
-function buildGraphFromBlueprint(bp, locale = "ko") {
-  const problems = validateBlueprint(bp);
+function buildGraphFromBlueprint(bp, locale = "ko", ctx = {}) {
+  const problems = validateBlueprint(bp, ctx);
   if (problems.length) return { ok: false, problems };
 
   const nodes = [];
@@ -595,14 +651,19 @@ function buildGraphFromBlueprint(bp, locale = "ko") {
   const stepId = (i) => `step${i + 1}`;
   bp.steps.forEach((step, index) => {
     const isCode = step.kind === "code";
+    // 다른 자동화를 한 단계로 부른다(데스크탑 커넥터 C46 subgraph). 캔버스엔 있는데
+    //   말로는 못 만들던 구멍 — 데스크탑 스케줄러가 이 노드를 재귀 실행한다.
+    const isSub = step.kind === "runGraph";
     nodes.push({
       id: stepId(index),
-      // 코드 스텝은 code 노드로(데스크탑 shared/graph-blueprint.ts와 같은 규칙).
-      type: isCode ? "code" : (step.effect === "mutation" ? "action" : "agent"),
+      // 코드 스텝은 code 노드로, subgraph 는 subgraph 노드로(데스크탑 shared/graph-blueprint.ts와 같은 규칙).
+      type: isSub ? "subgraph" : isCode ? "code" : (step.effect === "mutation" ? "action" : "agent"),
       label: step.title,
       position: { x: column(index + 1), y: 0 },
       config: {
-        ...(isCode
+        ...(isSub
+          ? { graphRef: step.graphRef || "", note: step.instruction }
+          : isCode
           ? {
             code: step.code || "", codeLang: step.codeLang === "js" ? "js" : "python", note: step.instruction,
             ...(Array.isArray(step.packages) && step.packages.length
@@ -695,7 +756,7 @@ function buildGraphFromBlueprint(bp, locale = "ko") {
     }
     const branchId = `check${index + 1}`;
     nodes.push({
-      id: branchId, type: "condition", label: branchLabel(branch),
+      id: branchId, type: "condition", label: branchLabel(branch, locale),
       position: { x: column(index + 1) + 140, y: 0 },
       config: { var: branch.var, op: branch.op, ...(branch.value !== undefined ? { value: branch.value } : {}) },
     });
@@ -762,11 +823,35 @@ function firstJsonObject(text) {
   return null;
 }
 
-const unreadable = () => ({
-  ok: false, code: "INTERVIEW_OUTPUT_UNREADABLE",
-  reason: "만들 내용을 읽지 못했습니다.",
-  nextAction: "자동으로 돌릴 일을 한 문장으로 다시 적어 주세요.",
-});
+/**
+ * ★런타임이 JSON 대신 **사람에게 하는 말**을 돌려줬을 수 있다.
+ *
+ * 실측 2026-08-06: 모델이 `You've hit your weekly limit · resets Aug 8 at 6pm (Asia/Seoul)`을
+ * 돌려줬는데, 제품은 그 문장을 삼키고 "만들 내용을 읽지 못했습니다 / 한 문장으로 다시
+ * 적어 주세요"라고 말했다. 사람은 자기 문장이 틀린 줄 알고 몇 번이고 다시 쓴다 —
+ * 아무리 잘 써도 안 된다. 무엇이 막혔는지 아는 쪽은 제품인데, 그것을 지우고 있었다.
+ *
+ * 짧고 JSON이 아니면 잘린 청사진이 아니라 **고지문**이다. 그대로 보여준다.
+ */
+const RUNTIME_NOTICE_MAX = 240;
+const unreadable = (rawText) => {
+  const text = typeof rawText === "string" ? rawText.trim() : "";
+  const looksLikeNotice = text.length > 0 && text.length <= RUNTIME_NOTICE_MAX && !text.includes("{");
+  if (looksLikeNotice) {
+    return {
+      ok: false, code: "INTERVIEW_MODEL_UNAVAILABLE",
+      reason: `AI가 만들지 못했습니다 — ${text}`,
+      nextAction: "다른 모델을 연결하거나, 안내에 적힌 시각 이후에 다시 시도해 주세요.",
+      // 재시도로 해결되지 않는다 — 형식 문제가 아니다.
+      terminal: true,
+    };
+  }
+  return {
+    ok: false, code: "INTERVIEW_OUTPUT_UNREADABLE",
+    reason: "만들 내용을 읽지 못했습니다.",
+    nextAction: "자동으로 돌릴 일을 한 문장으로 다시 적어 주세요.",
+  };
+};
 
 function normalizeQuestions(candidates, state) {
   const seen = new Set(state.asked);
@@ -820,10 +905,10 @@ function weakenedAgainstLastAttempt(blueprint, state) {
 
 function parseInterviewTurn(text, state) {
   const raw = firstJsonObject(text);
-  if (!raw) return unreadable();
+  if (!raw) return unreadable(text);
   let parsed;
-  try { parsed = JSON.parse(raw); } catch { return unreadable(); }
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return unreadable();
+  try { parsed = JSON.parse(raw); } catch { return unreadable(text); }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return unreadable(text);
 
   if (Array.isArray(parsed.ask) && parsed.ask.length > 0) {
     const questions = normalizeQuestions(parsed.ask, state);
@@ -838,7 +923,7 @@ function parseInterviewTurn(text, state) {
   }
 
   const blueprint = parsed.blueprint;
-  if (!blueprint || typeof blueprint !== "object") return unreadable();
+  if (!blueprint || typeof blueprint !== "object") return unreadable(text);
   const normalized = { ...blueprint, schema: BLUEPRINT_SCHEMA };
   const problems = validateBlueprint(normalized);
   if (problems.length === 0) {