agentlas 1.0.28 → 1.0.35

package/engine/commands/project.cjs

@@ -1,31 +1,64 @@
 "use strict";
 /*
- * project — 명시적 프로젝트 초기화/점검 (v1 monolith 13199–13223 포팅).
+ * project — 프로젝트 상태·초기화, 그리고 순서 팀 편성 (독립).
  *
- * 0.9.10 경계: `.agentlas/` 를 만드는 유일한 진입점은 `agentlas project init` 이다.
- * `project status` 는 완전 수동(파일 생성/DB visit 기록 없음)으로 검사만 한다.
+ * 2026-08-06(오너 원칙): 데스크탑/플러그인은 산출물·설정을 공유할 뿐 선행 전제가
+ * 아니다. 그래서 `project team`·`project use`로 터미널에서 직접 폴더를 프로젝트로
+ * 연결하고 컨트롤러 팀을 정한다 — 이후 `run "<task>"`와 REPL 평문 입력이 데스크탑
+ * 없이 동작한다. 프로젝트 쓰기는 engine/project/team.cjs가 소유(스키마 공유).
  */
 const { projectCwd } = require("../project/paths.cjs");
 const {
   ensureTerminalProjectForExecutionCli,
   initializeTerminalProjectCli,
 } = require("../project/state.cjs");
+const { connectProjectTeam } = require("../project/team.cjs");
+const { resolveProjectController } = require("../project/controller.cjs");
+
+function showStatus(ctx, cwd, ko) {
+  const active = ensureTerminalProjectForExecutionCli(ctx.db(), cwd, "read", "terminal-project-status");
+  ctx.out(`${ko ? "프로젝트 폴더" : "project"}: ${cwd}`);
+  ctx.out(`${ko ? ".agentlas 상태" : "Agentlas state"}: ${active
+    ? (ko ? "초기화됨" : "initialized")
+    : (ko ? "초기화되지 않음" : "not initialized")}`);
+  // 연결된 프로젝트 + 순서 팀(컨트롤러)을 보여준다 — 데스크탑 없이도 무엇이 실행될지.
+  try {
+    const resolved = resolveProjectController(ctx.db(), cwd);
+    const pool = resolved.project?.agentPool || [];
+    ctx.out(`${ko ? "연결된 프로젝트" : "connected project"}: ${resolved.project?.name || "—"}`);
+    if (pool.length) {
+      ctx.out(ko ? "순서 팀 (0번=컨트롤러):" : "ordered team (index 0 = controller):");
+      pool.forEach((m, i) => ctx.out(`  ${i}. ${m.nameSnapshot}`));
+    }
+  } catch (e) {
+    if (e && e.code === "project_not_connected") {
+      ctx.out(ctx.ui.dim(ko
+        ? "이 폴더는 아직 프로젝트에 연결되지 않았습니다. `agentlas project use <에이전트>`로 연결하세요."
+        : "This folder is not connected to a project yet. Connect it with `agentlas project use <agent>`."));
+    } else if (e && e.honestStop) {
+      ctx.out(ctx.ui.dim(String(e.message)));
+    }
+    // 그 외 오류는 status를 막지 않는다.
+  }
+  return 0;
+}
+
+function reportTeam(ctx, result, ko) {
+  ctx.out(`${ctx.ui.green("✓")} ${ko ? "프로젝트" : "project"} ${result.created ? (ko ? "생성" : "created") : (ko ? "갱신" : "updated")}: ${result.name}`);
+  ctx.out(ko ? "순서 팀 (0번=컨트롤러):" : "ordered team (index 0 = controller):");
+  result.team.forEach((m, i) => ctx.out(`  ${i}. ${m.nameSnapshot}`));
+  ctx.out(ctx.ui.dim(ko
+    ? "이제 이 폴더에서 바로 실행: agentlas run \"<할 일>\"  또는 REPL에서 그냥 문장을 치세요."
+    : "Now run here directly: agentlas run \"<task>\"  or just type a sentence in the REPL."));
+}
 
 function run(ctx, args) {
   const action = String(args[0] || "status").toLowerCase();
   const cwd = projectCwd();
   const ko = ctx.lang === "ko";
-  if (action === "status") {
-    const active = ensureTerminalProjectForExecutionCli(ctx.db(), cwd, "read", "terminal-project-status");
-    ctx.out(`${ko ? "프로젝트" : "project"}: ${cwd}`);
-    ctx.out(`${ko ? "Agentlas 상태" : "Agentlas state"}: ${active
-      ? (ko ? "초기화됨" : "initialized")
-      : (ko ? "초기화되지 않음" : "not initialized")}`);
-    if (!active) ctx.out(ko
-      ? "비공개 .agentlas 상태와 로컬 제외 파일을 만들려면 `agentlas project init`을 실행하세요."
-      : "Run `agentlas project init` to create private .agentlas state and update local ignore files.");
-    return 0;
-  }
+
+  if (action === "status") return showStatus(ctx, cwd, ko);
+
   if (action === "init") {
     ctx.out(ko
       ? "비공개 Agentlas 프로젝트 상태를 초기화합니다. .agentlas/ 생성, .gitignore 갱신, 로컬 자격증명·서명 템플릿 추가가 포함될 수 있습니다."
@@ -33,14 +66,44 @@ function run(ctx, args) {
     try {
       initializeTerminalProjectCli(ctx.db(), cwd);
     } catch (e) {
-      // fail-closed: 프라이버시 경계(.gitignore/심볼릭 링크)를 보증 못 하면 생성 금지.
       ctx.err(String((e && e.message) || e));
       return 1;
     }
     ctx.out(`${ko ? "초기화됨" : "Initialized"}: ${cwd}`);
     return 0;
   }
-  ctx.err("Usage: agentlas project [status|init]");
+
+  /*
+   * project use <에이전트>            — 이 폴더를 프로젝트로 연결 + 단일 컨트롤러 팀
+   * project team <에이전트> [<에이전트>...] — 순서 팀 편성 (0번=컨트롤러)
+   * 둘 다 데스크탑 없이 동작한다.
+   */
+  if (action === "use" || action === "team") {
+    const tokens = args.slice(1).filter((t) => t && !String(t).startsWith("-"));
+    if (!tokens.length) {
+      ctx.err(ko
+        ? `사용법: agentlas project ${action} <에이전트> ${action === "team" ? "[<에이전트>...]" : ""}  ·  에이전트 목록: agentlas list`
+        : `Usage: agentlas project ${action} <agent> ${action === "team" ? "[<agent>...]" : ""}  ·  list agents: agentlas list`);
+      return 1;
+    }
+    try {
+      const result = connectProjectTeam(ctx.db(), cwd, tokens, {});
+      reportTeam(ctx, result, ko);
+      return 0;
+    } catch (e) {
+      if (e && e.code === "team_agent_not_found") {
+        ctx.err((ko ? "에이전트를 찾을 수 없습니다: " : "agent not found: ") + e.token);
+        ctx.err(ctx.ui.dim(ko ? "설치된 에이전트: agentlas list" : "installed agents: agentlas list"));
+        return 1;
+      }
+      ctx.err(String((e && e.message) || e));
+      return 1;
+    }
+  }
+
+  ctx.err(ko
+    ? "사용법: agentlas project [status | init | use <에이전트> | team <에이전트>...]"
+    : "Usage: agentlas project [status | init | use <agent> | team <agent>...]");
   return 1;
 }
 

package/engine/commands/roles.cjs

@@ -0,0 +1,210 @@
+"use strict";
+/*
+ * roles — 오케스트레이터/워커 모델 역할 조회·설정.
+ *
+ * 배경(2026-08-05 감사, 결함 C): `list`와 `doctor`는 model_roles를 보여주는데
+ * 터미널 어디에도 쓰기 경로가 없었다(전 코드베이스 SELECT만). 바꾸려면 데스크탑을
+ * 열어야 했고, REPL `/model`은 지역 변수 대입이라 검증도 저장도 안 됐다.
+ *
+ * 계약:
+ *  - 스키마 소유권은 데스크탑(v79)에 있다. 여기서는 테이블·컬럼을 만들지 않는다 —
+ *    테이블이 없으면 정직 정지 + 데스크탑 안내. 있는 행에 UPSERT만 한다.
+ *  - kind는 데스크탑과 같은 어휘(RUNTIME_BIN + byok 계열)로 검증한다. PATH에
+ *    없는 CLI도 저장은 허용하되(미리 설정) 그 자리에서 알린다 — 조용한 저장 금지.
+ *  - worker --inherit 는 스키마 CHECK(worker만 inherit 가능)를 그대로 따른다.
+ *  - 모델 id는 제공자마다 열린 어휘라 존재 검증하지 않는다(워크로드 라우팅의
+ *    EFFORTS 주석과 같은 원칙: 화이트리스트를 게이트로 쓰지 않는다).
+ */
+const { RUNTIME_BIN, whichSync } = require("../runtimes/detect.cjs");
+const { runtimeAuthEvidence } = require("../runtimes/auth-evidence.cjs");
+const { MODEL_ROLE_TABLE, VALID_ROLES, resolvedModelRole, roleMembers } = require("../runtimes/roles.cjs");
+const { runWriteTransaction } = require("../agentlas-sqlite-policy.cjs");
+const { EFFORTS } = require("../agentlas-workload-routing.cjs");
+
+// 데스크탑 RuntimeKind 어휘(runtimes/detect.cjs 주석과 동일). CLI가 아닌 종류는
+// which 검사 대상이 아니다.
+const KNOWN_KINDS = new Set([...Object.keys(RUNTIME_BIN), "byok", "ollama", "lmstudio", "mlx"]);
+
+function fmt(selection, en) {
+  if (!selection) return en ? "not set" : "미설정";
+  const bits = [
+    `${selection.kind}${selection.model ? `/${selection.model}` : ""}`,
+    selection.effort ? `effort=${selection.effort}` : null,
+    selection.inherit ? (en ? "(inherits orchestrator)" : "(오케스트레이터 상속)") : null,
+  ];
+  return bits.filter(Boolean).join(" ");
+}
+
+function show(ctx, args = []) {
+  const en = ctx.lang === "en";
+  const db = ctx.db();
+  if (args.includes("--json")) {
+    ctx.out(JSON.stringify({
+      orchestrator: resolvedModelRole(db, "orchestrator"),
+      worker: resolvedModelRole(db, "worker"),
+      pools: { orchestrator: roleMembers(db, "orchestrator"), worker: roleMembers(db, "worker") },
+    }, null, 2));
+    return 0;
+  }
+  ctx.out(ctx.ui.bold(en ? "Model roles" : "모델 역할"));
+  for (const role of ["orchestrator", "worker"]) {
+    const resolved = resolvedModelRole(db, role);
+    ctx.out(`  ${role.padEnd(13)} ${fmt(resolved, en)}`);
+    const pool = roleMembers(db, role);
+    if (pool.length) {
+      ctx.out(ctx.ui.dim(`  ${" ".repeat(13)} ${en ? "pool: " : "풀: "}${pool.map((m) => `${m.position}.${m.kind}${m.model ? `/${m.model}` : ""}`).join("  ")}`));
+    }
+  }
+  ctx.out("");
+  ctx.out(ctx.ui.dim(en
+    ? 'Change: agentlas roles set <orchestrator|worker> <runtime> [--model <id>] [--effort <level>]  ·  worker inherit: agentlas roles set worker --inherit'
+    : '변경: agentlas roles set <orchestrator|worker> <runtime> [--model <id>] [--effort <level>]  ·  워커 상속: agentlas roles set worker --inherit'));
+  return 0;
+}
+
+function parseSetFlags(args) {
+  const rest = [];
+  const flags = {};
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--model") { flags.model = String(args[++i] ?? "").trim(); continue; }
+    if (arg.startsWith("--model=")) { flags.model = arg.slice(8).trim(); continue; }
+    if (arg === "--effort") { flags.effort = String(args[++i] ?? "").trim().toLowerCase(); continue; }
+    if (arg.startsWith("--effort=")) { flags.effort = arg.slice(9).trim().toLowerCase(); continue; }
+    if (arg === "--inherit") { flags.inherit = true; continue; }
+    rest.push(arg);
+  }
+  return { rest, flags };
+}
+
+function set(ctx, args) {
+  const en = ctx.lang === "ko" ? false : true;
+  const ko = !en;
+  const { rest, flags } = parseSetFlags(args);
+  const role = String(rest[0] || "").toLowerCase();
+  const kindArg = rest[1] ? String(rest[1]).toLowerCase() : null;
+
+  const usage = ko
+    ? "사용법: agentlas roles set <orchestrator|worker> <runtime> [--model <id>] [--effort <level>] | agentlas roles set worker --inherit"
+    : "Usage: agentlas roles set <orchestrator|worker> <runtime> [--model <id>] [--effort <level>] | agentlas roles set worker --inherit";
+
+  if (!VALID_ROLES.has(role)) { ctx.err(usage); return 1; }
+  if (flags.inherit && role !== "worker") {
+    ctx.err(ko ? "--inherit 는 worker 역할에만 씁니다 (스키마 계약)." : "--inherit applies to the worker role only (schema contract).");
+    return 1;
+  }
+  if (!flags.inherit && !kindArg) { ctx.err(usage); return 1; }
+  if (kindArg && !KNOWN_KINDS.has(kindArg)) {
+    ctx.err((ko ? "모르는 런타임 종류: " : "unknown runtime kind: ") + kindArg);
+    ctx.err(ko
+      ? `가능한 값: ${[...KNOWN_KINDS].join(" · ")}`
+      : `valid kinds: ${[...KNOWN_KINDS].join(" · ")}`);
+    return 1;
+  }
+  if (flags.effort !== undefined && !EFFORTS.includes(flags.effort)) {
+    ctx.err((ko ? "모르는 effort 값: " : "unknown effort level: ") + flags.effort + ` (${EFFORTS.join("|")})`);
+    return 1;
+  }
+
+  const db = ctx.db();
+  // 스키마 창조 금지 — 테이블은 데스크탑 마이그레이션 v79가 만든다.
+  if (!ctx.tableExists(db, MODEL_ROLE_TABLE)) {
+    ctx.err(ko
+      ? "model_roles 테이블이 아직 없습니다. 스키마는 데스크탑 앱이 소유합니다 — 데스크탑을 한 번 실행하면 생성됩니다."
+      : "The model_roles table does not exist yet. Desktop owns this schema — run the desktop app once to create it.");
+    return 1;
+  }
+
+  let kind = kindArg;
+  let model = flags.model !== undefined ? (flags.model || null) : undefined;
+  let inherit = 0;
+  if (flags.inherit) {
+    // 상속 = 워커가 오케스트레이터를 따른다. 스키마상 kind NOT NULL이라
+    // 현재 오케스트레이터의 좌표를 복사해 두되 inherit=1로 표시한다(리더 부재 시 정직 정지).
+    const orchestrator = resolvedModelRole(db, "orchestrator");
+    if (!orchestrator) {
+      ctx.err(ko ? "상속할 오케스트레이터 설정이 없습니다. 먼저 orchestrator를 설정하세요." : "No orchestrator to inherit from. Set the orchestrator first.");
+      return 1;
+    }
+    kind = orchestrator.kind;
+    if (model === undefined) model = orchestrator.model;
+    inherit = 1;
+  }
+
+  const now = new Date().toISOString();
+  runWriteTransaction(db, () => {
+    const existing = db.prepare("SELECT * FROM model_roles WHERE role=?").get(role);
+    if (existing) {
+      // kind가 바뀌면 이전 모델 id는 새 런타임의 어휘가 아니다(예: kimi에 opus).
+      // --model 미지정 시 유지가 아니라 초기화 — 무의미한 좌표를 승계하지 않는다.
+      const keepModel = existing.kind === kind ? existing.model : null;
+      db.prepare(
+        "UPDATE model_roles SET kind=?, model=?, effort=?, inherit=?, updated_at=? WHERE role=?",
+      ).run(
+        kind,
+        model === undefined ? keepModel : model,
+        flags.effort === undefined ? existing.effort : (flags.effort === "none" ? null : flags.effort),
+        inherit,
+        now,
+        role,
+      );
+    } else {
+      db.prepare(
+        "INSERT INTO model_roles (role, kind, model, effort, inherit, updated_at) VALUES (?,?,?,?,?,?)",
+      ).run(role, kind, model === undefined ? null : model, flags.effort === undefined || flags.effort === "none" ? null : flags.effort, inherit, now);
+    }
+  });
+
+  const saved = resolvedModelRole(db, role);
+  ctx.out(`${ctx.ui.green("✓")} ${role} = ${fmt(saved, en)}`);
+
+  // 저장은 됐지만 실행이 안 될 수 있는 상태는 그 자리에서 말한다 — 조용한 저장 금지.
+  const bin = RUNTIME_BIN[kind];
+  if (bin && !whichSync(bin)) {
+    ctx.out(ctx.ui.dim(ko
+      ? `참고: '${bin}' 실행 파일이 PATH에 없습니다. 설치 전에는 이 역할의 실행이 실패합니다.`
+      : `Note: '${bin}' is not on PATH. Runs with this role will fail until it is installed.`));
+  } else if (bin) {
+    const evidence = runtimeAuthEvidence(kind);
+    if (evidence.status === "none") {
+      ctx.out(ctx.ui.dim(ko
+        ? `참고: ${kind} 로그인 흔적이 없습니다. 로그인 전에는 실행이 실패할 수 있습니다.`
+        : `Note: no local sign-in evidence for ${kind}. Runs may fail until you sign in.`));
+    }
+  }
+  return 0;
+}
+
+function run(ctx, args = []) {
+  const en = ctx.lang === "en";
+  const [sub, ...rest] = args;
+  if (!sub || sub === "show" || sub === "list" || sub === "--json") return show(ctx, sub === "--json" ? ["--json"] : rest);
+  if (sub === "set") return set(ctx, rest);
+  if (sub === "help" || sub === "--help" || sub === "-h") {
+    // SELF_HELP_COMMANDS 계약: --help 는 스텁이 아니라 실제 안내여야 한다.
+    ctx.out(en
+      ? [
+        "agentlas roles — orchestrator/worker model roles (persisted, shared with Desktop)",
+        "  roles                                  show both roles and their pools",
+        "  roles set <orchestrator|worker> <runtime> [--model <id>] [--effort <level>]",
+        "  roles set worker --inherit             worker follows the orchestrator",
+        "",
+        `  runtimes: ${[...KNOWN_KINDS].join(" · ")}`,
+        "  REPL /model and /runtime are session-scoped — this command is the persistent path.",
+      ].join("\n")
+      : [
+        "agentlas roles — 오케스트레이터/워커 모델 역할 (영구 저장, 데스크탑과 공유)",
+        "  roles                                  두 역할과 풀 조회",
+        "  roles set <orchestrator|worker> <runtime> [--model <id>] [--effort <level>]",
+        "  roles set worker --inherit             워커가 오케스트레이터를 따름",
+        "",
+        `  런타임: ${[...KNOWN_KINDS].join(" · ")}`,
+        "  REPL /model·/runtime 은 세션 한정입니다 — 영구 설정은 이 명령입니다.",
+      ].join("\n"));
+    return 0;
+  }
+  ctx.err(en ? `unknown roles subcommand: ${sub} (show · set)` : `모르는 roles 하위 명령: ${sub} (show · set)`);
+  return 1;
+}
+
+module.exports = { run };

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/commands/workforce.cjs

@@ -7,9 +7,13 @@
  *     runtimeOverride, { cwd, projectPath, permission })
  *
  * 라우팅 불변식: 이 표면은 Agent Workforce Ontology 전용 fail-closed 경로다.
- * 어휘 라우터/hep-network 로 조용히 폴백하지 않는다. legacy-network 는 v1에서
- * parity().cmdHep(["hep-network", ...]) 호환 탈출구였는데, 그 parity 모듈이 아직
- * v2에 없으므로 정직 정지로 안내만 한다(가짜 성공 금지).
+ * 어휘 라우터로 조용히 폴백하지 않는다.
+ *
+ * 스코프 고지(2026-08-05): cmdWorkforce 는 sourceScope 를 싣지 않고
+ * AGENTLAS_MCP_BASE_URL 을 직접 친다. 서버는 sourceScope 부재를 "hub" 로 잡으므로
+ * 이 명령이 실제로 보는 메뉴는 **공개 Hub 뿐**이다. 로컬·오너 Cloud 를 포함한
+ * 연합 편성은 MCP 호스트의 /hep-network 가 한다 — 이 표면에는 그 계층이 없어서
+ * hep-network/hep-local/hep-cloud/hep-hub/legacy-network 를 전부 삭제했다.
  *
  * Write-capable first contact bootstraps the exact current project through the
  * canonical Core merge-only boundary. Read-only inspection remains passive.
@@ -79,15 +83,62 @@ async function dispatch(ctx, command, args) {
       });
       return result && result.ok ? 0 : 1;
     }
-    case "legacy-network": {
-      // v1의 명시적 호환 탈출구(parity cmdHep → hep-network)는 아직 v2에 없다.
-      // 조용히 workforce 로 대체 실행하지 않는다 — 두 경로는 라우팅 권한 모델이 다르다.
-      ctx.err(
-        "'legacy-network' (hep-network compatibility) is not wired into the v2 engine yet.\n" +
-        "Use `agentlas workforce <request>` for the fail-closed Agent Workforce Ontology route,\n" +
-        "or the v1 build: git tag legacy-v1-engine-snapshot.",
-      );
-      return 1;
+    /*
+     * 소스 스코프 편성 4종 — 2026-08-05 네이티브 배선.
+     *
+     * 역사: 7/28에 "별칭이 스코프를 버린다"를 고치며 hep-*를 외부 CLI 패스스루로
+     * 승격했는데, 그 CLI는 exit 3 + host_llm_required만 반환하는 스텁이었다(8/5
+     * 삭제). 재조사 결과 편성의 세 조각(4,578줄 루프·로컬 Core MCP·주입 지점)이
+     * 전부 이 머신에 있었고, 빠진 것은 배선뿐이었다. 이제 이 표면이 직접
+     * 호스트다: 루프의 리더 LLM이 WorkOrder를 작성하고, 로컬 Core가 선언된
+     * 스코프의 메뉴를 연합하며, 같은 LLM이 정확 릴리스를 고른다.
+     *
+     * 폴백 금지: 로컬 Core가 없으면 원격 Hub로 조용히 내려가지 않는다 — 이름이
+     * 약속한 스코프가 거짓이 된다(7/28 결함의 재발). 정직 정지 + 설치 안내.
+     */
+    case "hep-network":
+    case "hep-local":
+    case "hep-cloud":
+    case "hep-hub": {
+      const sourceScope = command.slice(4); // network|local|cloud|hub
+      const ko = ctx.lang !== "en";
+      const { rest, runtimeOverride } = splitRuntimeOverride(args);
+      const hasTask = rest.some((token, i) =>
+        !["--benchmark", "--json", "--parallel", "-n"].includes(String(token))
+        && !(i > 0 && ["--parallel", "-n"].includes(String(rest[i - 1]))));
+      if (!hasTask) {
+        ctx.err(`usage: agentlas ${command} "<task>" [--parallel N] [--json] [--runtime <kind>]`);
+        return 1;
+      }
+      const { localCoreBin } = require("../hephaestus/local-core.cjs");
+      if (!localCoreBin()) {
+        ctx.err(ko
+          ? `${sourceScope} 스코프 편성은 로컬 Agentlas-OS Core(hephaestus)가 연합을 소유합니다 — 설치되어 있지 않습니다.`
+          : `${sourceScope}-scope staffing is federated by the local Agentlas-OS core (hephaestus), which is not installed.`);
+        ctx.err(ko
+          ? "설치: Agentlas 데스크탑 앱 또는 https://agentlas.cloud 안내를 따르세요. 공개 Hub 메뉴만이라면 지금도: agentlas workforce \"<요청>\""
+          : "Install Agentlas-OS (Desktop app or https://agentlas.cloud). For the public Hub menu only, this works today: agentlas workforce \"<request>\"");
+        return 1;
+      }
+      const db = ctx.db();
+      const cwd = projectCwd();
+      const permission = resolvePermission(ctx);
+      const projectPath = ensureTerminalProjectForExecutionCli(db, cwd, permission, `terminal-${command}`) || cwd;
+      const { createLocalCoreHubTool } = require("../workforce/local-core-transport.cjs");
+      const { createLocalCoreWorkforceRuntime } = require("../workforce/deps.cjs");
+      const transport = createLocalCoreHubTool({ sourceScope, projectDir: projectPath, cwd });
+      try {
+        const runtime = createLocalCoreWorkforceRuntime({ lang: ctx.lang, out: ctx.out }, transport);
+        const result = await runtime.cmdWorkforce(db, rest, runtimeOverride, {
+          cwd,
+          projectPath,
+          permission,
+          sourceScope,
+        });
+        return result && result.ok ? 0 : 1;
+      } finally {
+        transport.close();
+      }
     }
     default: {
       ctx.err(`unknown workforce command: ${command}`);

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 };