agentlas 1.0.28 → 1.0.29

package/engine/commands/roles.cjs

@@ -0,0 +1,202 @@
+"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) {
+  const en = ctx.lang === "en";
+  const db = ctx.db();
+  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") return show(ctx);
+  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/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/graph/ask-model.cjs

@@ -0,0 +1,131 @@
+"use strict";
+/*
+ * 인터뷰 한 턴을 모델에게 묻는 최소 경로.
+ *
+ * 세션·영속·메모리 티켓 없이 **한 번 묻고 최종 텍스트만** 받는다. 인터뷰는 사람이 화면 앞에
+ * 앉아 기다리는 대화라, 채팅 세션의 부수효과(대화 저장·메모리 방출·펜스 처리)가 끼어들면
+ * 사용자가 요청하지 않은 기록이 남는다.
+ *
+ * 실패를 삼키지 않는다. 모델이 안 돌면 그 사실과 다음 행동을 그대로 돌려준다 —
+ * 조용히 빈 문자열을 주면 파서가 "읽지 못했습니다"로 바꿔 원인이 사라진다.
+ */
+const nativeHost = require("../agentlas-native-host.cjs");
+// ★resolveRuntime(resolve.cjs)이 아니라 resolveRuntimeForAgent를 쓴다.
+// resolveRuntime은 `role`을 **아예 읽지 않아서**, 사용자가 모델 역할에 gemini를 지정해 둬도
+// active_runtime(codex)으로 흘렀다(실측: 인터뷰가 사용자가 고르지 않은 런타임에서 돌았고,
+// 그쪽 사용 한도가 소진돼 있었다). 사용자가 정한 역할 사다리를 따르는 쪽이 정본이다.
+const { resolveRuntimeForAgent } = require("../runtimes/overrides.cjs");
+const { listAvailableCliRuntimes } = require("../runtimes/detect.cjs");
+
+/**
+ * native-host가 부르는 이벤트 싱크 — 인터뷰 중에는 화면에 아무것도 흘리지 않는다.
+ *
+ * ★메서드를 손으로 골라 적으면 안 된다. native-host가 부르는 이름이 하나라도 빠지면
+ * 턴 중간에 TypeError로 죽는다(실측: streamStart 누락으로 프로세스가 통째로 죽었다).
+ * 실제 EventSink의 표면을 그대로 덮어써서, 저쪽이 늘어나도 여기가 따라간다.
+ */
+function quietSink() {
+  const { EventSink } = require("../sessions/sink.cjs");
+  const sink = new EventSink(() => {}, () => {});
+  const quiet = Object.create(Object.getPrototypeOf(sink));
+  for (const name of Object.getOwnPropertyNames(Object.getPrototypeOf(sink))) {
+    if (name === "constructor") continue;
+    quiet[name] = () => {};
+  }
+  // native-host가 색/번역 헬퍼도 만진다.
+  quiet.c = new Proxy({}, { get: () => (text) => String(text ?? "") });
+  quiet.t = (_key, fallback) => String(fallback ?? "");
+  quiet.replaceTasks = () => {};
+  return quiet;
+}
+
+/**
+ * 인터뷰 한 턴을 묻는다.
+ *
+ * 사용자가 정한 역할(orchestrator)을 **먼저** 쓴다. 그게 실패하면 조용히 포기하지 않고
+ * 이 컴퓨터에 있는 다른 런타임으로 이어서 물어보되, **어느 것이 답했는지 말한다** —
+ * 조용히 다른 모델로 바꾸면 사용자는 자기가 고른 모델이 돈 줄 안다.
+ * 전부 실패하면 각각의 사유를 그대로 돌려준다(하나로 뭉뚱그리면 원인이 사라진다).
+ *
+ * @returns {Promise<{ok:true,text:string,runtime:string,fellBackFrom?:string}
+ *                  |{ok:false,reason:string,nextAction:string}>}
+ */
+async function askModel(ctx, prompt, opts = {}) {
+  const db = ctx.db();
+  let primary = null;
+  try {
+    primary = resolveRuntimeForAgent({
+      db,
+      prefs: ctx.prefs,
+      role: "orchestrator",
+      ...(opts.runtime ? { explicit: opts.runtime } : {}),
+      ...(opts.model ? { model: opts.model } : {}),
+    });
+  } catch (err) {
+    primary = null;
+    var primaryError = (err && err.message) || String(err);
+  }
+
+  // 시도 순서: 사용자가 정한 것 먼저, 그다음 이 컴퓨터에 있는 나머지.
+  const candidates = [];
+  if (primary && primary.kind && primary.bin) candidates.push(primary);
+  if (!opts.runtime) {
+    // listAvailableCliRuntimes()는 문자열이 아니라 {kind, bin, path} 객체를 돌려준다.
+    // 문자열로 읽으면 후보가 하나도 안 쌓여 폴백이 통째로 죽는다(실측).
+    for (const found of listAvailableCliRuntimes()) {
+      if (!found || !found.kind || !found.path) continue;
+      if (candidates.some((c) => c.kind === found.kind)) continue;
+      candidates.push({ kind: found.kind, bin: found.path });
+    }
+  }
+  if (!candidates.length) {
+    return {
+      ok: false,
+      reason: primaryError
+        ? `실행할 AI 런타임을 찾지 못했습니다: ${primaryError}`
+        : "이 컴퓨터에서 쓸 수 있는 AI 런타임이 없습니다.",
+      nextAction: "`agentlas doctor`로 런타임 상태를 확인한 뒤 다시 시도해 주세요.",
+    };
+  }
+
+  const failures = [];
+  for (const runtime of candidates) {
+    let res;
+    try {
+      res = await nativeHost.runNativeTurn({
+        kind: runtime.kind,
+        bin: runtime.bin,
+        ui: quietSink(),
+        cwd: opts.cwd || process.cwd(),
+        prompt,
+        // 읽기 권한 — 인터뷰는 사람에게 묻고 형식을 만드는 일이라 파일을 바꿀 이유가 없다.
+        permission: "read",
+        session: {},
+        model: runtime.model,
+        effort: runtime.effort,
+        mcpServers: [],
+        mcpAllowlistMode: "exact",
+      });
+    } catch (err) {
+      failures.push(`${runtime.kind}: ${(err && err.message) || err}`);
+      continue;
+    }
+    const text = String((res && (res.finalText || res.text)) || "");
+    if (text.trim()) {
+      const out = { ok: true, text, runtime: runtime.kind };
+      if (candidates[0] !== runtime) out.fellBackFrom = candidates[0].kind;
+      return out;
+    }
+    failures.push(res && res.error
+      ? `${runtime.kind}: ${String(res.error).replace(/\s+/g, " ").slice(0, 200)}`
+      : `${runtime.kind}: 빈 답`);
+  }
+
+  return {
+    ok: false,
+    reason: `AI가 답하지 못했습니다.\n  ${failures.join("\n  ")}`,
+    nextAction: "`agentlas doctor`로 런타임 상태를 확인하거나, 로그인이 필요한 런타임에 다시 로그인해 주세요.",
+  };
+}
+
+module.exports = { askModel };