agentlas 1.0.29 → 1.0.35

package/engine/cli-output.cjs

@@ -0,0 +1,262 @@
+"use strict";
+/*
+ * CLI 출력 계약 — 명령은 **문자열이 아니라 {데이터 + 스키마}** 를 돌려준다.
+ *
+ * 왜(2026-08-08, Paseo CLI 대조 실측):
+ * 우리 명령들은 각자 `ctx.out("...")` 로 직접 찍었다. 그래서
+ *  · `--json` 이 어떤 명령엔 있고 어떤 명령엔 없다,
+ *  · 에러 형식이 명령마다 다르다,
+ *  · 스크립트가 쓰려면 사람용 문장을 파싱해야 한다.
+ *
+ * Paseo CLI(`packages/cli/src/output/`)는 명령이 `{type,data,schema}` 를 반환하고
+ * 렌더러 하나가 `--json/--yaml/--quiet/--no-color/--no-headers` 를 해석한다.
+ * 그 계약을 그대로 가져온다. 규칙 셋:
+ *
+ *  1. **quiet 이 모든 것을 이긴다.** `--quiet` 는 id 만 한 줄씩 — `xargs` 로 바로 흐른다.
+ *  2. **에러도 같은 형식 규율을 따른다.** `--json` 이면 `{"error":{"code","message"}}`.
+ *     사람용이면 빨간 `Error: `.
+ *  3. **색은 옵션이 정한다.** 명령이 직접 ANSI 를 박지 않는다(파이프 오염 금지).
+ *
+ * 이 파일은 의존성이 없다(테스트가 순수 함수로 검증한다).
+ */
+
+/** @typedef {"table"|"json"|"yaml"} OutputFormat */
+
+const DEFAULT_OPTIONS = Object.freeze({
+  format: "table",
+  quiet: false,
+  noHeaders: false,
+  noColor: false,
+});
+
+/** 명령이 돌려주는 단일 항목 결과. */
+function single(data, schema) {
+  return { type: "single", data, schema };
+}
+
+/** 명령이 돌려주는 목록 결과. */
+function list(data, schema) {
+  return { type: "list", data: Array.isArray(data) ? data : [], schema };
+}
+
+function isResult(value) {
+  return Boolean(
+    value &&
+      typeof value === "object" &&
+      (value.type === "single" || value.type === "list") &&
+      value.schema &&
+      Array.isArray(value.schema.columns),
+  );
+}
+
+function rowsOf(result) {
+  return result.type === "list" ? result.data : [result.data];
+}
+
+function readField(item, field) {
+  if (typeof field === "function") return field(item);
+  if (item && typeof item === "object") return item[field];
+  return undefined;
+}
+
+function textOf(value) {
+  if (value === null || value === undefined) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value instanceof Date) return value.toISOString();
+  return JSON.stringify(value);
+}
+
+/**
+ * 표시 폭 — ANSI 를 벗기고, CJK 전각을 2칸으로 센다.
+ * 한글 표가 어긋나던 이유가 이것이다(폭을 문자 수로 세면 열이 밀린다).
+ */
+function displayWidth(value) {
+  const plain = String(value).replace(/\[[0-9;]*m/g, "");
+  let width = 0;
+  for (const char of plain) {
+    const code = char.codePointAt(0) ?? 0;
+    const wide =
+      (code >= 0x1100 && code <= 0x115f) ||
+      (code >= 0x2e80 && code <= 0xa4cf) ||
+      (code >= 0xac00 && code <= 0xd7a3) ||
+      (code >= 0xf900 && code <= 0xfaff) ||
+      (code >= 0xfe30 && code <= 0xfe6f) ||
+      (code >= 0xff00 && code <= 0xff60) ||
+      (code >= 0xffe0 && code <= 0xffe6);
+    width += wide ? 2 : 1;
+  }
+  return width;
+}
+
+function padTo(value, width, align) {
+  const pad = Math.max(0, width - displayWidth(value));
+  if (align === "right") return " ".repeat(pad) + value;
+  if (align === "center") {
+    const left = Math.floor(pad / 2);
+    return " ".repeat(left) + value + " ".repeat(pad - left);
+  }
+  return value + " ".repeat(pad);
+}
+
+function renderQuiet(result) {
+  const idField = result.schema.idField;
+  return rowsOf(result)
+    .map((item) => textOf(readField(item, idField)))
+    .filter((line) => line.length > 0)
+    .join("\n");
+}
+
+function renderJson(result) {
+  const serialize = result.schema.serialize;
+  const project = (item) => (serialize ? serialize(item) : item);
+  const payload = result.type === "list" ? result.data.map(project) : project(result.data);
+  return JSON.stringify(payload, null, 2);
+}
+
+/** 의존성 없이 쓰는 최소 YAML(스칼라·객체·배열 1단계). */
+function renderYaml(result) {
+  const serialize = result.schema.serialize;
+  const project = (item) => (serialize ? serialize(item) : item);
+  const scalar = (value) => {
+    if (value === null || value === undefined) return "null";
+    if (typeof value === "number" || typeof value === "boolean") return String(value);
+    const text = textOf(value);
+    return /^[\w./:@-]+$/.test(text) ? text : JSON.stringify(text);
+  };
+  const objectLines = (object, indent) => {
+    const pad = " ".repeat(indent);
+    return Object.entries(object).map(([key, value]) => {
+      if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) {
+        return `${pad}${key}:\n${objectLines(value, indent + 2).join("\n")}`;
+      }
+      if (Array.isArray(value)) {
+        if (value.length === 0) return `${pad}${key}: []`;
+        return `${pad}${key}:\n${value.map((entry) => `${pad}  - ${scalar(entry)}`).join("\n")}`;
+      }
+      return `${pad}${key}: ${scalar(value)}`;
+    });
+  };
+  if (result.type === "list") {
+    if (result.data.length === 0) return "[]";
+    return result.data
+      .map((item) => {
+        const lines = objectLines(project(item), 2);
+        return `- ${lines.join("\n").trimStart()}`;
+      })
+      .join("\n");
+  }
+  return objectLines(project(result.data), 0).join("\n");
+}
+
+function renderTable(result, options) {
+  const columns = result.schema.columns;
+  const rows = rowsOf(result);
+  if (rows.length === 0) return "";
+  const cells = rows.map((item) =>
+    columns.map((column) => textOf(readField(item, column.field))),
+  );
+  const widths = columns.map((column, index) =>
+    Math.max(
+      options.noHeaders ? 0 : displayWidth(column.header),
+      ...cells.map((row) => displayWidth(row[index] ?? "")),
+    ),
+  );
+  const lines = [];
+  if (!options.noHeaders) {
+    lines.push(
+      columns
+        .map((column, index) => padTo(column.header.toUpperCase(), widths[index], column.align))
+        .join("  ")
+        .trimEnd(),
+    );
+  }
+  for (const row of cells) {
+    lines.push(
+      columns
+        .map((column, index) => padTo(row[index] ?? "", widths[index], column.align))
+        .join("  ")
+        .trimEnd(),
+    );
+  }
+  return lines.join("\n");
+}
+
+/** 형식 선택은 여기 한 곳. quiet 이 언제나 이긴다. */
+function render(result, options = {}) {
+  if (!isResult(result)) {
+    throw new TypeError("render() expects a {type,data,schema} command result");
+  }
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  if (opts.quiet) return renderQuiet(result);
+  if (opts.format === "json") return renderJson(result);
+  if (opts.format === "yaml") return renderYaml(result);
+  if (typeof result.schema.renderHuman === "function") return result.schema.renderHuman(result, opts);
+  return renderTable(result, opts);
+}
+
+/** 무엇이든 구조화 에러로. code 는 기계가 분기할 값이다. */
+function toCommandError(error) {
+  if (error && typeof error === "object" && typeof error.code === "string" && typeof error.message === "string") {
+    return { code: error.code, message: error.message, ...(error.details ? { details: error.details } : {}) };
+  }
+  if (error instanceof Error) {
+    return { code: "unknown_error", message: error.message, ...(error.stack ? { details: error.stack } : {}) };
+  }
+  return { code: "unknown_error", message: String(error) };
+}
+
+/** 에러도 같은 형식 규율을 따른다 — 사람용만 색을 쓴다. */
+function renderError(error, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const commandError = toCommandError(error);
+  if (opts.format === "json") return JSON.stringify({ error: commandError }, null, 2);
+  if (opts.format === "yaml") {
+    return ["error:", `  code: ${commandError.code}`, `  message: ${JSON.stringify(commandError.message)}`].join("\n");
+  }
+  const prefix = opts.noColor ? "Error: " : "Error: ";
+  return commandError.details && typeof commandError.details === "string" && opts.format === "table"
+    ? `${prefix}${commandError.message}`
+    : `${prefix}${commandError.message}`;
+}
+
+/**
+ * argv 에서 전역 출력 플래그를 뜯어낸다. **모든 명령이 같은 이름·같은 의미**를 갖도록
+ * 파서가 한 곳이다(명령마다 --json 유무가 갈리던 것을 막는다).
+ *
+ * 색 규칙은 clig.dev 를 따른다: `NO_COLOR` 환경변수, `--no-color`, 그리고 TTY 가
+ * 아니면 자동으로 끈다(파이프에 ANSI 를 흘리지 않는다).
+ */
+function parseOutputFlags(argv, env = process.env, isTty = Boolean(process.stdout.isTTY)) {
+  const rest = [];
+  const options = { ...DEFAULT_OPTIONS };
+  for (const token of argv) {
+    if (token === "--json") options.format = "json";
+    else if (token === "--yaml") options.format = "yaml";
+    else if (token === "--quiet" || token === "-q") options.quiet = true;
+    else if (token === "--no-headers") options.noHeaders = true;
+    else if (token === "--no-color") options.noColor = true;
+    else rest.push(token);
+  }
+  if (env && (env.NO_COLOR || env.AGENTLAS_NO_COLOR)) options.noColor = true;
+  if (!isTty) options.noColor = true;
+  return { options, rest };
+}
+
+/** 사람용 표현이 스피너·배너를 써도 되는가(비대화형이면 평문으로 떨어진다). */
+function isRichUi(options, isTty = Boolean(process.stdout.isTTY)) {
+  return Boolean(isTty) && options.format === "table" && !options.quiet;
+}
+
+module.exports = {
+  DEFAULT_OPTIONS,
+  single,
+  list,
+  isResult,
+  render,
+  renderError,
+  toCommandError,
+  parseOutputFlags,
+  isRichUi,
+  displayWidth,
+};

package/engine/cloud-assets/package.cjs

@@ -591,10 +591,14 @@ function cloudRoutingCardProblem(card) {
   if (!workforce || typeof workforce !== "object" || Array.isArray(workforce)) {
     return "workforce must be a complete semantic resume";
   }
+  // `skills` has a floor of 0, not 1. Skills are modules and live outside the
+  // core, so a fully modular agent legitimately declares none. Requiring one
+  // here would block publishing every modular package. Kept identical in
+  // agentlas_desktop/electron/cloud-agents/package.ts — the two must not drift.
   const semanticLists = [
     ["communities", /^community:[a-z0-9][a-z0-9-]*$/, 1, 5],
     ["roles", /^role:[a-z0-9][a-z0-9-]*$/, 0, 4],
-    ["skills", /^skill:[a-z0-9][a-z0-9-]*$/, 1, 12],
+    ["skills", /^skill:[a-z0-9][a-z0-9-]*$/, 0, 12],
     ["knowledge", /^knowledge:[a-z0-9][a-z0-9-]*$/, 0, 256],
   ];
   for (const [field, pattern, minimum, maximum] of semanticLists) {

package/engine/commands/automation.cjs

@@ -2,6 +2,9 @@
 /*
  * automation — 자동화 등록/목록/토글/삭제/실행 (v1 cmdAutomation 의 v2 포팅).
  *   list (기본) | add | on <id> | off <id> | remove <id> | run <id> | runs | daemon
+ *   tick            1회 due 스윕 후 종료(launchd/cron 이 poke 하는 진입점)
+ *   install         macOS launchd 상주 켜기 — 앱/창이 꺼져 있어도 발동(opt-in)
+ *   uninstall       상주 끄기 · status  상주 상태
  *
  * 스케줄 계산은 automation/schedule, DB는 automation/store, 실행은
  * automation/daemon(세션 계층)만 쓴다. run <id> 는 스케줄을 건드리지 않는다
@@ -196,7 +199,40 @@ async function run(ctx, args) {
     return daemon.automationDaemon(ctx, db, { intervalSec: interval, runtimeOverride });
   }
 
-  ctx.err(usage("list|add|on <id>|off <id>|remove <id>|run <id>|runs|daemon"));
+  // 1회 due 스윕 후 종료 — launchd/cron 이 poke 하는 진입점(상주 루프 아님).
+  if (sub === "tick") {
+    await daemon.daemonTick(ctx, db, {});
+    return 0;
+  }
+
+  // 앱/창이 꺼져 있어도 자동화가 발동하도록 macOS launchd 로 상주시킨다(opt-in).
+  if (sub === "install" || sub === "uninstall" || sub === "status") {
+    const launchd = require("../automation/launchd.cjs");
+    if (sub === "status") {
+      const st = launchd.launchdStatus();
+      if (!st.supported) { ctx.out(ko ? "launchd 상주는 macOS 전용입니다. 다른 OS 는 `agentlas automation daemon` 을 켜 두세요." : "launchd persistence is macOS-only. On other systems keep `agentlas automation daemon` running."); return 0; }
+      ctx.out(`${st.loaded ? ctx.ui.green("✓") : ctx.ui.dim("○")} ${ko ? "상주(launchd)" : "persistence (launchd)"}: ${st.loaded ? (ko ? "실행 중" : "loaded") : st.installed ? (ko ? "설치됨(미로드)" : "installed (not loaded)") : (ko ? "미설치" : "not installed")}`);
+      ctx.out(ctx.ui.dim(`plist: ${st.plistPath}`));
+      if (!st.loaded) ctx.out(ctx.ui.dim(ko ? "켜기: agentlas automation install" : "Enable: agentlas automation install"));
+      return 0;
+    }
+    if (sub === "install") {
+      let interval = 300;
+      for (let i = 1; i < args.length; i++) if (args[i] === "--interval") interval = Math.max(30, Number(args[++i]) || 300);
+      const st = launchd.enableLaunchd({ intervalSec: interval });
+      if (st.error) { ctx.err(`${ctx.ui.red("✖")} ${st.error}`); return 1; }
+      ctx.out(`${ctx.ui.green("✓")} ${ko ? "상주를 켰습니다 — 앱/창이 꺼져 있어도 자동화가 발동합니다" : "persistence on — automations fire even with the app/window closed"} (${interval}s)`);
+      ctx.out(ctx.ui.dim(ko ? `${Math.max(30, interval)}초마다 due 를 확인합니다. 끄기: agentlas automation uninstall` : `checks due automations every ${Math.max(30, interval)}s. Disable: agentlas automation uninstall`));
+      return 0;
+    }
+    // uninstall
+    const st = launchd.disableLaunchd();
+    if (st.error) { ctx.err(`${ctx.ui.red("✖")} ${st.error}`); return 1; }
+    ctx.out(`${ctx.ui.green("✓")} ${ko ? "상주를 껐습니다. 자동화는 포그라운드 daemon 을 켜 둘 때만 발동합니다." : "persistence off. Automations fire only while a foreground daemon runs."}`);
+    return 0;
+  }
+
+  ctx.err(usage("list|add|on <id>|off <id>|remove <id>|run <id>|runs|daemon|tick|install|uninstall|status"));
   return 1;
 }
 

package/engine/commands/browser.cjs

@@ -1,19 +1,177 @@
 "use strict";
 /*
- * browser — 실제 브라우저 실행 하드포인트 (hep-browser 라우트).
+ * browser — 실제 브라우저 실행 하드포인트 + 사이트 로그인 볼트·조종 (2026-08-06 확장).
  *
- * v1 디스패처 매핑 그대로:
- *   `agentlas browser <url-or-query|sub…>` → cmdHep(["hep-browser", ...rest])
- *   v1은 browser에 무인자 가드가 없었다(missingArgumentUsage 미포함) —
- *   무인자도 hep-browser 패스스루로 넘어가 네이티브 usage가 나온다. 보존.
+ * 오너 원칙("조종을 다른 흐름으로 확장"): telegram 뿐 아니라 데스크탑의 브라우저-볼트
+ * 흐름(사이트별 전용-프로필 로그인/세션)도 터미널에서 조종·공유되어야 한다. 저장 테이블은
+ * 데스크탑과 공유(browser_sites/…)하고, 조종은 CDP(engine/browser/cdp.cjs)로 한다.
+ *
+ * 하위 명령(볼트·조종):
+ *   browser status                브라우저(Chrome/CDP) 준비 상태 + 사이트 세션 요약
+ *   browser sites                 저장된 사이트와 로그인 세션 상태(valid/expired/none)
+ *   browser add <site> [--label L] [--user U]   사이트 카드 추가(비밀번호 없음)
+ *   browser login <site>          그 사이트를 Agentlas 브라우저로 연다 — 로그인은 사용자가 직접
+ *   browser mark <site> <valid|expired|none>    로그인 뒤 세션 상태를 기록
+ *   browser go <url>              이미 열린 Agentlas 브라우저를 그 URL 로 몬다(조종)
+ *   browser rm <site>             사이트 카드 삭제
+ *
+ * 그 외(무인자 포함, URL·검색어)는 v1 그대로 hep-browser 하드포인트로 넘겨 Chrome 을 띄운다.
+ *
+ * 보안(데스크탑과 동일): 비밀번호를 받지도, 자동 입력하지도 않는다. 로그인은 제공자 페이지에서
+ * 사용자가 직접 한다 — 터미널은 페이지를 열어 주고 세션 상태만 기록한다.
  */
 const { create, usageFor, isHelpToken } = require("../hephaestus/runtime.cjs");
+const vault = require("../browser/vault.cjs");
+const cdp = require("../browser/cdp.cjs");
 
-async function run(ctx, args) {
-  if (args.some(isHelpToken)) {
-    ctx.out(usageFor("browser", ctx.lang));
+const SUBS = new Set(["status", "sites", "add", "login", "mark", "go", "rm", "remove"]);
+
+function flag(rest, name) {
+  const i = rest.findIndex((a) => a === `--${name}`);
+  return i >= 0 && rest[i + 1] ? rest[i + 1] : null;
+}
+function positional(rest) { return rest.find((a) => a && !String(a).startsWith("-")) || null; }
+
+function siteUrl(site) { return /^[a-z][a-z0-9+.-]*:\/\//i.test(site) ? site : `https://${site}`; }
+
+function statusDot(ui, status) {
+  if (status === "valid") return ui.green("●");
+  if (status === "expired") return ui.yellow ? ui.yellow("●") : ui.dim("●");
+  return ui.dim("○");
+}
+
+async function browserStatus(ctx) {
+  const ko = ctx.lang === "ko";
+  const ready = await cdp.cdpReady();
+  ctx.out(`${ready ? ctx.ui.green("✓") : ctx.ui.dim("○")} ${ko ? "Agentlas 브라우저(CDP)" : "Agentlas browser (CDP)"}: ${ready ? (ko ? "실행 중 — 조종 가능" : "running — pilotable") : (ko ? "꺼짐" : "not running")} (port ${cdp.DEFAULT_PORT})`);
+  const sites = vault.listBrowserSites(ctx.db());
+  if (!sites.length) {
+    ctx.out(ctx.ui.dim(ko ? "저장된 사이트 없음. 추가: agentlas browser add <site>" : "No saved sites. Add one: agentlas browser add <site>"));
+    return 0;
+  }
+  const valid = sites.filter((s) => s.session.status === "valid").length;
+  ctx.out(ctx.ui.dim(ko ? `사이트 ${sites.length}개 (로그인 유효 ${valid}개) — 목록: agentlas browser sites` : `${sites.length} sites (${valid} logged in) — list: agentlas browser sites`));
+  return 0;
+}
+
+function browserSites(ctx) {
+  const ko = ctx.lang === "ko";
+  const sites = vault.listBrowserSites(ctx.db());
+  if (!sites.length) {
+    ctx.out(ctx.ui.dim(ko ? "저장된 사이트가 없습니다. 추가: agentlas browser add <site>" : "No saved sites yet. Add one: agentlas browser add <site>"));
     return 0;
   }
+  for (const s of sites) {
+    const when = s.session.capturedAt ? new Date(s.session.capturedAt).toLocaleDateString() : "";
+    const label = s.label ? ` ${ctx.ui.dim(s.label)}` : "";
+    const user = s.username ? ctx.ui.dim(` (${s.username})`) : "";
+    ctx.out(`${statusDot(ctx.ui, s.session.status)} ${s.site}${label}${user}  ${ctx.ui.dim(`${s.session.status}${when ? " · " + when : ""}`)}`);
+  }
+  return 0;
+}
+
+function browserAdd(ctx, rest) {
+  const ko = ctx.lang === "ko";
+  const site = positional(rest);
+  if (!site) { ctx.err(ko ? "사용법: agentlas browser add <site> [--label 이름] [--user 아이디]" : "Usage: agentlas browser add <site> [--label name] [--user handle]"); return 1; }
+  try {
+    const row = vault.upsertBrowserSite(ctx.db(), { site, label: flag(rest, "label"), username: flag(rest, "user") });
+    vault.logBrowserAction(ctx.db(), { site: row.site, action: "vault.save", result: "ok" });
+    ctx.out(`${ctx.ui.green("✓")} ${ko ? "사이트를 저장했습니다" : "site saved"}: ${row.site}`);
+    ctx.out(ctx.ui.dim(ko ? `로그인: agentlas browser login ${row.site}` : `Log in: agentlas browser login ${row.site}`));
+    return 0;
+  } catch (e) { ctx.err(`${ctx.ui.red("✖")} ${String((e && e.message) || e)}`); return 1; }
+}
+
+async function browserLogin(ctx, rest) {
+  const ko = ctx.lang === "ko";
+  const site = positional(rest);
+  if (!site) { ctx.err(ko ? "사용법: agentlas browser login <site>" : "Usage: agentlas browser login <site>"); return 1; }
+  const db = ctx.db();
+  let row;
+  try { row = vault.upsertBrowserSite(db, { site }); } catch (e) { ctx.err(`${ctx.ui.red("✖")} ${String((e && e.message) || e)}`); return 1; }
+  const url = siteUrl(row.site);
+
+  if (await cdp.cdpReady()) {
+    // 이미 열린 Agentlas 브라우저를 로그인 페이지로 몬다(조종). 로그인은 사용자가 직접.
+    try {
+      const page = await cdp.attachPage();
+      try { await page.navigate(url, { waitMs: 1500 }); } finally { page.close(); }
+      vault.logBrowserAction(db, { site: row.site, action: "login.open", target: url, result: "navigated" });
+      ctx.out(`${ctx.ui.green("✓")} ${ko ? "브라우저를 로그인 페이지로 옮겼습니다" : "moved the browser to the login page"}: ${url}`);
+    } catch (e) {
+      ctx.err(`${ctx.ui.red("✖")} ${String((e && e.message) || e)}`);
+      return 1;
+    }
+  } else {
+    // CDP 미기동 — 조종할 대상이 없다. 먼저 브라우저를 띄우도록 정직하게 안내(자동 실행 안 함).
+    ctx.out(ko
+      ? `Agentlas 브라우저가 아직 실행 중이 아닙니다. 먼저 열어 주세요:\n  agentlas browser ${url}`
+      : `The Agentlas browser is not running yet. Open it first:\n  agentlas browser ${url}`);
+  }
+  ctx.out(ctx.ui.dim(ko
+    ? `그 창에서 직접 로그인한 뒤, 세션을 기록하세요:\n  agentlas browser mark ${row.site} valid`
+    : `Log in yourself in that window, then record the session:\n  agentlas browser mark ${row.site} valid`));
+  ctx.out(ctx.ui.dim(ko ? "비밀번호는 받지도, 자동 입력하지도 않습니다 — 로그인은 사용자만." : "No password is ever taken or auto-typed — you log in, not the tool."));
+  return 0;
+}
+
+function browserMark(ctx, rest) {
+  const ko = ctx.lang === "ko";
+  const site = positional(rest);
+  const status = rest.filter((a) => a && !String(a).startsWith("-") && a !== site)[0];
+  if (!site || !status) { ctx.err(ko ? "사용법: agentlas browser mark <site> <valid|expired|none>" : "Usage: agentlas browser mark <site> <valid|expired|none>"); return 1; }
+  try {
+    const row = vault.setBrowserSession(ctx.db(), site, status);
+    vault.logBrowserAction(ctx.db(), { site: row.site, action: "session.mark", result: status });
+    ctx.out(`${ctx.ui.green("✓")} ${row.site}: ${ko ? "세션 상태" : "session"} → ${status}`);
+    return 0;
+  } catch (e) { ctx.err(`${ctx.ui.red("✖")} ${String((e && e.message) || e)}`); return 1; }
+}
+
+async function browserGo(ctx, rest) {
+  const ko = ctx.lang === "ko";
+  const url = positional(rest);
+  if (!url) { ctx.err(ko ? "사용법: agentlas browser go <url>" : "Usage: agentlas browser go <url>"); return 1; }
+  if (!(await cdp.cdpReady())) {
+    ctx.err(ko
+      ? `Agentlas 브라우저가 실행 중이 아닙니다. 먼저 열어 주세요: agentlas browser ${siteUrl(url)}`
+      : `The Agentlas browser is not running. Open it first: agentlas browser ${siteUrl(url)}`);
+    return 1;
+  }
+  try {
+    const page = await cdp.attachPage();
+    let title;
+    try { await page.navigate(siteUrl(url), { waitMs: 1500 }); title = await page.evalExpr("document.title"); } finally { page.close(); }
+    ctx.out(`${ctx.ui.green("✓")} ${ko ? "이동했습니다" : "navigated"}: ${siteUrl(url)}${title ? ctx.ui.dim(` — ${title}`) : ""}`);
+    return 0;
+  } catch (e) { ctx.err(`${ctx.ui.red("✖")} ${String((e && e.message) || e)}`); return 1; }
+}
+
+function browserRemove(ctx, rest) {
+  const ko = ctx.lang === "ko";
+  const site = positional(rest);
+  if (!site) { ctx.err(ko ? "사용법: agentlas browser rm <site>" : "Usage: agentlas browser rm <site>"); return 1; }
+  vault.deleteBrowserSite(ctx.db(), site);
+  vault.logBrowserAction(ctx.db(), { site: vault.normalizeSite(site), action: "vault.delete", result: "ok" });
+  ctx.out(`${ctx.ui.green("✓")} ${ko ? "사이트를 삭제했습니다" : "site removed"}: ${vault.normalizeSite(site) || site}`);
+  return 0;
+}
+
+async function run(ctx, args) {
+  if (args.some(isHelpToken)) { ctx.out(usageFor("browser", ctx.lang)); return 0; }
+  const sub = String(args[0] || "").toLowerCase();
+  const rest = args.slice(1);
+  if (SUBS.has(sub)) {
+    if (sub === "status") return browserStatus(ctx);
+    if (sub === "sites") return browserSites(ctx);
+    if (sub === "add") return browserAdd(ctx, rest);
+    if (sub === "login") return browserLogin(ctx, rest);
+    if (sub === "mark") return browserMark(ctx, rest);
+    if (sub === "go") return browserGo(ctx, rest);
+    if (sub === "rm" || sub === "remove") return browserRemove(ctx, rest);
+  }
+  // 그 외(무인자·URL·검색어)는 v1 그대로 hep-browser 하드포인트로 — Chrome 을 실제로 띄운다.
   return create(ctx).cmdHep(["hep-browser", ...args]);
 }
 

package/engine/commands/build.cjs

@@ -1,33 +1,114 @@
 "use strict";
 /*
- * build — 에이전트/팀 빌드·수리·패키징 (hep-build 라우트).
+ * build — 에이전트를 로컬에서 빌드·설치한다 (독립, 2026-08-06 재작성).
  *
- * v1 디스패처 검증 메모 (legacy-v1-engine-snapshot engine/agentlas.cjs ~13097):
- *   v1의 `agentlas build`는 hep-build 단순 패스스루가 아니라 터미널 소유
- *   빌더(terminalAssets.cmdBuild: 시스템 MCP 메타데이터 프리플라이트 → 1회
- *   동의 → Meta-Agent 실행)로 갔다. 그 프리플라이트/빌더 체인은 engine/mcp/*
- *   와 빌더 서브시스템 소유라 이 클러스터의 범위 밖이다.
- *   v2의 이 파일은 v1 도움말이 계약으로 명시한 표면 —
- *   `build "<request>" … (hep-build)` — 즉 Agentlas OS hep-build 라우트를
- *   그대로 노출한다. 터미널 소유 MCP-동의 빌더가 v2에 재구축되면 그 모듈이
- *   이 명령을 대체(또는 선행)해야 한다.
+ * 이전: `build "<req>"`는 Hephaestus 네이티브 hep-build 패스스루였고, 그 네이티브는
+ * "Open Claude Code or Codex with the plugin, then /hep-build"라는 스텁만 냈다 —
+ * 플러그인을 강제해 오너 원칙(데스크탑/플러그인은 공유하되 전제 아님)을 어겼다.
  *
- * v1 인자 가드 그대로:
- *   - help 토큰 → usage 출력, exit 0
- *   - 무인자   → usage 실패, exit 1 (요청 문자열이 라우터로 새는 것 방지)
+ * 지금: 터미널 자체 런타임으로 로컬 빌더(agents/builder.cjs)를 `run`과 같은
+ * 실행 인프라(Orchestrator 세션)로 돌려 import 가능한 폴더를 만들고, 성공하면
+ * 자동 설치한다. 폴더는 남으므로 자동 설치가 실패해도 `agentlas import`로 복구 가능.
  */
-const { create, usageFor, isHelpToken } = require("../hephaestus/runtime.cjs");
+const { Orchestrator } = require("../sessions/orchestrator.cjs");
+const { Renderer } = require("../ui/renderer.cjs");
+const { resolveRuntimeForAgent } = require("../runtimes/overrides.cjs");
+const permissions = require("../agentlas-permissions.cjs");
+const { projectCwd } = require("../project/paths.cjs");
+const { ensureTerminalProjectForExecutionCli } = require("../project/state.cjs");
+const { ensureBuilderAgent, parseBuiltFolder } = require("../agents/builder.cjs");
+const { importLocalFolder } = require("../agents/import-local.cjs");
+const path = require("node:path");
+const fs = require("node:fs");
+
+function usage(ko) {
+  return ko
+    ? "사용법: agentlas build \"<만들고 싶은 에이전트>\"  [--runtime <kind>] [--print]"
+    : "Usage: agentlas build \"<the agent you want>\"  [--runtime <kind>] [--print]";
+}
 
 async function run(ctx, args) {
-  if (args.some(isHelpToken)) {
-    ctx.out(usageFor("build", ctx.lang));
-    return 0;
+  const ko = ctx.lang === "ko";
+  if (args.some((a) => a === "--help" || a === "-h" || a === "help")) { ctx.out(usage(ko)); return 0; }
+
+  // --runtime/--print 만 벗겨내고 나머지는 요청 문장.
+  const flags = {};
+  const rest = [];
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === "--runtime" && args[i + 1]) { flags.runtime = args[++i]; continue; }
+    if (args[i] === "--print" || args[i] === "-p") { flags.print = true; continue; }
+    rest.push(args[i]);
+  }
+  const request = rest.join(" ").trim();
+  if (!request) { ctx.err("✖ " + usage(ko)); return 1; }
+
+  const db = ctx.db();
+  const cwd = projectCwd();
+  const agent = ensureBuilderAgent(db);
+
+  let runtime;
+  try {
+    runtime = resolveRuntimeForAgent({
+      db, prefs: ctx.prefs, explicit: flags.runtime, role: "orchestrator", agentId: agent.id,
+    });
+  } catch (e) {
+    // no_runtime 등 정직 정지 그대로.
+    ctx.err(String((e && e.message) || e));
+    return 1;
+  }
+
+  // 빌더는 파일을 써야 한다 — write 권한으로 실행한다(현재 폴더에 패키지 생성).
+  const permission = permissions.normalize("write");
+  try { ensureTerminalProjectForExecutionCli(db, cwd, permission, "terminal-build"); } catch { /* 프로젝트 없어도 빌드는 됨 */ }
+
+  const orch = new Orchestrator({ db, lang: ctx.lang });
+  const session = orch.spawn({ agent, runtime, permission, cwd, title: `build: ${request.slice(0, 48)}` });
+
+  let renderer = null;
+  if (!flags.print) {
+    renderer = new Renderer(ctx.uiInstance);
+    renderer.attach(session, { replay: false });
+    ctx.err(ctx.uiInstance.c.dim(`${agent.slug} · ${runtime.kind}${runtime.model ? ` · ${runtime.model}` : ""}`));
   }
-  if (!args.length) {
-    ctx.err("✖ " + usageFor("build", ctx.lang));
+
+  const res = await session.send(request);
+  if (renderer) renderer.detach();
+  const finalText = (res && (res.finalText || res.text)) || "";
+  if (flags.print && finalText) process.stdout.write(finalText.trimEnd() + "\n");
+
+  if (session.status === "failed") {
+    if (session.lastError) ctx.err(session.lastError);
     return 1;
   }
-  return create(ctx).cmdHep(["hep-build", ...args]);
+
+  // 빌더가 `BUILT: <folder>`를 남겼으면 자동 설치한다.
+  const built = parseBuiltFolder(finalText);
+  if (!built) {
+    ctx.out(ctx.uiInstance.c.dim(ko
+      ? "빌드 산출물 위치를 확정하지 못했습니다. 만들어진 폴더를 확인해 `agentlas import <폴더>`로 설치하세요."
+      : "Could not confirm the built folder. Check the created folder and install it with `agentlas import <folder>`."));
+    return 0;
+  }
+  const builtPath = path.isAbsolute(built) ? built : path.join(cwd, built);
+  if (!fs.existsSync(builtPath)) {
+    ctx.out(ctx.uiInstance.c.dim(ko
+      ? `빌더가 알린 폴더가 없습니다: ${built}. 만들어진 폴더를 확인해 \`agentlas import\`로 설치하세요.`
+      : `The reported folder does not exist: ${built}. Check the created folder and install it with \`agentlas import\`.`));
+    return 0;
+  }
+  try {
+    const imported = importLocalFolder(db, builtPath);
+    ctx.out(`${ctx.uiInstance.c.green("✓")} ${ko ? "설치됨" : "installed"}: ${imported.slug} — ${imported.name}`);
+    ctx.out(ctx.uiInstance.c.dim(ko
+      ? `실행: agentlas run ${imported.slug} "<할 일>"`
+      : `Run it: agentlas run ${imported.slug} "<task>"`));
+    return 0;
+  } catch (e) {
+    ctx.out(ctx.uiInstance.c.dim(ko
+      ? `자동 설치 실패(${String((e && e.message) || e)}). 폴더는 남아 있습니다: ${builtPath}. \`agentlas import ${builtPath}\`로 설치하세요.`
+      : `Auto-install failed (${String((e && e.message) || e)}). The folder remains at ${builtPath}. Install with \`agentlas import ${builtPath}\`.`));
+    return 0;
+  }
 }
 
 module.exports = { run };