agentlas 1.0.11 → 1.0.14

package/engine/agentlas-workload-routing.cjs

@@ -17,7 +17,15 @@ const SCHEMA_VERSION = 1;
 const ALLOCATION_SCHEMA = "agentlas.workload-allocation.v1";
 const TIERS = Object.freeze(["economy", "balanced", "frontier"]);
 const TIER_RANK = Object.freeze({ economy: 0, balanced: 1, frontier: 2 });
+// 알려진 값은 랭크 폴백으로만 쓴다 — "유효한가" 게이트로 쓰지 않는다. 2026-07-28 라이브
+// 실측: codex의 모델 카탈로그가 프론티어 모델 하나에서 "ultra"(자동 위임) 리즌
+// 레벨을 광고했는데, normalizeEffort가 이 튜플로 게이트를 걸면 parent-AI의 할당
+// 결정 전체가 통째로 null(무효) 처리된다. 새 값이 나올 때마다 이 튜플을 고치지
+// 않고, resolveEffort가 모델 자체 목록의 순서(=능력 랭크, provider 계약)를
+// 신뢰하도록 뒤집었다. (구체적 모델 id는 이 파일에 절대 하드코딩하지 않는다 —
+// 아래 doesNotMatch 계약 테스트 참고.)
 const EFFORTS = Object.freeze(["none", "minimal", "low", "medium", "high", "xhigh", "max"]);
+const EFFORT_TOKEN_RE = /^[a-z][a-z0-9-]{0,23}$/;
 const CAPABILITIES = new Set(["code", "image", "tools", "long-context"]);
 const PHASES = new Set(["plan", "delegate", "synthesize"]);
 
@@ -31,8 +39,9 @@ function normalizeTier(value) {
 }
 
 function normalizeEffort(value) {
+  // 신택스만 검증한다 — 화이트리스트 존재는 게이트로 쓰지 않는다(위 EFFORTS 주석).
   const v = String(value || "").toLowerCase().trim();
-  return EFFORTS.includes(v) ? v : null;
+  return EFFORT_TOKEN_RE.test(v) ? v : null;
 }
 
 function normalizeCapabilities(value) {
@@ -251,10 +260,29 @@ function resolveEffort(provider, requested, supported = []) {
     const available = Array.isArray(supported) ? supported : [];
     if (!available.length) return null;
     if (available.includes(requested)) return requested;
-    const requestedRank = EFFORTS.indexOf(requested);
+    // 이 모델이 정확히 그 값을 광고하지 않을 때만 여기로 온다. 랭크는 모델 자체
+    // 목록의 순서(=능력 랭크, provider 계약)를 최우선으로 쓰고, 알려진 7단계
+    // 표는 순서 정보가 없는 값의 폴백일 뿐이다 — 화이트리스트 게이트가 아니다.
+    // 미광고 known 값은 available 안에서 known-rank가 자기 이하인 마지막 항목
+    // 바로 뒤(소수 위치)에 끼워 넣는다 — 무조건 "목록 끝"으로 밀면 사실 available의
+    // 상위 항목들보다 낮은 값(예: low/xhigh/max만 있을 때의 "medium")이 전부 통과돼
+    // 요청보다 위로 에스컬레이션된다. 표에도 없는 완전 미지의 값만 +Infinity.
+    const rank = (value) => {
+      const own = available.indexOf(value);
+      if (own !== -1) return own;
+      const known = EFFORTS.indexOf(value);
+      if (known === -1) return Infinity;
+      let insertAfter = -1;
+      available.forEach((item, index) => {
+        const itemKnown = EFFORTS.indexOf(item);
+        if (itemKnown !== -1 && itemKnown <= known) insertAfter = index;
+      });
+      return insertAfter + 0.5;
+    };
+    const requestedRank = rank(requested);
     const lower = available
-      .filter((item) => EFFORTS.indexOf(item) <= requestedRank)
-      .sort((a, b) => EFFORTS.indexOf(b) - EFFORTS.indexOf(a))[0];
+      .filter((item) => rank(item) <= requestedRank)
+      .sort((a, b) => rank(b) - rank(a))[0];
     return lower || available[0] || null;
   }
   return null;
@@ -397,10 +425,32 @@ function resolveAllocationAcrossRuntimes(options = {}) {
   return { ...resolution, runtime, runtimeId, requestedRuntimeId: requestedId || null };
 }
 
-function createDecisionReceipt({ taskId, stage, decision, resolution }) {
+function modelRoleForStage(stage) {
+  return ["plan", "planner", "leader", "verify", "verifier", "synthesize", "synthesis", "route", "clarify"]
+    .includes(cleanText(stage, 80).toLowerCase())
+    ? "orchestrator"
+    : "worker";
+}
+
+function normalizeObservedUsage(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const inputTokens = value.inputTokens;
+  const outputTokens = value.outputTokens;
+  return Number.isInteger(inputTokens) && inputTokens >= 0
+    && Number.isInteger(outputTokens) && outputTokens >= 0
+    ? { inputTokens, outputTokens }
+    : null;
+}
+
+function createDecisionReceipt({ taskId, stage, decision, resolution, role, usage }) {
   const normalized = normalizeAllocation(decision);
   const validationIssues = [];
-  if (!normalized) validationIssues.push("invalid-ai-allocation");
+  const decisionProvided = decision != null;
+  if (!decisionProvided) validationIssues.push("allocation_not_provided");
+  else if (!normalized) validationIssues.push("invalid_ai_allocation");
+  const resolvedRole = role === "worker" || role === "orchestrator"
+    ? role
+    : modelRoleForStage(stage);
   const resolutionCodes = cleanText(resolution && resolution.fallbackReason, 500)
     .split(",")
     .map((code) => cleanText(code, 120))
@@ -411,12 +461,13 @@ function createDecisionReceipt({ taskId, stage, decision, resolution }) {
   ])].slice(0, 32);
   const featurePayload = JSON.stringify(normalized ? {
     phase: normalized.phase,
+    role: resolvedRole,
     tier: normalized.tier,
     effort: normalized.effort,
     reasonCodes: normalized.reasonCodes,
     requiredCapabilities: normalized.requiredCapabilities,
     estimatedContextTokens: normalized.estimatedContextTokens,
-  } : { phase: cleanText(stage, 80) || null, allocation: null });
+  } : { phase: cleanText(stage, 80) || null, role: resolvedRole, allocation: null });
   const featureHash = `sha256:${crypto.createHash("sha256").update(featurePayload, "utf8").digest("hex")}`;
   const source = resolution && resolution.source;
   const hasResolvedCurrent = Boolean(
@@ -439,6 +490,7 @@ function createDecisionReceipt({ taskId, stage, decision, resolution }) {
       ? normalized.decisionId
       : `terminal:model-allocation:${featureHash.slice("sha256:".length, "sha256:".length + 24)}`,
     packetId: cleanText(taskId, 255) || null,
+    role: resolvedRole,
     status,
     requested: {
       tier: normalized ? normalized.tier : null,
@@ -460,6 +512,7 @@ function createDecisionReceipt({ taskId, stage, decision, resolution }) {
     selectorVersion: normalized ? normalized.selectorVersion : "deterministic-host-fallback",
     independentVerificationRequired:
       riskCodes.has("high-risk") || riskCodes.has("critical-risk") || riskCodes.has("independent-verification"),
+    usage: normalizeObservedUsage(usage),
     validationIssues,
     privacy: { rawPromptIncluded: false, rawTranscriptIncluded: false },
   };
@@ -522,6 +575,7 @@ module.exports = {
   resolveAllocation,
   resolveAllocationAcrossRuntimes,
   createDecisionReceipt,
+  modelRoleForStage,
   appendDecisionReceipt,
   defaultReceiptPath,
   plannerSystemPrompt,

package/engine/agentlas.cjs

@@ -102,6 +102,14 @@ function nearestCommands(token, names) {
 
 function main() {
   const argv = process.argv.slice(2);
+  const helpRequested = argv.some((arg) => arg === "--help" || arg === "-h");
+  const helpCommand = argv.find((arg) => arg !== "--help" && arg !== "-h" && !arg.startsWith("-"));
+  if (helpRequested && helpCommand) {
+    const ctx = buildCtx();
+    const command = commands.resolveCommandName(helpCommand);
+    const code = require("./commands/help.cjs").runForCommand(ctx, command);
+    process.exit(typeof code === "number" ? code : 0);
+  }
   // 옵션 정규화: -h/--help/-V/--version 은 하위 명령으로 변환
   const normalized = argv.map((a) => {
     if (a === "--help" || a === "-h") return "help";

package/engine/automation/daemon.cjs

@@ -111,6 +111,41 @@ function resolveTargetAgent(db, row) {
   return bySlug;
 }
 
+/**
+ * 이 터미널이 실행할 수 없는 계열 판정 — 실행 게이트와 due 셀렉션의 유일한 정본.
+ * store.runnerUnsupportedSql 의 SQL 술어와 반드시 같은 조건을 본다(갈리면 굶주림이
+ * 되돌아온다: 셀렉션이 담은 행을 실행기가 거부하면 그 행이 due 창을 영구 점유한다).
+ *
+ * Hub 타깃: 데스크탑은 정확 릴리스 핀 + Hub 런타임으로 실행한다
+ * (automation-scheduler.ts:573-630 hub_version_pin 게이트) — 터미널에는 그 실행
+ * 계층이 없으므로 위장 실행 금지, 정직 스킵.
+ * tool_mode 'browser'/'computer-use': 데스크탑은 Agentlas Browser/컴퓨터유즈 러너를
+ * 배선하고 권한 프리플라이트까지 건다(automation-scheduler.ts:619-625). 터미널
+ * 세션 계층에는 그 러너가 없다 — 평문 세션으로 돌리는 조용한 다운그레이드 대신
+ * 정직 스킵으로 Desktop 실행분(회차)을 그대로 남겨 둔다.
+ * @returns {{reason:string, message:string}|null}
+ */
+function runnerSkip(db, row, ko) {
+  if (row.target_type === "hub") {
+    return {
+      reason: "hub-target-unsupported",
+      message: ko
+        ? `Hub 타깃 자동화는 터미널 데몬이 실행하지 않습니다(정확 릴리스 핀 실행은 Desktop 스케줄러 몫): ${row.name}`
+        : `Hub-target automations are not run by the terminal daemon (exact-release Hub execution belongs to the Desktop scheduler): ${row.name}`,
+    };
+  }
+  const rowToolMode = columnExists(db, "automations", "tool_mode") ? row.tool_mode : null;
+  if (rowToolMode === "browser" || rowToolMode === "computer-use") {
+    return {
+      reason: "tool-mode-unsupported",
+      message: ko
+        ? `tool_mode '${rowToolMode}' 자동화는 터미널 데몬이 실행하지 않습니다(브라우저/컴퓨터유즈 러너는 Desktop 몫): ${row.name}`
+        : `tool_mode '${rowToolMode}' automations are not run by the terminal daemon (the browser/computer-use runner belongs to Desktop): ${row.name}`,
+    };
+  }
+  return null;
+}
+
 /**
  * 자동화 1건 실행(헤드리스). 권한은 자동화 행의 permission 열(있으면), 없으면 "write".
  * opts:
@@ -131,26 +166,10 @@ async function runAutomationOnce(ctx, db, row, opts = {}) {
     return { ok: false, skipped: true, reason: "disabled" };
   }
   // ── 터미널이 충실히 실행할 수 없는 계열은 리스를 잡지 않고 스킵한다 ──
-  // 리스/스케줄을 소비하면 데스크탑 스케줄러가 그 회차를 영영 실행하지 못한다.
-  // Hub 타깃: 데스크탑은 정확 릴리스 핀 + Hub 런타임으로 실행한다
-  // (automation-scheduler.ts:573-630 hub_version_pin 게이트) — 터미널에는 그
-  // 실행 계층이 없으므로 위장 실행 금지, 정직 스킵.
-  if (row.target_type === "hub") {
-    ctx.err(ko
-      ? `Hub 타깃 자동화는 터미널 데몬이 실행하지 않습니다(정확 릴리스 핀 실행은 Desktop 스케줄러 몫): ${row.name}`
-      : `Hub-target automations are not run by the terminal daemon (exact-release Hub execution belongs to the Desktop scheduler): ${row.name}`);
-    return { ok: false, skipped: true, reason: "hub-target-unsupported" };
-  }
-  // tool_mode 'browser'/'computer-use': 데스크탑은 Agentlas Browser/컴퓨터유즈
-  // 러너를 배선하고 권한 프리플라이트까지 건다(automation-scheduler.ts:619-625).
-  // 터미널 세션 계층에는 그 러너가 없다 — 평문 세션으로 돌리는 조용한 다운그레이드
-  // (위장 실행) 대신 정직 스킵으로 Desktop 실행분을 남겨 둔다.
-  const rowToolMode = columnExists(db, "automations", "tool_mode") ? row.tool_mode : null;
-  if (rowToolMode === "browser" || rowToolMode === "computer-use") {
-    ctx.err(ko
-      ? `tool_mode '${rowToolMode}' 자동화는 터미널 데몬이 실행하지 않습니다(브라우저/컴퓨터유즈 러너는 Desktop 몫): ${row.name}`
-      : `tool_mode '${rowToolMode}' automations are not run by the terminal daemon (the browser/computer-use runner belongs to Desktop): ${row.name}`);
-    return { ok: false, skipped: true, reason: "tool-mode-unsupported" };
+  const unsupported = runnerSkip(db, row, ko);
+  if (unsupported) {
+    ctx.err(unsupported.message);
+    return { ok: false, skipped: true, reason: unsupported.reason };
   }
   if (!store.leaseSupported(db)) {
     // 리스 열이 없는 DB에서는 Desktop 과의 배타성을 증명할 수 없다 — fail-closed.
@@ -167,6 +186,14 @@ async function runAutomationOnce(ctx, db, row, opts = {}) {
     return { ok: false, skipped: true, reason: "lease" };
   }
 
+  // 데스크탑 스케줄러는 60초마다 리스를 갱신한다. 여기는 한 번 잡고 끝이라
+  // TTL(15분)을 넘긴 실행은 프로세스가 살아 있어도 회수 대상이 됐다 — 같은
+  // 자동화가 두 실행기에서 겹쳐 도는 경로. 같은 주기로 심장박동을 보낸다.
+  const leaseHeartbeat = setInterval(() => {
+    try { store.renewAutomationLease(db, row.id); } catch { /* best-effort */ }
+  }, 60_000);
+  if (typeof leaseHeartbeat.unref === "function") leaseHeartbeat.unref();
+
   try {
     // ── raw-row 실행 계약 게이트 (데스크탑 automation-scheduler.ts:538-549 동형) ──
     // 손상된 계약 값으로는 무인 실행하지 않는다 — 문구까지 데스크탑과 동일.
@@ -246,6 +273,7 @@ async function runAutomationOnce(ctx, db, row, opts = {}) {
     store.advanceAfterRun(db, row, { ok: false, advanceSchedule: !!opts.advanceSchedule });
     return { ok: false, error: msg };
   } finally {
+    clearInterval(leaseHeartbeat);
     store.releaseAutomation(db, row.id);
   }
 }
@@ -259,17 +287,31 @@ async function daemonTick(ctx, db, opts = {}) {
   const nowIso = (opts.now || new Date()).toISOString();
   let due = [];
   try {
-    due = store.dueAutomations(db, nowIso, 5);
+    // 실행 창은 "이 실행기가 실제로 실행할 수 있는" 행만 담는다 (runnable: true).
+    // 미지원 계열/남의 리스 행은 스킵돼도 next_run_at 이 전진하지 않으므로, 창에
+    // 담으면 시간순 LIMIT 5 의 머리를 영구 점유해 뒤의 자동화를 전부 굶긴다.
+    due = store.dueAutomations(db, nowIso, 5, { runnable: true });
   } catch (e) {
     ctx.err("Failed to query due automations: " + String((e && e.message) || e));
     return 0;
   }
+  // 미지원 계열은 실행 창에서 빠졌어도 존재 사실은 정직하게 알린다 — Desktop 몫으로
+  // 남겨둔 회차이므로 틱마다 반복하지 않고 데몬 수명당 1회만 고지한다.
+  if (opts.skipAnnounced) {
+    let deferred = [];
+    // 고지 상한 50 — 실행 창(5)과 달리 이 목록은 실행에 쓰이지 않으므로 넉넉해도 안전하다.
+    try { deferred = store.dueAutomations(db, nowIso, 50, { runnable: false }); } catch { /* best-effort */ }
+    for (const row of deferred) {
+      if (opts.skipAnnounced.has(row.id)) continue;
+      const skip = runnerSkip(db, row, ctx.lang === "ko");
+      if (!skip) continue;
+      ctx.err(skip.message);
+      opts.skipAnnounced.add(row.id);
+    }
+  }
   let ran = 0;
   for (const row of due) {
     if (opts.shouldStop && opts.shouldStop()) break;
-    // 터미널 미지원 계열(hub 타깃/browser/computer-use)은 due 로 계속 남는다 —
-    // Desktop 몫으로 남겨둔 것이므로 틱마다 같은 안내를 반복하지 않는다.
-    if (opts.skipAnnounced && opts.skipAnnounced.has(row.id)) continue;
     ran += 1;
     const result = await runAutomationOnce(ctx, db, row, {
       advanceSchedule: true,
@@ -279,12 +321,15 @@ async function daemonTick(ctx, db, opts = {}) {
       spawnImpl: opts.spawnImpl,
       timeoutConfig: opts.timeoutConfig,
     });
-    if (
-      opts.skipAnnounced && result && result.skipped &&
-      (result.reason === "hub-target-unsupported" || result.reason === "tool-mode-unsupported")
-    ) {
-      opts.skipAnnounced.add(row.id);
-      continue; // 스케줄/1회성 비활성화도 건드리지 않는다 — Desktop 이 실행해야 할 회차다.
+    // 스킵은 회차를 소비하지 않는다 — 1회성 비활성화조차 건드리지 않는다.
+    // (미지원 계열은 Desktop 몫이고, lease 스킵은 지금 남이 돌리는 회차다. 셀렉션과
+    //  실행 사이의 리스 레이스로 스킵된 1회성 행을 여기서 꺼 버리면 그 실행은 영영 사라진다.)
+    if (result && result.skipped) {
+      if (
+        opts.skipAnnounced &&
+        (result.reason === "hub-target-unsupported" || result.reason === "tool-mode-unsupported")
+      ) opts.skipAnnounced.add(row.id);
+      continue;
     }
     // 스케줄이 없는(1회성) 행이 남으면 재발화 방지 (v1과 동일).
     if (!row.schedule || !schedule.nextAutomationRun(row)) {
@@ -331,5 +376,6 @@ module.exports = {
   resolveTargetAgent,
   automationContractState,
   automationSessionChatId,
+  runnerSkip,
   decodeRuntimeSelection,
 };

package/engine/automation/schedule.cjs

@@ -102,6 +102,21 @@ function nextCronRun(cron, from = new Date(), timezone = null) {
   return null;
 }
 
+/**
+ * IANA 타임존으로 해석 가능한지만 본다(빈 값 = 로컬존이므로 유효).
+ * nextCronRun 은 cron 파싱 실패와 잘못된 존을 똑같이 null 로 접어버리므로,
+ * 호출부가 "어느 필드가 틀렸는지"를 구분하려면 이 검사가 따로 필요하다.
+ */
+function isValidTimezone(timezone) {
+  if (!timezone) return true;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: String(timezone) });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function localTimezone() {
   try { return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC"; } catch { return "UTC"; }
 }
@@ -175,6 +190,7 @@ module.exports = {
   cronField,
   zonedDateParts,
   nextCronRun,
+  isValidTimezone,
   localTimezone,
   legacyScheduleSpec,
   nextAutomationRun,

package/engine/automation/store.cjs

@@ -105,6 +105,27 @@ function claimAutomation(db, id, now = new Date(), owner = LEASE_OWNER) {
   return (result.changes ?? result.rowsAffected ?? 0) > 0;
 }
 
+/**
+ * 이 프로세스가 아직 들고 있는 리스의 claimed_at 을 현재로 민다.
+ *
+ * claimAutomation 은 한 번만 부르고 갱신이 없었다. 데스크탑 스케줄러는 60초마다
+ * 갱신하므로, TTL(15분)을 넘긴 CLI 실행은 프로세스가 멀쩡히 살아 있는데도
+ * 회수 대상이 된다 — 에이전트 세션에서 15분은 평범하고, 그러면 같은 자동화가
+ * 두 실행기에서 겹쳐 돈다. 소유자가 나일 때만 갱신하므로, 이미 남에게 넘어간
+ * 리스를 되빼앗지는 않는다.
+ */
+function renewAutomationLease(db, id, now = new Date(), owner = LEASE_OWNER) {
+  if (!leaseSupported(db)) return false;
+  try {
+    const result = db
+      .prepare("UPDATE automations SET claimed_at = ? WHERE id = ? AND lease_owner = ?")
+      .run(now.toISOString(), id, owner);
+    return (result.changes ?? result.rowsAffected ?? 0) > 0;
+  } catch {
+    return false;
+  }
+}
+
 function releaseAutomation(db, id) {
   try {
     db.prepare("UPDATE automations SET claimed_at = NULL, lease_owner = NULL WHERE id = ?").run(id);
@@ -142,11 +163,28 @@ function listRuns(db, limit = 15) {
   ).all(Math.max(1, limit));
 }
 
+/**
+ * 다음 회차가 없어 자동화를 끝낼 때만 쓰는 단방향(끄기 전용) write.
+ *
+ * advanceAfterRun 은 실행 시작 시점의 row 스냅샷을 들고 있는데, 그 사이 사용자가
+ * 다른 터미널이나 Desktop 토글로 `automation off` 를 할 수 있다(에이전트 실행은
+ * 수 분~수십 분). 스냅샷의 enabled 를 되쓰면 그 끄기가 조용히 되돌아가고
+ * ("Disabled: … morning" 을 보고 exit 0 인데도) 다음 예정 시각에 또 발화한다.
+ * 그래서 enabled 는 "켜기"로는 절대 쓰지 않고, 종료 조건일 때만 0 으로 내린다.
+ */
+function disableExhausted(db, id) {
+  db.prepare("UPDATE automations SET enabled = 0 WHERE id = ?").run(id);
+}
+
 /**
  * 실행 후 스케줄 북키핑 — v1 runAutomationOnce 의 성공/실패 분기와 동일:
  *  - 성공: run_count 증가. 실패: last_run_at 만 갱신(성공 카운트 오염 금지).
  *  - advanceSchedule(데몬 경로)일 때만 next_run_at 전진; 다음 시각이 없으면 비활성화.
  *  - run-now(advanceSchedule=false)는 스케줄을 건드리지 않는다(앱 advanceSchedule=false와 동일).
+ *
+ * enabled 는 여기서 스냅샷 값으로 되쓰지 않는다 — disableExhausted 주석 참조.
+ * (같은 이유로 성공/실패 두 분기 모두 같은 규칙을 따라야 한다: 한쪽만 고치면
+ *  실패로 끝난 실행이 여전히 끈 자동화를 부활시킨다.)
  */
 function advanceAfterRun(db, row, { ok, advanceSchedule, ranAt = new Date() } = {}) {
   const hasRunCount = columnExists(db, "automations", "run_count");
@@ -156,12 +194,13 @@ function advanceAfterRun(db, row, { ok, advanceSchedule, ranAt = new Date() } =
     if (shouldAdvance) {
       if (hasRunCount) {
         db.prepare(
-          "UPDATE automations SET last_run_at = ?, run_count = run_count + 1, next_run_at = ?, enabled = ? WHERE id = ?",
-        ).run(ranAt.toISOString(), advance ? advance.toISOString() : null, advance ? row.enabled : 0, row.id);
+          "UPDATE automations SET last_run_at = ?, run_count = run_count + 1, next_run_at = ? WHERE id = ?",
+        ).run(ranAt.toISOString(), advance ? advance.toISOString() : null, row.id);
       } else {
-        db.prepare("UPDATE automations SET last_run_at = ?, next_run_at = ?, enabled = ? WHERE id = ?")
-          .run(ranAt.toISOString(), advance ? advance.toISOString() : null, advance ? row.enabled : 0, row.id);
+        db.prepare("UPDATE automations SET last_run_at = ?, next_run_at = ? WHERE id = ?")
+          .run(ranAt.toISOString(), advance ? advance.toISOString() : null, row.id);
       }
+      if (!advance) disableExhausted(db, row.id);
     } else if (hasRunCount) {
       db.prepare("UPDATE automations SET last_run_at = ?, run_count = run_count + 1 WHERE id = ?")
         .run(ranAt.toISOString(), row.id);
@@ -170,25 +209,64 @@ function advanceAfterRun(db, row, { ok, advanceSchedule, ranAt = new Date() } =
     }
     // max_runs 도달 시 비활성화 (앱과 동일한 종료 조건).
     if (row.max_runs && (row.run_count || 0) + 1 >= row.max_runs) {
-      db.prepare("UPDATE automations SET enabled = 0 WHERE id = ?").run(row.id);
+      disableExhausted(db, row.id);
       return { advance, maxRunsReached: true };
     }
   } else if (shouldAdvance) {
-    db.prepare("UPDATE automations SET last_run_at = ?, next_run_at = ?, enabled = ? WHERE id = ?")
-      .run(ranAt.toISOString(), advance ? advance.toISOString() : null, advance ? row.enabled : 0, row.id);
+    db.prepare("UPDATE automations SET last_run_at = ?, next_run_at = ? WHERE id = ?")
+      .run(ranAt.toISOString(), advance ? advance.toISOString() : null, row.id);
+    if (!advance) disableExhausted(db, row.id);
   } else {
     db.prepare("UPDATE automations SET last_run_at = ? WHERE id = ?").run(ranAt.toISOString(), row.id);
   }
   return { advance, maxRunsReached: false };
 }
 
-/** 데몬 폴링: 활성 + 스케줄 트리거 + next_run_at 도래분. trigger_type 열은 방어적. */
-function dueAutomations(db, nowIso = new Date().toISOString(), limit = 5) {
+/**
+ * 이 실행기가 실행할 수 없는 계열의 SQL 술어 — daemon.runnerSkip 게이트와 짝이다.
+ * (hub 타깃 / tool_mode browser·computer-use = Desktop 몫.)
+ * IFNULL 필수: SQLite 3치 논리에서 NULL 열이 있으면 NOT (…) 이 NULL 이 되어
+ * 멀쩡한 행까지 조용히 사라진다.
+ */
+function runnerUnsupportedSql(db) {
+  const parts = ["IFNULL(target_type,'') = 'hub'"];
+  if (columnExists(db, "automations", "tool_mode")) {
+    parts.push("IFNULL(tool_mode,'') IN ('browser','computer-use')");
+  }
+  return `(${parts.join(" OR ")})`;
+}
+
+/**
+ * 데몬 폴링: 활성 + 스케줄 트리거 + next_run_at 도래분. trigger_type 열은 방어적.
+ *
+ * opts.runnable=true (데몬 실행 창): 이 실행기가 실행할 수 없는 행을 셀렉션에서 뺀다.
+ * 이유(굶주림 근본): 미지원 행(Desktop 몫)과 남이 리스를 쥔 행은 스킵돼도 next_run_at
+ * 이 전진하지 않는다 — 시간순 LIMIT n 창의 머리에 영구히 남아 뒤의 실행 가능한
+ * 자동화를 전부 굶긴다(데몬은 멀쩡해 보이고 아무것도 안 돈다). 실행 못 할 행은
+ * 애초에 창에 담지 않는 것이 유일한 근본 수리다 — 그 행의 회차는 그대로 보존된다.
+ * opts.runnable=false: 그 미지원 행만(고지용). 미지정: 예전 그대로 전체.
+ */
+function dueAutomations(db, nowIso = new Date().toISOString(), limit = 5, opts = {}) {
   if (!tableExists(db, "automations")) return [];
-  const triggerFilter = columnExists(db, "automations", "trigger_type") ? "AND trigger_type = 'schedule'" : "";
+  const where = ["enabled = 1"];
+  const params = [];
+  if (columnExists(db, "automations", "trigger_type")) where.push("trigger_type = 'schedule'");
+  where.push("next_run_at IS NOT NULL", "next_run_at <= ?");
+  params.push(nowIso);
+  if (opts.runnable === true) {
+    where.push(`NOT ${runnerUnsupportedSql(db)}`);
+    if (leaseSupported(db)) {
+      // 남이 유효 리스를 쥔 행은 claimAutomation 이 반드시 실패한다 — 같은 굶주림 경로.
+      where.push("(claimed_at IS NULL OR claimed_at < ?)");
+      params.push(new Date(Date.parse(nowIso) - LEASE_TTL_MS).toISOString());
+    }
+  } else if (opts.runnable === false) {
+    where.push(runnerUnsupportedSql(db));
+  }
+  params.push(limit);
   return db.prepare(
-    `SELECT * FROM automations WHERE enabled = 1 ${triggerFilter} AND next_run_at IS NOT NULL AND next_run_at <= ? ORDER BY next_run_at ASC LIMIT ?`,
-  ).all(nowIso, limit);
+    `SELECT * FROM automations WHERE ${where.join(" AND ")} ORDER BY next_run_at ASC LIMIT ?`,
+  ).all(...params);
 }
 
 module.exports = {
@@ -201,9 +279,11 @@ module.exports = {
   setEnabled,
   removeAutomation,
   claimAutomation,
+  renewAutomationLease,
   releaseAutomation,
   recordRun,
   listRuns,
   advanceAfterRun,
   dueAutomations,
+  runnerUnsupportedSql,
 };