agentlas 1.0.10 → 1.0.12

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Changelog
 
+## 1.0.12 — 2026-07-28
+
+- **Orchestrator/worker model roles now resolve from ordered candidate
+  pools.** The shared `model_role_members` table (Desktop schema v80) holds
+  n candidates per role in priority order; the terminal picks the first
+  member that is actually executable here, records every skipped member
+  with its reason, and never silently substitutes a lower-priority runtime
+  when all members are unavailable — the head member is used and the skip
+  list is preserved. An empty worker pool inherits the orchestrator pool,
+  matching the single-row inherit contract, and databases without pools
+  keep resolving through the v79 single-row and legacy `active_runtime`
+  ladders unchanged.
+- **Workforce escalation is bounded and receipted end to end.** A worker
+  that violates the handoff output contract twice — or is named in two
+  consecutive verifier failures — gets exactly one orchestrator-role
+  retry, stamped with `escalated-after-failure`, the failure count, and
+  the attempt number; a failing escalation stops honestly instead of
+  looping or downgrading.
+- **BYOK Anthropic calls mark the system prefix as a prompt-cache
+  breakpoint.** Real Anthropic endpoints receive the system prompt as one
+  `cache_control: ephemeral` block (~90% cheaper cached input on hits;
+  a silent no-op below the per-model minimum). Anthropic-compatible
+  endpoints (GLM/Kimi/DeepSeek) keep the plain string form they expect.
+- Model-allocation receipts split "no allocation was provided"
+  (`allocation_not_provided`) from "the allocation was malformed"
+  (`invalid_ai_allocation`), and real invocations now retain the
+  provider-reported token usage per role instead of discarding it.
+
+## 1.0.11 — 2026-07-27
+
+- **The slash palette repaints in place instead of stacking copies of
+  itself.** Every keystroke left the previous frame on screen, so a few
+  arrow presses filled the terminal with duplicate palettes and pushed the
+  prompt out of view. Two causes, both measured on an emulated terminal:
+  the frame was drawn with the cursor saved and restored by absolute
+  position, and the frame was 18 lines tall with no regard for the window.
+  In a REPL the prompt sits at the bottom of the screen, so drawing below
+  it always scrolls — and after a scroll the saved absolute row points at
+  different content, so the next repaint erased the wrong region and left
+  the old frame behind. The palette now returns to the prompt with a
+  relative cursor move, which survives scrolling, and never draws a frame
+  taller than the window: the list shrinks around the highlighted entry,
+  and the selection detail folds away before the list does, so the
+  highlighted row and the controls hint survive at any height. Verified at
+  14, 18, 24 and 50 rows — one palette on screen, prompt intact.
+- Quitting no longer announces a wait for commands that finish in
+  milliseconds; the notice now appears only after 400ms.
+
 ## 1.0.10 — 2026-07-27
 
 Four defects in the REPL's slash surface, all found by sweeping for the shape

package/engine/agentlas-input.cjs

@@ -509,31 +509,56 @@ function renderSlashPalette(rows, selectedIndex, opts = {}) {
   );
   const descWidth = Math.max(0, lineWidth - commandWidth - 1);
   const selected = rows[Math.max(0, Math.min(selectedIndex, rows.length - 1))] || rows[0];
-  const out = [
+  const head = [
     c.faint(truncateVisible(`${i18n.t(lang, "palette.title")}  ${i18n.t(lang, "palette.search")}`, lineWidth)),
     c.faint("─".repeat(lineWidth)),
   ];
-  rows.forEach((row, index) => {
-    const command = padVisible(truncateVisible(row.command, commandWidth), commandWidth);
-    const desc = truncateVisible(row.description, descWidth);
-    const body = " " + c.blue(command) + c.text(desc);
-    out.push(index === selectedIndex ? c.inverse(padVisible(body, lineWidth)) : body);
-  });
-  out.push(c.faint("─".repeat(lineWidth)));
+  /*
+   * 꼬리(구분선·선택 상세·조작 안내)를 먼저 만든다 — 목록만 예산에 맞춰 줄이고
+   * 머리와 꼬리는 어떤 높이에서도 지키기 위해서다.
+   */
+  const tail = [c.faint("─".repeat(lineWidth))];
+  const tailStart = tail.length; // 이 뒤는 자리가 모자라면 접는다 (상세 → 예시 순으로 버림)
+  const out = head;
   if (selected) {
     const usage = truncateVisible(selected.usage || selected.command, lineWidth - 2);
     const detail = truncateVisible(selected.detail || selected.description || "", lineWidth - 2);
     const category = selected.category ? i18n.t(lang, "palette.category", selected.category) : "";
     const categoryRoom = Math.max(0, lineWidth - visibleWidthLite(usage) - 3);
     const categoryText = categoryRoom > 0 ? truncateVisible(category, categoryRoom) : "";
-    out.push(" " + c.text(usage) + (categoryText ? c.dim("  " + categoryText) : ""));
-    if (detail) out.push(" " + c.dim(detail));
+    tail.push(" " + c.text(usage) + (categoryText ? c.dim("  " + categoryText) : ""));
+    if (detail) tail.push(" " + c.dim(detail));
     if (selected.examples && selected.examples.length) {
-      out.push(c.dim(truncateVisible(" " + i18n.t(lang, "palette.examples", selected.examples.slice(0, 2).join("  |  ")), lineWidth)));
+      tail.push(c.dim(truncateVisible(" " + i18n.t(lang, "palette.examples", selected.examples.slice(0, 2).join("  |  ")), lineWidth)));
     }
   }
-  out.push(c.dim(truncateVisible(" " + i18n.t(lang, "palette.controls"), lineWidth)));
-  return out.join("\n");
+  /*
+   * 화면 높이 예산. 터미널보다 긴 프레임을 쏟으면 그리는 도중 스크롤이 나고, 그 순간
+   * 오버레이가 제자리를 잃어 이전 프레임이 화면에 남는다(실측: 24행에서 18행짜리
+   * 프레임 → 블록이 겹겹이 쌓이고 프롬프트가 화면 밖으로 밀려남).
+   * 선택 항목이 잘려 나가지 않도록 강조 위치를 중심으로 창을 잡는다.
+   */
+  const controls = c.dim(truncateVisible(" " + i18n.t(lang, "palette.controls"), lineWidth));
+  const budget = Math.max(1, Math.floor(Number(opts.maxRows) || (rows.length + head.length + tail.length + 1)));
+  /*
+   * 자리가 모자라면 선택 상세부터 접는다. 목록 한 줄과 조작 안내는 마지막까지 지킨다 —
+   * 아무것도 못 고르는 팔레트나 나가는 법을 모르는 팔레트는 없느니만 못하다.
+   * 최소 프레임은 5줄(제목·구분선·목록 1줄·구분선·조작 안내)이며, 그보다 좁은 예산도 5줄이다.
+   */
+  while (tail.length > tailStart && budget - head.length - tail.length - 1 < 1) tail.pop();
+  const listBudget = Math.max(1, budget - head.length - tail.length - 1);
+  const start = Math.min(
+    Math.max(0, selectedIndex - listBudget + 1),
+    Math.max(0, rows.length - listBudget),
+  );
+  rows.slice(start, start + listBudget).forEach((row, offset) => {
+    const index = start + offset;
+    const command = padVisible(truncateVisible(row.command, commandWidth), commandWidth);
+    const desc = truncateVisible(row.description, descWidth);
+    const body = " " + c.blue(command) + c.text(desc);
+    out.push(index === selectedIndex ? c.inverse(padVisible(body, lineWidth)) : body);
+  });
+  return out.concat(tail, [controls]).join("\n");
 }
 
 function attachSlashPalette(rl, opts = {}) {
@@ -557,6 +582,7 @@ function attachSlashPalette(rl, opts = {}) {
     selected: 0,
     selectedCommand: null,
     visible: false,
+    navigated: false,
     dismissedForLine: null,
   };
 
@@ -571,12 +597,43 @@ function attachSlashPalette(rl, opts = {}) {
     return rows().length > 0 && state.dismissedForLine !== (rl.line || "");
   }
   function replaceLine(value) {
+    const next = String(value || "");
+    /*
+     * keypress 리스너 안에서 rl.write(Ctrl-U) → rl.write(text)를 재진입시키면
+     * Node readline의 원래 Tab/Enter 핸들러가 아직 같은 키를 처리하는 중이라
+     * 기존 `/s` 뒤에 선택값을 붙였다(`/s/team`, `/s/skills` 실측). line/cursor는
+     * readline의 공개 관측 상태이고 `_refreshLine`은 그 상태를 그리는 유일한
+     * 부수효과라, 한 번에 교체해 재진입을 피한다. 구형 Node만 기존 키 시퀀스로
+     * 폴백한다.
+     */
+    if (typeof rl._refreshLine === "function") {
+      rl.line = next;
+      rl.cursor = next.length;
+      rl._refreshLine();
+      return;
+    }
     rl.write(null, { ctrl: true, name: "u" });
-    rl.write(value);
+    rl.write(next);
+  }
+  /*
+   * 커서 복원은 상대 이동으로만 한다.
+   *
+   * 예전 구현은 DECSC/DECRC(`\x1b7`/`\x1b8`)로 절대 위치를 저장·복원했다. 그런데 REPL은
+   * 프롬프트가 화면 맨 아래에 있는 게 보통이라, 그 아래로 프레임을 그리면 반드시 스크롤이
+   * 난다. 스크롤 뒤 저장된 절대 행은 다른 내용을 가리키므로 복원이 어긋나고, 다음 렌더의
+   * "커서 아래 전부 지우기"가 이전 프레임을 못 지운다 — 화면에 팔레트가 겹겹이 쌓였다.
+   * (pyte 에뮬레이션 실측: 24행에서 ↓ 3회 → 잔상 블록 + 프롬프트 유실.)
+   * `\x1b[nA` 같은 상대 이동은 내용과 함께 밀리므로 스크롤이 나도 어긋나지 않는다.
+   */
+  function promptColumn() {
+    const prompt = typeof rl.getPrompt === "function" ? rl.getPrompt() : "";
+    const typed = String(rl.line || "").slice(0, rl.cursor);
+    return visibleWidthLite(String(prompt)) + visibleWidthLite(typed) + 1;
   }
   function clear() {
     if (!state.visible) return;
-    stream.write("\x1b7\x1b[E\x1b[0J\x1b8");
+    // 그린 뒤에는 프롬프트 아래에 자리가 있으므로 커서 아래로 이동은 스크롤을 만들지 않는다.
+    stream.write(`\x1b[1B\r\x1b[0J\x1b[1A\x1b[${promptColumn()}G`);
     state.visible = false;
   }
   function render() {
@@ -596,10 +653,27 @@ function attachSlashPalette(rl, opts = {}) {
     if (state.selected < 0 || state.selected >= list.length) state.selected = 0;
     const body = renderSlashPalette(list, state.selected, {
       columns: stream.columns || process.stdout.columns || 88,
+      // 프롬프트 줄과 여유 한 줄을 남긴다 — 프레임이 화면을 다 먹으면 제자리 갱신이 불가능하다.
+      maxRows: Math.max(5, (stream.rows || process.stdout.rows || 24) - 2),
       colors,
       lang: opts.lang || (opts.ui && opts.ui.lang) || "en",
     });
-    stream.write("\x1b7\x1b[E\x1b[0J" + body + "\x1b8");
+    if (!body) { clear(); return; }
+    const lines = body.split("\n");
+    /*
+     * 첫 줄바꿈은 프롬프트 아래로 내려가며, 자리가 없으면 여기서 화면이 한 번 밀린다.
+     * 그린 만큼 그대로 되올라오므로 이후 갱신은 제자리에서 일어난다.
+     *
+     * 복귀 후에는 커서 열만 맞춘다. readline 의 prompt(true) 로 프롬프트 줄을 다시
+     * 그리면 refreshLine 이 커서 아래를 지워 방금 그린 프레임까지 함께 날아간다
+     * (실측: 리사이즈 없이도 팔레트가 통째로 사라짐). 프롬프트 줄 자체는 지운 적이
+     * 없으므로 평상시에는 화면에 그대로 남아 있다.
+     *
+     * 남은 한계: 창 크기를 줄이면 터미널이 프롬프트 줄을 리플로우하며 지울 수 있고,
+     * 그때는 다음 입력 전까지 프롬프트가 보이지 않는다(40행→18행 축소에서 실측).
+     * 팔레트는 리사이즈를 구독하지 않는다.
+     */
+    stream.write(`\r\n\x1b[0J${lines.join("\r\n")}\x1b[${lines.length}A\x1b[${promptColumn()}G`);
     state.visible = true;
   }
   /*
@@ -620,6 +694,7 @@ function attachSlashPalette(rl, opts = {}) {
     if (!list.length) return false;
     state.selected = (state.selected + delta + list.length) % list.length;
     state.selectedCommand = list[state.selected].command;
+    state.navigated = true;
     const query = rl.line || "";
     setImmediate(() => {
       if ((rl.line || "") !== query) replaceLine(query);
@@ -648,12 +723,38 @@ function attachSlashPalette(rl, opts = {}) {
       move(name === "down" ? 1 : -1);
       return;
     }
-    // Shift-Tab 은 팔레트 확정 키가 아니다 — 호출자(REPL)의 권한 순환 단축키다.
-    // 여기서 select() 하면 한 번의 Shift-Tab 이 줄 내용까지 바꿔 버린다.
-    if (active() && ((name === "tab" && !key.shift) || name === "return")) {
-      select();
+    // Tab 은 완성이다 — 강조된 항목으로 줄을 채운다.
+    // Shift-Tab 은 팔레트 확정 키가 아니다(호출자 REPL 의 권한 순환 단축키다).
+    if (active() && name === "tab" && !key.shift) {
+      if (select()) {
+        /*
+         * prependListener는 readline 자체 Tab 처리를 중단시키지 못한다. 선택을 먼저
+         * 반영한 뒤, 기본 완성기가 같은 키로 줄을 다시 바꿔도 다음 tick에 exact
+         * 선택을 한 번 재적용한다.
+         */
+        const selected = state.selectedCommand;
+        setImmediate(() => {
+          if (selected) replaceLine(selected);
+        });
+      }
+      return;
+    }
+    /*
+     * Enter 는 사용자가 실제로 목록을 훑었을 때만 강조 항목을 확정한다.
+     *
+     * 예전에는 팔레트가 떠 있기만 하면 Enter 가 무조건 select() 를 불렀고,
+     * 훑은 적이 없으면 state.selected 는 0이라 "목록 첫 줄"이 대신 실행됐다.
+     * `/s`(활성 세션 전환)를 치고 Enter 하면 `/sessions` 가 돌아간다 — 친 것과
+     * 다른 명령이 실행되는 것이다(pty 실측). 게다가 피해 대상은 팔레트 정렬의
+     * 함수라, 명령 목록을 손볼 때마다 어떤 명령이 가로채이는지가 조용히 바뀐다.
+     */
+    if (active() && name === "return") {
+      if (state.navigated) select();
+      else clear();
       return;
     }
+    // 타이핑이 이어지면 "훑었다"는 사실은 무효가 된다 — 질의가 달라졌기 때문.
+    state.navigated = false;
     state.dismissedForLine = null;
     setImmediate(render);
   }