elanous 0.2.31 → 0.2.34

package/src/context-bus/ops-events.ts

@@ -1,6 +1,7 @@
 import type { Database } from 'bun:sqlite';
 import { debug, redactSecretText } from '../debug/log.js';
 import { openSurfaceEventsDb, recordEvent, surfaceEventsDbPath } from '../domains/surface-events.js';
+import { canonicalSeatId } from '../msg/msg-store.js';
 
 export const OPS_EVENT_KINDS = [
   'land.start', 'land.refused', 'land.merged',
@@ -17,6 +18,8 @@ export interface OpsEventInput {
   text: string;
   /** Optional locator — PR number, checklist cell id, config key, release version. */
   ref?: string;
+  /** Optional seat identity, normalized by the shared message-address registry. */
+  seat?: string;
   /** Optional ISO timestamp; unparseable values are dropped. */
   at?: string;
 }
@@ -47,6 +50,7 @@ export function emitOpsEvent(input: OpsEventInput, deps: OpsEventDeps = {}): str
     const text = oneLine(input.text);
     if (!text) return null;
     const ref = oneLine(input.ref) || null;
+    const seat = typeof input.seat === 'string' && input.seat.trim() ? canonicalSeatId(input.seat) : undefined;
     const at = typeof input.at === 'string' && !Number.isNaN(Date.parse(input.at)) ? input.at : undefined;
     if (!db) {
       // Test runners must never fall through to the user's production memory DB
@@ -61,11 +65,11 @@ export function emitOpsEvent(input: OpsEventInput, deps: OpsEventDeps = {}): str
     return record(db, {
       surface: 'ops', direction: 'outbound', domain: 'elanous', category: 'ops',
       kind: input.kind, text, summary: text.slice(0, 120),
-      refs: JSON.stringify({ kind: input.kind, ref, url: null }),
+      refs: JSON.stringify({ kind: input.kind, ref, url: null, ...(seat ? { seat } : {}) }),
       ...(at ? { ts: at } : {}),
     });
   } catch (error) {
-    try { debug.log('ops.event', 'record-failed', {
+    try { debug.log('context.bus', 'write-failed', {
       kind: input.kind, reason: error instanceof Error ? error.message : String(error),
     }, { level: 'warn' }); } catch { /* A broken logger cannot change the caller's result. */ }
     return null;

package/src/control/control-status.ts

@@ -33,6 +33,13 @@ export interface ControlStatusDeps {
   log?: typeof debug.log;
 }
 
+/** The same read-only HQ source used by `control status` and HQ-fenced control serve. */
+export function readControlHqLease(): ReturnType<typeof readHqLease> {
+  return readHqLease(getElanousConfigDirOverride() !== undefined
+    ? { store: fileLeaseStore(join(effectiveInstanceRoot(), 'hq', 'lease.json')), hostPath: join(effectiveInstanceRoot(), 'hq', 'host') }
+    : {});
+}
+
 const missing = (row: ControlStatusRowName, reason: string): ControlStatusRow => ({ row, state: 'unmeasured', text: '못 쟀다', reason });
 
 function localInstallRoot(): string {
@@ -76,9 +83,7 @@ export async function collectControlStatus(deps: ControlStatusDeps = {}): Promis
   };
 
   await add('집', async () => {
-    const readLease = deps.readLease ?? (() => readHqLease(getElanousConfigDirOverride() !== undefined
-      ? { store: fileLeaseStore(join(effectiveInstanceRoot(), 'hq', 'lease.json')), hostPath: join(effectiveInstanceRoot(), 'hq', 'host') }
-      : {}));
+    const readLease = deps.readLease ?? readControlHqLease;
     const { record, ageSeconds, expired } = await readLease();
     if (!record) return missing('집', '본부 임대 기록 없음');
     return { row: '집', state: expired ? 'warn' : 'ok',

package/src/control-plane/ledger.ts

@@ -23,6 +23,7 @@ export interface PodWorkerKey { context: string; imageDigest: string; lockHash:
 type PodWorkerState = 'idle' | 'leased' | 'sanitizing' | 'quarantined';
 interface PodWorkerLeaseAttrs {
   key: PodWorkerKey;
+  podUid: string;
   state: PodWorkerState;
   generation: number;
   idleTtlMs: number;
@@ -203,20 +204,20 @@ export class ResourceLedger {
   }
 
   /** A trusted host registers a clean instance; canary verification is a separate, still unwired step. */
-  registerPodWorker(request: { workerId: string; machine: string; key: PodWorkerKey; owner: string; ttlMs: number }, now?: number): ResourceRecord {
+  registerPodWorker(request: { workerId: string; machine: string; podUid: string; key: PodWorkerKey; owner: string; ttlMs: number }, now?: number): ResourceRecord {
     return this.mutate(() => {
+    if (typeof request.podUid !== 'string' || !request.podUid.trim()) throw new ResourceLedgerError(400, 'invalid-pod-worker-uid');
     now ??= Date.now();
     const rows = this.read();
     const id = `pod-worker-lease:${request.workerId}`;
     const index = rows.findIndex(row => row.id === id);
     const previous = index < 0 ? undefined : rows[index]!;
     if (previous && previous.kind !== 'pod-worker-lease') throw new ResourceLedgerError(409, 'worker-id-conflict');
-    if (previous && previous.owner !== request.owner) throw new ResourceLedgerError(403, 'not-owner');
     // A workerId identifies one Pod instance. Expiry never proves that a leased or quarantined Pod was cleaned.
     if (previous) throw new ResourceLedgerError(409, 'worker-id-used');
     const generation = 0;
     const row: ResourceRecord = { id, kind: 'pod-worker-lease', machine: request.machine, name: request.workerId,
-      owner: request.owner, attrs: { key: request.key, state: 'idle', generation, idleTtlMs: request.ttlMs }, observedAt: now, ttlMs: request.ttlMs };
+      owner: request.owner, attrs: { key: request.key, podUid: request.podUid, state: 'idle', generation, idleTtlMs: request.ttlMs }, observedAt: now, ttlMs: request.ttlMs };
     if (index < 0) rows.push(row); else rows[index] = row;
     this.write(rows);
     return row;
@@ -229,6 +230,7 @@ export class ResourceLedger {
     const rows = this.read();
     const index = rows.findIndex(row => row.kind === 'pod-worker-lease' && (!request.machine || row.machine === request.machine)
       && Math.max(0, at - row.observedAt) < row.ttlMs && workerAttrs(row).state === 'idle'
+      && typeof workerAttrs(row).podUid === 'string' && workerAttrs(row).podUid.trim().length > 0
       && sameWorkerKey(workerAttrs(row).key, request.key));
     if (index < 0) throw new ResourceLedgerError(409, 'no-warm-worker');
     const row = rows[index]!;

package/src/control-plane/server.ts

@@ -164,15 +164,16 @@ export function startControlServer(opts: ControlServerOptions = {}): {
           if (workerRegister) {
             if (!machine) throw new ResourceLedgerError(403, 'worker-host-required');
             const body = podWorkerBody(await req.json());
-            const { workerId, machine: workerMachine, key, ttlMs } = body;
+            const { workerId, machine: workerMachine, podUid, key, ttlMs } = body;
             if (typeof workerId !== 'string' || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,95}$/.test(workerId)
               || typeof workerMachine !== 'string' || !workerMachine.trim()
+              || typeof podUid !== 'string' || !podUid.trim()
               || typeof ttlMs !== 'number' || !Number.isSafeInteger(ttlMs) || ttlMs <= 0 || ttlMs > MAX_POD_WORKER_TTL_MS) throw new ResourceLedgerError(400, 'invalid-pod-worker-lease');
             requireMachine(workerMachine);
             const stale = await currentWorkerPrimary();
             if (stale) return stale;
             return json(await ledger.withGuardedWorkerMutation(async () => !(await currentWorkerPrimary()),
-              () => ledger.registerPodWorker({ workerId, machine: workerMachine, key: podWorkerKey(key), ttlMs, owner })));
+              () => ledger.registerPodWorker({ workerId, machine: workerMachine, podUid, key: podWorkerKey(key), ttlMs, owner })));
           }
           if (workerAcquire) {
             if (scope !== 'member') throw new ResourceLedgerError(403, 'worker-consumer-required');
@@ -244,7 +245,8 @@ export function startControlServer(opts: ControlServerOptions = {}): {
               name: url.searchParams.get('name') || undefined,
             });
             return json({ resources: rows.map(row => row.kind === 'pod-worker-lease'
-              ? { ...row, attrs: { key: row.attrs.key, state: row.attrs.state, generation: row.attrs.generation } }
+              ? { ...row, attrs: { key: row.attrs.key, podUid: row.attrs.podUid,
+                state: row.attrs.state, generation: row.attrs.generation, idleTtlMs: row.attrs.idleTtlMs } }
               : row.kind === 'port-lease'
               ? { ...row, attrs: { ...row.attrs, leaseId: undefined } }
               : row) });

package/src/core-turn/run-core-turn.ts

@@ -289,6 +289,7 @@ export async function runCoreTurn(
         ...(ctx.callbacks?.onResolvedProvider !== undefined ? { onResolvedProvider: ctx.callbacks.onResolvedProvider } : {}),
         ...(ctx.budgetGrant !== undefined ? { budgetGrant: ctx.budgetGrant } : {}),
         ...(ctx.terminalToolNames !== undefined ? { terminalToolNames: ctx.terminalToolNames } : {}),
+        ...(ctx.terminalPriorAnswerVisible !== undefined ? { terminalPriorAnswerVisible: ctx.terminalPriorAnswerVisible } : {}),
         // ⭐⭐⭐ `B3`(2026-08-19 · 대표 지시 ②) — 도는 턴 «안»으로 들어오는 사용자 발화의 배수구.
         //   ⛔ 종전엔 스트리밍 중 친 발화가 ***턴이 끝난 뒤***에야 나갔다.
         //   ⭐ 이제 «다음 모델 요청을 만들기 직전»(루프 경계)에 이력으로 들어가고,

package/src/core-turn/run-goal-loop.ts

@@ -397,6 +397,10 @@ function findRejectedToolCalls(newMessages: readonly LLMMessage[]): string[] {
   return [...rejected];
 }
 
+/** `streamLLMWithTools` 의 빈 턴·예산 포기 경고(`buildNoFinalSynthesisNotice`) 문면 — 완료 판정 관측에서 «답 없음»으로 센다.
+ *  머리 표지만 보지 않고 런타임 문장까지 맞춰, 그 표지를 인용한 정상 답을 «경고»로 세지 않는다. */
+const NO_FINAL_SYNTHESIS_NOTICE = /\[NO FINAL SYNTHESIS\] The model (?:stopped after repeated empty turns|used the available tool-loop turns without writing a plain-text answer)\./;
+
 /** 이 turn 의 새 메시지에서 마지막 `update_goal` 도구 호출을 찾아 구조화 종결 상태를
  *  반환한다. status 가 enum 밖이면 무시(null). evidence/reason 은 문자열만 수용. */
 function findGoalUpdate(
@@ -559,6 +563,20 @@ export async function runGoalLoop(
   ): GoalLoopResult => {
     if (terminalPublished) return result;
     terminalPublished = true;
+    // TUI-H1-GOALLOOP-EMPTY-TAIL — 완료 판정 한 줄: 목표가 닫혔나(goal-complete) · 사람에게 보일 답이 있나
+    //   (answer-present) · 둘 다 아니다(none — 빈 답이거나 «[NO FINAL SYNTHESIS]» 경고가 최종 답).
+    try {
+      const finalTrimmed = result.finalText.trim();
+      const reason = result.goalComplete
+        ? 'goal-complete'
+        : finalTrimmed.length > 0 && !NO_FINAL_SYNTHESIS_NOTICE.test(finalTrimmed) ? 'answer-present' : 'none';
+      debug.log('goal.loop', 'completion-verdict', {
+        sessionId: ctx.sessionId, ...runAttribution,
+        iterations, reason, stopReason: result.stopReason, finalChars: result.finalText.length,
+      }, { level: 'info' });
+    } catch {
+      // Observability must not change the loop result.
+    }
     try {
       if (result.goalComplete) {
         publishGoalLifecycle(bus, 'complete', completePayload ?? {
@@ -778,6 +796,9 @@ export async function runGoalLoop(
       ...(surfaceUserText !== undefined ? { userText: surfaceUserText } : {}),
       // TUI-GOAL-LOOP-FRICTION(#46·#63) — update_goal 은 도구 예산 거부를 받지 않고, 답과 함께 오면 그 턴으로 마감한다.
       terminalToolNames: [...(ctx.terminalToolNames ?? []), UPDATE_GOAL_TOOL_NAME],
+      // TUI-H1-GOALLOOP-EMPTY-TAIL — 앞 iteration 의 답이 이미 화면에 있으면 «update_goal 만 → 빈 턴» 은 할 말이 없는
+      //   것이다 — 재촉·경고 없이 빈 답으로 끝내고 아래 완료 판정이 앞 답으로 마감한다(중복 접기와 같은 길).
+      ...(previousFinalText.trim().length > 0 ? { terminalPriorAnswerVisible: true } : {}),
       // update_goal 은 종결 신호 — 실 dispatcher 로 새지 않게 가로채 ack 만 돌려준다.
       dispatchTool: (name, args, dctx) => {
         dispatchCount += 1;

package/src/core-turn/short-question.ts

@@ -105,7 +105,11 @@ function classifyTuiChatIntentBase(text: string, ctx: ShortQuestionContext): Tui
   if (!q || ctx.hasAttachments) return coding(ctx.hasAttachments ? 'attachment' : 'empty');
   if (/(?:하니스|구현|코딩|버그|리팩터|커밋|패치|테스트|시험\s*돌|빌드|배포|\b(?:implement|coding|refactor|commit|patch|tests?|build|deploy)\b)/i.test(q)) return coding('coding');
   // Destructive or executing verbs in any form (not only «…줘») are never a quick turn.
-  if (/(?:지워|지우|삭제|제거|옮겨|옮기|돌려|실행(?!\s*중(?:인)?(?:\s|[?!.~]|$))|설치|되돌려|롤백|재시작|죽여|\b(?:delete|remove|rm|rename|move|run|install|revert|rollback|drop|kill|restart)\b)/i.test(q)) return coding('write-verb');
+  // A no-tool answer can transcribe its first line. Keep the verb for file changes and
+  // remove only this copy phrase, so another write request in the same answer is still caught.
+  const answerOnly = /도구\s*쓰지\s*말고\s*답해\s*:/i.test(q);
+  const writeVerbInput = answerOnly ? q.replace(/첫\s*줄(?:을|를)?\s*그대로\s*옮기고/g, '') : q;
+  if (/(?:지워|지우|삭제|제거|옮겨|옮기|돌려|실행(?!\s*중(?:인)?(?:\s|[?!.~]|$))|설치|되돌려|롤백|재시작|죽여|\b(?:delete|remove|rm|rename|move|run|install|revert|rollback|drop|kill|restart)\b)/i.test(writeVerbInput)) return coding('write-verb');
   // Allowlist, not denylist: every «…줘» request verb must be one a quick turn can do; anything else
   // (지워줘 · 돌려줘 · 옮겨줘 …) keeps the coding goal loop.
   for (const match of q.matchAll(/([가-힣]+?)\s*(?:줘|주세요|줄래|주라)/g)) {

package/src/core-turn/types.ts

@@ -158,6 +158,9 @@ export interface CoreTurnContext {
   /** TUI-GOAL-LOOP-FRICTION — 종결 신호 도구 이름. `streamLLMWithTools` 의 `terminalToolNames` 로 그대로 간다
    *  (예산 거부 면제 · 신호뿐인 턴 ⊕ 답 = 마감). goal loop 가 `update_goal` 을 넣는다. */
   terminalToolNames?: LLMOpts['terminalToolNames'];
+  /** TUI-H1-GOALLOOP-EMPTY-TAIL — 이 턴 «앞»에 사람에게 답을 이미 보였다. `streamLLMWithTools` 의
+   *  `terminalPriorAnswerVisible` 로 그대로 간다(종결 신호 뒤 빈 턴 = 경고 없이 빈 답). goal loop 가 넣는다. */
+  terminalPriorAnswerVisible?: LLMOpts['terminalPriorAnswerVisible'];
   /** Optional model override (forwarded to `streamLLMWithTools`). */
   modelOverride?: string;
 }

package/src/dashboard/acp-active-model.ts

@@ -6,7 +6,7 @@
 
 import { debug } from '../debug/log.js';
 import { effectiveReasoningLevel } from '../llm.js';
-import { recordCurrentRouteDecision, resolveRouteDecision, sessionModelPin } from '../llm/route-decision.js';
+import { clearSurfaceRouteDecision, currentRouteDecision, recordCurrentRouteDecision, recordRouteExecution, resolveRouteDecision, sessionModelPin } from '../llm/route-decision.js';
 import { inspectActiveProvider } from '../provider-summary.js';
 import { getUserConfig } from '../user-config.js';
 
@@ -38,3 +38,44 @@ export function resolveDashboardActiveModel(userText: string): string | null {
   });
   return decision.model || null;
 }
+
+/** 턴 사용량(ACP `elanous/ui/usage`)이 실어 온 «실제» 공급자·모델을 이 표면의 실행으로 적는다
+ *  (TUI-MODEL-BADGE-ACTUAL · 10-16). 완료 배지가 결정과 다르면 «A → B» 로 보인다.
+ *  폴백(결정과 다른 모델)이면 관측 이벤트 `llm.route-decision` / `dashboard-executed-fallback` 를 «항상» 남긴다. */
+export function recordDashboardTurnExecution(
+  usage: { model?: string; routeProvider?: string } | null | undefined,
+  /** 필수 — 세션 위치를 모르면(null) 적지 않는다(원격 사용량을 로컬 실행으로 꾸미지 않게). */
+  session: { remote: boolean } | null,
+): void {
+  // ⛔ 순서: 원격·세션 미상 판정(⊕ 비우기)을 model 검사보다 «먼저» 한다 — 사용량 봉투의 model 은 선택 칸이라,
+  //   모델 없는 원격 사용량이 먼저 반환하면 지난 로컬 턴의 «A → B» 가 남는다(r6 리뷰).
+  const model = usage?.model?.trim() || null;
+  if (session === null) {
+    // 짝을 모르는 턴 — 지난 턴의 결정·실행이 이 턴의 배지로 «다시» 보이지 않게 비운다.
+    clearSurfaceRouteDecision('dashboard');
+    debug.log('llm.route-decision', 'dashboard-executed-session-unknown', { model }, { level: 'warn' });
+    return;
+  }
+  // ⛔ 원격 데몬 세션은 적지 않는다 — 결정은 데몬 쪽에서 서므로 이 프로세스의 결정과 짝이 안 맞는다.
+  //   후속 칸 TUI-MODEL-BADGE-REMOTE.
+  if (session.remote) {
+    // 원격 턴은 로컬 결정과 짝이 없다 — 지난 로컬 턴의 «A → B» 가 이 턴의 배지로 다시 나오지 않게 비운다(r5 리뷰).
+    clearSurfaceRouteDecision('dashboard');
+    if (debug.enabled) debug.log('llm.route-decision', 'dashboard-executed-remote-skipped', { model });
+    return;
+  }
+  if (!model) return;
+  const provider = usage?.routeProvider?.trim() || undefined;
+  const decision = currentRouteDecision('dashboard');
+  // 결정이 없는 실행은 짝이 없다 — 적지 않는다.
+  if (!decision) return;
+  recordRouteExecution('dashboard', { model, ...(provider ? { provider } : {}) });
+  if (decision.model !== '' && decision.model !== model) {
+    debug.log('llm.route-decision', 'dashboard-executed-fallback', {
+      planned: { provider: decision.provider, model: decision.model },
+      actual: { provider: provider ?? null, model },
+    }, { level: 'warn' });
+  } else if (debug.enabled) {
+    debug.log('llm.route-decision', 'dashboard-executed', { provider: provider ?? null, model });
+  }
+}

package/src/dashboard/background-jobs-status.ts

@@ -0,0 +1,66 @@
+// ── 상태줄 «⧗ 백그라운드 N» 상태 (TUI-BG-JOB-VISIBILITY · TUI 결함 #71 · 0.2.31) ──────────────
+//
+// 🚨 무엇을 푸는가: 10-16 07:3x OPT 가 «남은 리뷰 4건 실행 중 · 다음 점검 = …» 으로 턴을 «✔ 완료» 로
+//   끝냈다. 상태줄엔 백그라운드 표시가 없어 바깥(OP·대표)에선 «12분 유휴» 로 보였다.
+// ⭐ 이 모듈은 «상태줄에 몇 개를 그릴지» 와 그 관측만 쥔다 — 렌더는 `backgroundJobsSegment`
+//   (src/status/bar.ts), 집계는 BackgroundSurface 의 `background`(src/shell-runner/background-surface.ts).
+// ⛔ 깨우기(끝나면 턴을 여는 것)는 하지 않는다 — TUI-AGENT-IDLE-WAKE 칸(onEnqueue 배선 · H2 문) 몫.
+// ⛔ 입력칸·외부 입력 대기열 주입 0(대표 비침투).
+//
+// 세 얼굴:
+//   관측 = debug.log('status.bar', 'bg-jobs', { running, backgrounded, background, trigger:'rollup' })
+//          — 등록된 백그라운드 수가 «바뀔 때만»(렌더마다·같은 수 반복엔 안 남긴다 · 처음 기준 = 0)
+//   인지 = 등록된 백그라운드 일 > 0 이면 턴이 유휴여도 «일하는 중»
+//   힐링 = 상태줄 «⧗ 백그라운드 N» — 사람·OP 가 «유휴인데 일하는 중» 을 본다 · 수가 바뀌면 다시 그린다 ·
+//          읽기 실패는 0 으로 보고 상태줄을 막지 않는다 · 실패 시 TF(관측 로그)
+
+import { debug } from '../debug/log.js';
+import type { BackgroundJobsSummary } from '../status/bar.js';
+
+export interface ShellRollupCounts {
+  running: number;
+  backgrounded: number;
+  /** 턴을 넘어 사는 핸들(bg 모드 ⊕ backgrounded). 필수 — backgrounded 로 추정하면 도는 bg 모드 일을 빠뜨린다. */
+  background: number;
+}
+
+export interface BackgroundJobsStatusDeps {
+  log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+export interface BackgroundJobsStatus {
+  /** 집계가 왔다 — 등록된 백그라운드 수가 바뀌었으면 관측 한 줄 ⊕ true(호출자가 다시 그린다). */
+  noteRollup(rollup: ShellRollupCounts): boolean;
+  /** 상태줄 입력. */
+  summary(): BackgroundJobsSummary;
+}
+
+function countOf(n: number): number {
+  return Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 0;
+}
+
+export function createBackgroundJobsStatus(deps: BackgroundJobsStatusDeps = {}): BackgroundJobsStatus {
+  const log = deps.log ?? ((event, data) => { debug.log('status.bar', event, data); });
+  // 처음 기준은 0 — 백그라운드 0 인 첫 집계(인라인 실행 등)는 «변화 없음» 이라 안 남긴다.
+  let background = 0;
+
+  return {
+    noteRollup(rollup) {
+      const next = countOf(rollup.background);
+      if (next === background) return false;
+      background = next;
+      try {
+        log('bg-jobs', {
+          running: countOf(rollup.running),
+          backgrounded: countOf(rollup.backgrounded),
+          background: next,
+          trigger: 'rollup',
+        });
+      } catch { /* 관측 실패가 상태줄을 막지 않는다 */ }
+      return true;
+    },
+    summary() {
+      return { background };
+    },
+  };
+}