agentlas 1.0.55 → 1.0.58

package/engine/commands/graph.cjs

@@ -157,6 +157,166 @@ function listGraphs(ctx) {
   return 0;
 }
 
+/**
+ * 옛 실행이 부수효과를 남겨 막힌 자동화를, 사람이 **한 번** 판단해 풀어 준다.
+ *
+ * 실측 2026-08-20: 터미널 코어에는 재조정 모듈이 아예 실리지 않아,
+ * `automation_partial_reconciliation_required` 를 **낼 수는 있는데 풀 수단이 없었다**.
+ * CLI 만 쓰는 사람은 그 자동화를 영원히 못 돌린다. 내는 오류가 있으면 푸는 길도 있어야 한다.
+ *
+ * 판단은 노드마다 둘 중 하나다 — "이미 일어났다(--done)" / "확실히 안 일어났다(--not-done)".
+ * 아무 것도 주지 않으면 무엇을 정해야 하는지 보여 주기만 한다. 실행 중에 묻지 않는다.
+ */
+/**
+ * 엔진을 손에 넣는다 — 캐시에 없으면 **받는다**.
+ *
+ * ★엔진이 필요한 명령은 전부 이 길을 지나야 한다. 실측 2026-08-20: `graph run` 은 이걸
+ *   고쳤는데, 바로 뒤에 만든 `graph reconcile` 이 동기 로더만 불러 같은 병을 반복했다 —
+ *   새로 설치한 사람에게는 "이 엔진에는 재조정 기능이 없습니다" 로 보인다(사실은 엔진이
+ *   아직 없는 것이다). 한 곳으로 모아 다음 명령이 또 빠뜨리지 않게 한다.
+ */
+async function acquireCore(ctx) {
+  const desktopCore = require("../core/desktop-core.cjs");
+  let core = ctx.desktopCore || desktopCore.loadDesktopCore();
+  if (!core || core.error || typeof core.runGraph !== "function") {
+    try {
+      core = await desktopCore.loadDesktopCoreAsync({ onNotice: (message) => ctx.err(message) });
+    } catch {
+      return null;
+    }
+  }
+  return core && !core.error ? core : null;
+}
+
+async function reconcileGraph(ctx, needle, flags, en) {
+  const rows = graphRows(ctx, ctx.db());
+  const row = findGraph(rows, needle);
+  if (row?.ambiguous) { reportAmbiguous(ctx, needle, row.ambiguous, en); return 1; }
+  if (!row) {
+    ctx.err(en ? `No graph matches "${needle}".` : `"${needle}"와 맞는 그래프가 없습니다.`);
+    return 1;
+  }
+  const core = await acquireCore(ctx);
+  const reconciliation = core && core.graphReconciliation;
+  if (!reconciliation || typeof reconciliation.get !== "function") {
+    ctx.err(en
+      ? "This engine build cannot reconcile. Update the CLI (`npm i -g agentlas@latest`) and try again."
+      : "이 엔진에는 재조정 기능이 없습니다. CLI를 업데이트한 뒤(`npm i -g agentlas@latest`) 다시 시도하세요.");
+    return 1;
+  }
+  // 그래프를 고친 뒤에는 옛 좌표가 그 그래프의 것이 아니라 재조정도 거절된다. 그 상태는
+  // 실행도 재조정도 안 되는 잠김이므로, 사람이 스스로 나갈 문을 둔다.
+  if (flags && flags['start-over']) {
+    if (typeof reconciliation.forgetStale !== 'function') {
+      ctx.err(en ? 'This engine build cannot do that. Update the CLI and try again.' : '이 엔진에는 그 기능이 없습니다. CLI를 업데이트한 뒤 다시 시도하세요.');
+      return 1;
+    }
+    const graph = parseGraph(row);
+    const automation = core.getAutomation ? core.getAutomation(row.id) : null;
+    const digest = core.graphExecutionDigest && automation && graph
+      ? core.graphExecutionDigest(automation, graph)
+      : null;
+    if (!digest) {
+      ctx.err(en ? 'Could not compute the current graph identity.' : '지금 그래프의 신원을 계산하지 못했습니다.');
+      return 1;
+    }
+    const outcome = reconciliation.forgetStale(row.id, digest);
+    if (!outcome.forgot) {
+      ctx.err(en
+        ? `Nothing to forget (${outcome.reason}). If the graph has not changed, decide each step instead.`
+        : `잊을 것이 없습니다(${outcome.reason}). 그래프가 그대로라면, 단계마다 정하는 쪽이 맞습니다.`);
+      return 1;
+    }
+    ctx.out(en
+      ? 'The earlier run is forgotten. Note: whatever it already did can happen again on the next run.'
+      : '이전 실행을 잊었습니다. 그 실행이 이미 한 일은 다음 실행에서 다시 일어날 수 있습니다.');
+    return 0;
+  }
+
+  const view = reconciliation.get(row.id);
+  if (!view) {
+    ctx.out(en
+      ? `"${row.name}" has nothing waiting to be reconciled.`
+      : `"${row.name}"에는 재조정을 기다리는 것이 없습니다.`);
+    return 0;
+  }
+
+  const done = new Set(asList(flags && (flags.done ?? flags["done"])));
+  const notDone = new Set(asList(flags && (flags["not-done"] ?? flags.notDone)));
+  const outputs = new Map();
+  for (const pair of asList(flags && flags.output)) {
+    const at = String(pair).indexOf("=");
+    if (at > 0) outputs.set(String(pair).slice(0, at).trim(), String(pair).slice(at + 1));
+  }
+
+  if (done.size === 0 && notDone.size === 0) {
+    ctx.out(en
+      ? `"${row.name}" stopped with steps whose effect cannot be told from the record.`
+      : `"${row.name}"은(는) 기록만으로는 일어났는지 알 수 없는 단계가 있어 멈춰 있습니다.`);
+    ctx.out("");
+    for (const node of view.nodes) {
+      const needs = node.outputRequired
+        ? (en ? `  (needs --output ${node.nodeId}=<value> when done)` : `  (일어났다면 --output ${node.nodeId}=<값> 필요)`)
+        : "";
+      ctx.out(`  ${node.nodeId}  ${node.label}${needs}`);
+    }
+    ctx.out("");
+    ctx.out(ctx.ui.dim(en
+      ? `Decide each one: agentlas graph reconcile "${row.name}" --done <node> --not-done <node>`
+      : `각각 정하세요: agentlas graph reconcile "${row.name}" --done <노드> --not-done <노드>`));
+    return 0;
+  }
+
+  const undecided = view.nodes.filter((n) => !done.has(n.nodeId) && !notDone.has(n.nodeId));
+  if (undecided.length > 0) {
+    ctx.err(en
+      ? `Still undecided: ${undecided.map((n) => n.nodeId).join(", ")}. Every step needs one answer.`
+      : `아직 안 정한 단계가 있습니다: ${undecided.map((n) => n.nodeId).join(", ")}. 모든 단계에 답이 필요합니다.`);
+    return 1;
+  }
+  const missingOutput = view.nodes.filter((n) => done.has(n.nodeId) && n.outputRequired && !outputs.has(n.nodeId));
+  if (missingOutput.length > 0) {
+    ctx.err(en
+      ? `These steps populate a value, so completing them needs it: ${missingOutput.map((n) => `--output ${n.nodeId}=<value>`).join(" ")}`
+      : `값을 만드는 단계라 "일어났다"로 두려면 값이 필요합니다: ${missingOutput.map((n) => `--output ${n.nodeId}=<값>`).join(" ")}`);
+    return 1;
+  }
+
+  try {
+    const result = reconciliation.apply({
+      automationId: view.automationId,
+      runId: view.runId,
+      occurrenceId: view.occurrenceId,
+      graphDigest: view.graphDigest,
+      checkpointDigest: view.checkpointDigest,
+      expectedUpdatedAt: view.updatedAt,
+      eventId: view.triggerEvent ? view.triggerEvent.id : null,
+      expectedEventUpdatedAt: view.triggerEvent ? view.triggerEvent.updatedAt : null,
+      decisions: view.nodes.map((n) => (done.has(n.nodeId)
+        ? { nodeId: n.nodeId, resolution: "completed", ...(outputs.has(n.nodeId) ? { output: outputs.get(n.nodeId) } : {}) }
+        : { nodeId: n.nodeId, resolution: "retry" })),
+    });
+    ctx.out(en
+      ? `Reconciled. ${result.completedNodeIds.length} step(s) marked as done, ${result.retryNodeIds.length} to redo.`
+      : `재조정했습니다. ${result.completedNodeIds.length}개는 일어난 것으로, ${result.retryNodeIds.length}개는 다시 하는 것으로 두었습니다.`);
+    ctx.out(ctx.ui.dim(en
+      ? `Now run it: agentlas graph run "${row.name}"`
+      : `이제 실행하세요: agentlas graph run "${row.name}"`));
+    return 0;
+  } catch (error) {
+    ctx.err(en
+      ? `Reconciliation was refused: ${String(error && error.message || error)}`
+      : `재조정이 거절됐습니다: ${String(error && error.message || error)}`);
+    return 1;
+  }
+}
+
+/** 같은 깃발이 여러 번 올 수 있다 — 하나든 여럿이든 배열로 본다. */
+function asList(value) {
+  if (value == null) return [];
+  return Array.isArray(value) ? value.map(String) : [String(value)];
+}
+
 function showGraph(ctx, needle) {
   const db = ctx.db();
   const rows = graphRows(ctx, db);
@@ -558,19 +718,10 @@ async function runGraph(ctx, needle, flags) {
    *
    *   받는 동안은 조용하지 않다(onNotice) — 12MB 를 말없이 끌어오지 않는다.
    */
-  let core = ctx.desktopCore || desktopCore.loadDesktopCore();
-  if (!core || core.error || typeof core.runGraph !== "function") {
-    try {
-      core = await desktopCore.loadDesktopCoreAsync({ onNotice: (message) => ctx.err(message) });
-    } catch (fetchError) {
-      ctx.err(JSON.stringify({
-        ok: false,
-        error: `graph-execution engine could not be fetched: ${fetchError instanceof Error ? fetchError.message : String(fetchError)}`,
-      }, null, 2));
-      return 1;
-    }
-  }
-  if (!core || core.error || typeof core.runGraph !== "function") {
+  // ★엔진을 얻는 법을 아는 곳은 acquireCore 하나뿐이다 — 둘이면 다음에 만드는 명령이
+  //   또 한쪽만 보고 캐시에서 끝난다(실측 2026-08-20: reconcile 이 정확히 그랬다).
+  let core = await acquireCore(ctx);
+  if (!core || typeof core.runGraph !== "function") {
     const cause = core?.error instanceof Error ? core.error.message : "vendored Desktop Core is unavailable";
     ctx.err(JSON.stringify({ ok: false, error: cause }, null, 2));
     return 1;
@@ -1147,6 +1298,7 @@ async function run(ctx, args = []) {
   for (let i = 0; i < args.length; i += 1) {
     const arg = args[i];
     if (arg === "-y" || arg === "--yes") { flags.yes = true; continue; }
+    if (arg === "--start-over") { flags["start-over"] = true; continue; }
     if (arg === "--input" || arg === "-i") { flags.input = String(args[i + 1] ?? "").trim(); i += 1; continue; }
     if (arg.startsWith("--input=")) { flags.input = arg.slice("--input=".length).trim(); continue; }
     // ★--name 도 값을 하나 받는 플래그다. 걷어내지 않으면 그 값이 파일 경로에 붙어
@@ -1154,6 +1306,23 @@ async function run(ctx, args = []) {
     //   실제로는 한 번도 동작한 적이 없었다(실사용 실측 2026-08-06).
     if (arg === "--name" || arg === "-n") { flags.name = String(args[i + 1] ?? "").trim(); i += 1; continue; }
     if (arg.startsWith("--name=")) { flags.name = arg.slice("--name=".length).trim(); continue; }
+    // 재조정 판단 — 같은 깃발이 여러 번 올 수 있으므로 모아 둔다. 값을 함께 걷어내지
+    // 않으면 위 --name 사고와 똑같이 그래프 이름에 붙어 "맞는 그래프가 없다"가 된다.
+    {
+      const multi = { "--done": "done", "--not-done": "not-done", "--output": "output" };
+      let matched = false;
+      for (const [token, key] of Object.entries(multi)) {
+        if (arg === token) {
+          (flags[key] || (flags[key] = [])).push(String(args[i + 1] ?? "").trim());
+          i += 1; matched = true; break;
+        }
+        if (arg.startsWith(`${token}=`)) {
+          (flags[key] || (flags[key] = [])).push(arg.slice(token.length + 1).trim());
+          matched = true; break;
+        }
+      }
+      if (matched) continue;
+    }
     rest.push(arg);
   }
   const sub = (rest[0] || "list").toLowerCase();
@@ -1165,6 +1334,7 @@ async function run(ctx, args = []) {
     ctx.out(en ? "  list                      what is saved" : "  list                      저장된 것 목록");
     ctx.out(en ? "  show \"<name>\"             steps, wiring, and problems" : "  show \"<이름>\"             단계·배선·문제점");
     ctx.out(en ? "  run \"<name>\" [--input \"<value>\"]  run locally with the included Desktop Core" : "  run \"<이름>\" [--input \"<값>\"]   포함된 Desktop Core로 로컬 실행");
+    ctx.out(en ? "  reconcile \"<name>\"       decide what already happened, when a run stopped unsure" : "  reconcile \"<이름>\"        멈춘 실행에서 무엇이 이미 일어났는지 정하기");
     ctx.out(en ? "  export \"<name>\" [file]    write a shareable package file" : "  export \"<이름>\" [파일]     남에게 줄 수 있는 파일로 저장");
     ctx.out(en ? "  inspect <file>            read a package file before installing" : "  inspect <파일>            설치 전에 패키지 파일 확인");
     ctx.out(en ? "  install <file> [--name \"<new name>\"]  install a package file" : "  install <파일> [--name \"<새 이름>\"]  패키지 파일 설치");
@@ -1185,6 +1355,15 @@ async function run(ctx, args = []) {
     }
     return showGraph(ctx, target);
   }
+  if (sub === "reconcile") {
+    if (!target) {
+      ctx.err(en
+        ? "Usage: agentlas graph reconcile \"<name>\" [--done <node>] [--not-done <node>] [--output <node>=<value>]"
+        : "사용법: agentlas graph reconcile \"<이름>\" [--done <노드>] [--not-done <노드>] [--output <노드>=<값>]");
+      return 1;
+    }
+    return await reconcileGraph(ctx, target, flags, en);
+  }
   if (sub === "export") {
     if (!target) {
       ctx.err(en ? "Usage: agentlas graph export \"<name>\" [file]" : "사용법: agentlas graph export \"<이름>\" [파일]");

package/engine/core/desktop-core.cjs

@@ -231,8 +231,33 @@ function loadDesktopCore(options = {}) {
     initStore: req("store/db").initStore,
     getDb: req("store/db").getDb,
     runGraph: kernel.runGraph,
+    getAutomation: req("store/automations").getAutomation,
+    // shared/ 는 electron/ 밖이라 req 로 못 닿는다 — 직접 해석한다.
+    graphExecutionDigest: (() => {
+      try { return require(path.join(root, "shared", "graph-execution-digest.js")).graphExecutionDigest; }
+      catch { return null; }
+    })(),
     graphFailureOf: kernel.graphFailureOf,
     planGraphLoops: kernel.planGraphLoops,
+    /*
+     * ★내는 오류가 있으면 푸는 길도 함께 준다. 실측 2026-08-20: 커널은
+     *   `automation_partial_reconciliation_required` 를 내는데, 그것을 푸는 모듈은
+     *   벤더에 실리지도 않았고 여기 표면에도 없었다 — CLI 만 쓰는 사람은 그 자동화를
+     *   영원히 못 돌린다. 옛 코어를 쓰는 동안에는 없을 수 있으므로 정직하게 null 로 둔다.
+     */
+    graphReconciliation: (() => {
+      try {
+        const mod = req("store/graph-reconciliation");
+        if (typeof mod.getAutomationGraphReconciliation !== "function") return null;
+        return {
+          get: mod.getAutomationGraphReconciliation,
+          apply: mod.reconcileAutomationGraph,
+          forgetStale: mod.forgetStaleGraphCheckpoint,
+        };
+      } catch {
+        return null;
+      }
+    })(),
   };
   return _cache;
 }

package/engine/vendor/desktop-core.manifest.json

@@ -1,7 +1,7 @@
 {
-  "version": "8",
-  "url": "https://github.com/agentlas-ai/agentlas-terminal/releases/download/desktop-core-v8/desktop-core.tar.gz",
-  "sha256": "035dab73fb904fe395074b2f75c238b7c65360f454e31e4ac840fbf6baa89afd",
-  "sizeBytes": 12544238,
-  "writtenAt": "2026-08-19T20:34:43.158Z"
+  "version": "10",
+  "url": "https://github.com/agentlas-ai/agentlas-terminal/releases/download/desktop-core-v10/desktop-core.tar.gz",
+  "sha256": "24276f065bdef65089f315b990f3573d88d5b47df650cb0deb023d979ecbcf95",
+  "sizeBytes": 12556818,
+  "writtenAt": "2026-08-19T21:31:43.680Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlas",
-  "version": "1.0.55",
+  "version": "1.0.58",
   "description": "Agentlas project terminal — run project controllers and task-scoped agent teams from the terminal. Standalone: no desktop app process required.",
   "bin": {
     "agentlas": "bin/agentlas.cjs"
@@ -13,7 +13,8 @@
     "vendor:core": "node scripts/vendor-desktop-core.cjs",
     "test:tool-access-notice-parity": "node test/tool-access-notice-parity.cjs",
     "verify:engine-reachable": "node scripts/verify-engine-reachable.cjs",
-    "prepublishOnly": "npm run verify:engine-reachable"
+    "prepublishOnly": "npm run verify:engine-reachable && npm run verify:way-out",
+    "verify:way-out": "node scripts/verify-raised-errors-have-a-way-out.cjs"
   },
   "engines": {
     "node": ">=20.19"