elanous 0.2.21 → 0.2.23

package/src/control-plane/member.ts

@@ -1,5 +1,7 @@
-import { readFileSync } from 'node:fs';
-import { cpus, freemem, loadavg, totalmem } from 'node:os';
+import { execFile } from 'node:child_process';
+import { readFileSync, promises as fs } from 'node:fs';
+import { promisify } from 'node:util';
+import { cpus, freemem, loadavg, platform, totalmem } from 'node:os';
 import { join } from 'node:path';
 import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
@@ -12,13 +14,173 @@ const MAX_RETRY_MS = 300_000;
 // Ordinary ticks start within the 10-minute TTL; first failure retries within 30 seconds.
 const MAX_INTERVAL_MS = MAX_RETRY_MS;
 const REQUEST_TIMEOUT_MS = 5_000;
+const PROCESS_PROBE_TIMEOUT_MS = 2_000;
+const execFileAsync = promisify(execFile);
 
-export function measureLoad(now: () => number = Date.now): {
+type Measurement<T> = { value: T; source: string; observedAt: number; status: 'ok' }
+  | { value: null; source: string; observedAt: number; status: 'unmeasured'; reason: string };
+
+function unmeasured<T>(source: string, observedAt: number, reason: string): Measurement<T> {
+  return { value: null, source, observedAt, status: 'unmeasured', reason };
+}
+
+export interface HarnessParentSummary {
+  count: Measurement<number>;
+  oldestAgeSeconds: Measurement<number>;
+  versionMismatchCount: Measurement<number>;
+}
+
+// Pod image commit is fixed at process startup; file paths and mutable package versions are not process identities.
+const STARTUP_IMAGE_COMMIT = process.env.ELANOUS_IMAGE_COMMIT?.trim();
+const HARNESS_PARENT_COMMAND = /^(?:(?:\S*\/)?(?:bun|node)\s+)?(?:\S*\/)?elanous\.mjs\s+harness\s+(?:say|ask)(?:\s|$)/;
+
+export function parseHarnessParentPs(text: string): HarnessProcessList {
+  if (!text.trim()) return { status: 'incomplete', stage: 'ps-parse' };
+  const records: Array<{ pid: number; command: string; elapsedSeconds: number }> = [];
+  let incomplete = false;
+  for (const line of text.split('\n')) {
+    const candidate = line.trim().match(/^\d+\s+\S+\s+(.+)$/)?.[1];
+    if (!candidate || !HARNESS_PARENT_COMMAND.test(candidate)) continue;
+    const match = line.trim().match(/^(\d+)\s+(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)\s+(.+)$/);
+    if (!match) { incomplete = true; continue; }
+    const pid = Number(match[1]);
+    const days = Number(match[2] ?? 0);
+    const hours = Number(match[3] ?? 0);
+    const minutes = Number(match[4]);
+    const seconds = Number(match[5]);
+    if (!Number.isSafeInteger(pid) || pid <= 0 || minutes >= 60 || seconds >= 60 || (match[3] !== undefined && hours >= 24)) { incomplete = true; continue; }
+    records.push({ pid, elapsedSeconds: days * 86_400 + hours * 3_600 + minutes * 60 + seconds, command: match[6]! });
+  }
+  return incomplete ? { status: 'incomplete', stage: 'ps-parse' } : { status: 'ok', records };
+}
+
+interface HarnessProcessList {
+  status: 'ok' | 'incomplete' | 'failed';
+  stage?: string;
+  records?: readonly { pid: number; command: string; elapsedSeconds: number; version?: string }[];
+}
+
+async function readHarnessProcessVersion(pid: number): Promise<string | undefined> {
+  if (platform() !== 'linux') return undefined;
+  try {
+    const env = await fs.readFile(`/proc/${pid}/environ`, { encoding: 'utf8', signal: AbortSignal.timeout(PROCESS_PROBE_TIMEOUT_MS) });
+    const versions = env.split('\0').filter(entry => entry.startsWith('ELANOUS_IMAGE_COMMIT='))
+      .map(entry => entry.slice('ELANOUS_IMAGE_COMMIT='.length).trim());
+    return versions.length === 1 && versions[0] ? versions[0] : undefined;
+  } catch { return undefined; }
+}
+
+export async function listHarnessParents(
+  run: typeof execFileAsync = execFileAsync,
+  readVersion: (pid: number) => Promise<string | undefined> = readHarnessProcessVersion,
+): Promise<HarnessProcessList> {
+  try {
+    const { stdout } = await run('ps', ['-axo', 'pid=,etime=,command='], {
+      encoding: 'utf8', timeout: PROCESS_PROBE_TIMEOUT_MS, maxBuffer: 4 * 1024 * 1024,
+    });
+    const parsed = parseHarnessParentPs(stdout);
+    if (parsed.status !== 'ok' || !parsed.records) return parsed;
+    const records = await Promise.all(parsed.records.map(async record => {
+      const version = await readVersion(record.pid).catch(() => undefined);
+      return { ...record, ...(version ? { version } : {}) };
+    }));
+    return { status: 'ok', records };
+  } catch { return { status: 'failed', stage: 'ps-exec' }; }
+}
+
+/** A process command/path is not the version loaded into a running process. Only startup-stamped identities count. */
+export function measureHarnessParents(
+  observedAt = Date.now(),
+  observation: HarnessProcessList = { status: 'failed', stage: 'ps-exec' },
+  currentVersion?: string,
+): HarnessParentSummary {
+  const source = 'ps:harness-processes';
+  if (observation.status !== 'ok' || !observation.records) {
+    const reason = observation.status === 'incomplete' ? 'ps-parse incomplete' : (observation.stage ?? 'ps-exec');
+    return { count: unmeasured(source, observedAt, reason), oldestAgeSeconds: unmeasured(source, observedAt, reason),
+      versionMismatchCount: unmeasured(source, observedAt, reason) };
+  }
+  const ok = (value: number): Measurement<number> => ({ value, source, observedAt, status: 'ok' });
+  const records = observation.records.filter(record => HARNESS_PARENT_COMMAND.test(record.command));
+  const count = ok(records.length);
+  const oldestAgeSeconds = records.length === 0
+    ? unmeasured<number>(source, observedAt, 'no-parents')
+    : records.every(record => Number.isFinite(record.elapsedSeconds) && record.elapsedSeconds >= 0)
+      ? ok(Math.max(...records.map(record => record.elapsedSeconds)))
+      : unmeasured<number>(source, observedAt, 'elapsed-unavailable');
+  const versionMismatchCount = records.length === 0 ? ok(0)
+    : currentVersion && records.every(record => typeof record.version === 'string' && record.version.length > 0)
+      ? ok(records.filter(record => record.version !== currentVersion).length)
+      : unmeasured<number>(source, observedAt, 'version-unavailable');
+  return { count, oldestAgeSeconds, versionMismatchCount };
+}
+
+export interface DiskIoPressure {
+  pageouts: Measurement<number>;
+  io: Measurement<{ someAvg10: number; fullAvg10: number }>;
+}
+
+export async function measureDiskIoPressure(
+  observedAt = Date.now(),
+  deps: { platform?: NodeJS.Platform; vmStat?: () => Promise<string> | string; readPressure?: () => Promise<string> | string } = {},
+  pageoutBaseline?: { value: number },
+): Promise<DiskIoPressure> {
+  const os = deps.platform ?? platform();
+  let pageouts: Measurement<number> = unmeasured('vm_stat:pageouts', observedAt, 'platform');
+  if (os === 'darwin') {
+    try {
+      const text = await (deps.vmStat ?? (async () => (await execFileAsync('vm_stat', [], {
+        encoding: 'utf8', timeout: PROCESS_PROBE_TIMEOUT_MS, maxBuffer: 1024 * 1024,
+      })).stdout))();
+      // Real macOS vm_stat prints `Pageouts:`; older/other formats print `Pages paged out:`.
+      const value = text.match(/^(?:Pageouts|Pages paged out):\s*([\d,]+)\s*\.?\s*$/m)?.[1];
+      if (value && Number.isSafeInteger(Number(value.replaceAll(',', '')))) {
+        const total = Number(value.replaceAll(',', ''));
+        pageouts = pageoutBaseline
+          ? Number.isFinite(pageoutBaseline.value) && total >= pageoutBaseline.value
+            ? { value: total - pageoutBaseline.value, source: 'vm_stat:pageouts', observedAt, status: 'ok' }
+            : unmeasured('vm_stat:pageouts', observedAt, 'baseline-unavailable')
+          : { value: total, source: 'vm_stat:pageouts', observedAt, status: 'ok' };
+        if (pageoutBaseline) pageoutBaseline.value = total;
+      }
+      else pageouts = unmeasured('vm_stat:pageouts', observedAt, 'invalid-output');
+    } catch { pageouts = unmeasured('vm_stat:pageouts', observedAt, 'vm_stat-failed'); }
+  }
+  let io: DiskIoPressure['io'] = unmeasured('/proc/pressure/io', observedAt, 'platform');
+  if (os === 'linux') {
+    try {
+      const text = await (deps.readPressure ?? (() => fs.readFile('/proc/pressure/io', {
+        encoding: 'utf8', signal: AbortSignal.timeout(PROCESS_PROBE_TIMEOUT_MS),
+      })))();
+      const some = text.match(/^some\s+avg10=(\d+(?:\.\d+)?)(?:\s|$)/m)?.[1];
+      const full = text.match(/^full\s+avg10=(\d+(?:\.\d+)?)(?:\s|$)/m)?.[1];
+      if (some !== undefined && full !== undefined && Number.isFinite(Number(some)) && Number.isFinite(Number(full)))
+        io = { value: { someAvg10: Number(some), fullAvg10: Number(full) }, source: '/proc/pressure/io', observedAt, status: 'ok' };
+      else io = unmeasured('/proc/pressure/io', observedAt, 'invalid-output');
+    } catch { io = unmeasured('/proc/pressure/io', observedAt, 'pressure-read-failed'); }
+  }
+  return { pageouts, io };
+}
+
+export async function measureLoad(
+  now: () => number = Date.now,
+  pageoutBaseline?: { value: number },
+  deps: { listParents?: () => Promise<HarnessProcessList>; diskIo?: (at: number, baseline?: { value: number }) => Promise<DiskIoPressure>; currentVersion?: string } = {},
+): Promise<{
   loadAvg: number[]; cpuCount: number; freeMem: number; totalMem: number; observedAt: number;
-} {
+  harnessParents: HarnessParentSummary; diskIo: DiskIoPressure;
+}> {
+  const observedAt = now();
+  const [parents, diskIo] = await Promise.all([
+    (deps.listParents ?? listHarnessParents)().catch((): HarnessProcessList => ({ status: 'failed', stage: 'ps-exec' })),
+    (deps.diskIo ?? ((at, baseline) => measureDiskIoPressure(at, {}, baseline)))(observedAt, pageoutBaseline)
+      .catch((): DiskIoPressure => ({ pageouts: unmeasured<number>('vm_stat:pageouts', observedAt, 'probe-failed'),
+        io: unmeasured<{ someAvg10: number; fullAvg10: number }>('/proc/pressure/io', observedAt, 'probe-failed') })),
+  ]);
   return {
     loadAvg: loadavg(), cpuCount: cpus().length,
-    freeMem: freemem(), totalMem: totalmem(), observedAt: now(),
+    freeMem: freemem(), totalMem: totalmem(), observedAt,
+    harnessParents: measureHarnessParents(observedAt, parents, deps.currentVersion ?? STARTUP_IMAGE_COMMIT), diskIo,
   };
 }
 
@@ -50,6 +212,7 @@ export interface MemberHeartbeatOptions {
   intervalMs?: number;
   fetch?: (input: URL | RequestInfo, init?: RequestInit) => Promise<Response>;
   now?: () => number;
+  measure?: (now: () => number, pageoutBaseline: { value: number }) => Promise<Awaited<ReturnType<typeof measureLoad>>>;
 }
 
 /** 넥서스 멤버의 기계 신원 — OS hostname 이 아니라 임대·관제가 쓰는 기계 식별자(`resolveMachineName`)를 쓴다.
@@ -81,6 +244,8 @@ export function startMemberHeartbeat(opts: MemberHeartbeatOptions): () => void {
   let failures = 0;
   let lastFailure: string | undefined;
   const machineId = opts.machine.id;
+  const pageoutBaseline: { value: number } = { value: Number.NaN };
+  const machineLoad = () => (opts.measure ?? measureLoad)(now, pageoutBaseline);
   // 자원의 `machine` 칸 = 기계 «이름»(가벼운 멤버·임대와 같은 값). 기계 범위 토큰은 이 칸을 토큰의 기계와 대조한다(server.ts requireMachine).
   const machineName = opts.machine.name;
 
@@ -106,7 +271,7 @@ export function startMemberHeartbeat(opts: MemberHeartbeatOptions): () => void {
   const register = async (): Promise<void> => {
     await post('/v1/resources/register', {
       ...opts.machine, kind: 'machine', machine: machineName, owner: '',
-      attrs: { ...opts.machine.attrs, load: measureLoad(now) }, observedAt: now(), ttlMs: MAX_RETRY_MS * 2,
+      attrs: { ...opts.machine.attrs, load: await machineLoad() }, observedAt: now(), ttlMs: MAX_RETRY_MS * 2,
     });
     await post('/v1/resources/register', {
       ...opts.instance, kind: 'instance', machine: machineName, owner: '',
@@ -125,7 +290,7 @@ export function startMemberHeartbeat(opts: MemberHeartbeatOptions): () => void {
     try {
       if (!registered) await register();
       else {
-        await post(`/v1/resources/${encodeURIComponent(machineId)}/heartbeat`, { attrs: { load: measureLoad(now) } });
+        await post(`/v1/resources/${encodeURIComponent(machineId)}/heartbeat`, { attrs: { load: await machineLoad() } });
         heartbeatsSinceInstanceRefresh++;
         if (heartbeatsSinceInstanceRefresh * interval >= MAX_RETRY_MS) {
           await post(`/v1/resources/${encodeURIComponent(opts.instance.id)}/heartbeat`, {});

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

@@ -33,7 +33,7 @@ import { debug } from '../debug/log.js';
 import { publishGoalLifecycle } from '../goals/loop.js';
 import { boundReadableText } from '../self-implement/orchestrator.js';
 import { changedFiles } from '../self-implement/seams.js';
-import { getHarnessRunId, getHarnessSpace } from '../harness/harness-space.js';
+import { getHarnessRole, getHarnessRunId, getHarnessSpace } from '../harness/harness-space.js';
 import { CONTROL_INBOX_DIR_ENV, drainControlInbox, drainSoftStopControlInbox, enqueueControlMemo, type ControlInboxDrain, type ControlMemoPayload } from '../harness/control-inbox.js';
 import { enqueuePendingUserInput } from '../session/pending-input.js';
 import { getCurrentPtyId } from '../agent/pty-identity.js';
@@ -180,6 +180,7 @@ export const GOAL_CONTINUATION_PROMPT = [
   '[continue]',
   '아직 목표가 완료로 증명되지 않았다. 완료를 미리 선언하지 말고, 현재 상태 대비 실제로 검증하라:',
   '남은 요구사항을 식별하고, 다음 최고가치 스텝을 지금 도구로 실행하라.',
+  '이미 사용자에게 한 답을 다시 쓰지 마라 — 새 사실이 없으면 텍스트 없이 update_goal 만 호출하라.',
   // evidence-audit(ref codex ext/goal continuation.md:41,51) — 스푸핑·조기완료 차단.
   '완료 증거로 의도/부분진전/이전 작업 기억/그럴듯한 답을 쓰지 마라. 현재 상태(파일·명령출력·테스트결과·PR·런타임 동작)를 실제로 확인한 증거만 인정한다.',
   '예산이 곧 소진된다거나 그만두고 싶다는 이유로 완료를 선언하지 마라.',
@@ -196,8 +197,25 @@ export const GOAL_READBACK_PROMPT = [
   '[finalize]',
   `완료를 텍스트로만 말했다. 텍스트 문장은 완료 신호가 아니다 — 완료가 사실이면 ${UPDATE_GOAL_TOOL_NAME} 도구를 status="complete" 로 호출하고 evidence 에 현재 상태에서 실제로 확인한 증거(파일·명령출력·테스트·PR)를 적어라.`,
   '아직 미충족 항목이 있으면 완료를 주장하지 말고 다음 스텝을 지금 실행하라.',
+  '이미 사용자에게 한 답을 다시 쓰지 마라 — 새 사실이 없으면 텍스트 없이 update_goal 만 호출하라.',
 ].join('\n');
 
+/** GOAL-LOOP-INTENT-STALL (0.2.24 · OP or-audit-1010) — 구현 자식이 «도구를 한 번도 안 부르고 말만 한 턴»에
+ *  넣는 재촉. hermes-agent stall guard(`agent/turn_final_response.py` 172-205)를 본떴다.
+ *  ⛔ 기존 프롬프트 상수는 건드리지 않는다 — 재촉 문면은 이 상수 하나뿐이다. */
+export const GOAL_INTENT_STALL_PROMPT = [
+  '[act now]',
+  '말로 계획만 적고 도구를 하나도 호출하지 않았다. 지금 바로 실제로 도구를 호출해 첫 스텝을 실행하라(예: 대상 파일 읽기).',
+  '설명 문장만으로 이 턴을 끝내지 마라.',
+].join('\n');
+
+/** 재촉 상한 — 이 횟수를 쓰고도 텍스트만이면 종전 ④(텍스트 수용)로 그대로 떨어진다. */
+export const GOAL_INTENT_STALL_MAX_REPROMPTS = 2;
+
+/** 재촉 가드가 켜지는 provider — ⭐ 이번 조각은 OpenRouter(오픈웨이트 모델) 구현 자식 «한정»이다
+ *  (OP 10-10 결정 · 실측 GLM Flash 첫 턴 40토큰 말만 하고 abandoned). 다른 provider 는 종전 그대로. */
+export const GOAL_INTENT_STALL_PROVIDERS: ReadonlySet<string> = new Set(['openrouter']);
+
 /** evidence 누락 complete 재주입 — update_goal(complete) 를 호출했으나 evidence 가 비었을 때. */
 export const GOAL_EVIDENCE_REQUIRED_PROMPT = [
   '[evidence required]',
@@ -262,6 +280,10 @@ export interface GoalLoopOptions {
   controlSpaceId?: string | null;
   /** Test seam — file-backed child liveness heartbeat. Default starts the workspace-file writer. */
   startLivenessHeartbeat?: typeof startChildLivenessHeartbeat;
+  /** GOAL-LOOP-INTENT-STALL — 구현 자식의 LLM provider. `openrouter` 일 때만 «도구 0회·텍스트만» 턴을
+   *  최대 2번 재촉한다. 생략하면 harness role 이 executor 인 프로세스에서만 활성 provider 로 푼다.
+   *  null = 가드 꺼짐. 시험은 이 인자를 명시해 env 에 기대지 않는다. */
+  intentStallProvider?: string | null;
 }
 
 export type GoalLoopStopReason =
@@ -447,10 +469,17 @@ export async function runGoalLoop(
   //   ※ 객체 홀더: onToolResult 클로저에서 변이하므로 let narrowing 대신 property 타입으로 읽는다.
   const runTests: { last: { ok: boolean; fail: number; unmatchedFilters: string[]; pass: number } | null } = { last: null };
   let lastResult: CoreTurnResult = { stopReason: 'end_turn', finalText: '' };
+  // GOAL-LOOP-INTENT-STALL — provider 는 루프 진입 시 «한 번» 정한다. 런 전체 도구 활동은 누적한다.
+  const intentStallProvider = await resolveIntentStallProvider(opts.intentStallProvider);
+  const intentStallGuard = intentStallProvider !== null && GOAL_INTENT_STALL_PROVIDERS.has(intentStallProvider);
+  let anyToolActivity = false;
+  let intentStallReprompts = 0;
+  // GOAL-LOOP-MIDRUN-STALL — 도구를 쓴 «뒤»의 말뿐인 턴 재촉은 런당 1회뿐이다.
+  let intentStallMidrunUsed = false;
 
   debug.log('goal.loop', 'start', {
     sessionId: ctx.sessionId, ...runAttribution, objective, maxIterations, noProgressLimit,
-    contextTokenLimit, contextPressureRatio,
+    contextTokenLimit, contextPressureRatio, intentStallGuard, intentStallProvider,
   }, { level: 'info' });
   const bus = getChannelBus();
   ensureProcessLifecycleBridge(bus, opts.attachLifecycleBridge ?? attachLifecycleBridge);
@@ -689,6 +718,7 @@ export async function runGoalLoop(
       },
     };
 
+    const previousFinalText = lastResult.finalText;
     try {
       lastResult = await runTurn(turnCtx);
     } finally {
@@ -699,6 +729,7 @@ export async function runGoalLoop(
     const goalUpdate = findGoalUpdate(turnNewMessages);
     const rejectedTools = findRejectedToolCalls(turnNewMessages);
     const toolActivity = hadToolActivity(turnNewMessages);
+    if (toolActivity) anyToolActivity = true;
     const markerComplete = hasCompletionMarker(lastResult.finalText);
     const markerBlocked = hasBlockedMarker(lastResult.finalText);
 
@@ -786,8 +817,26 @@ export async function runGoalLoop(
         debug.log('goal.loop', 'complete', {
           sessionId: ctx.sessionId, ...runAttribution, iterations, via: 'update_goal', evidenceCheck,
         }, { level: 'info' });
+        const normalizeAnswer = (text: string) => text.trim().replace(/\s+/g, ' ');
+        const previousAnswer = normalizeAnswer(previousFinalText);
+        const completionAnswer = normalizeAnswer(lastResult.finalText);
+        const previousAt = previousAnswer ? completionAnswer.indexOf(previousAnswer) : -1;
+        const prefix = previousAt >= 0 ? completionAnswer.slice(0, previousAt).trim() : '';
+        const suffix = previousAt >= 0 ? completionAnswer.slice(previousAt + previousAnswer.length).trim() : '';
+        // Only a readback preface is non-factual; a new sentence before the old answer
+        // (including one joined by a colon) must survive just like a new suffix.
+        const readbackPreface = /^(?:확인 결과|(?:방금\s+)?다시\s+확인(?:했습니다|했지만|해보니|해 보니|해봤지만|해 봤지만|했으나|했는데))[\s:：,.!?。！？-]*$/u;
+        const hasNewFact = (prefix.length > 0 && !readbackPreface.test(prefix)) || /\p{L}|\p{N}/u.test(suffix);
+        const duplicateAnswer = previousAnswer.length > 0 && (
+          completionAnswer.length === 0 || (previousAt >= 0 && !hasNewFact)
+        );
+        if (duplicateAnswer) {
+          debug.log('goal.loop', 'complete-duplicate-answer-suppressed', {
+            sessionId: ctx.sessionId, ...runAttribution, iterations, chars: lastResult.finalText.length,
+          });
+        }
         return finish(
-          { finalText: lastResult.finalText, iterations, stopReason: 'goal_complete', goalComplete: true },
+          { finalText: duplicateAnswer ? previousFinalText : lastResult.finalText, iterations, stopReason: 'goal_complete', goalComplete: true },
           { summary: completionSummary, changedFiles: completionChangedFiles },
         );
       }
@@ -847,6 +896,43 @@ export async function runGoalLoop(
     }
     readbackStreak = 0;
 
+    // ④-0 GOAL-LOOP-INTENT-STALL — OpenRouter 구현 자식이 런 내내 도구를 한 번도 안 부르고 말만 했다
+    //    (예: 「먼저 파일을 읽겠습니다」 후 멈춤). 일상 답변으로 수락하기 전에 «실제로 도구를 호출하라»를
+    //    최대 GOAL_INTENT_STALL_MAX_REPROMPTS 번 넣는다. 재촉 턴도 maxIterations 에 센다(하드캡이 이긴다).
+    //    상한을 쓰고도 텍스트만이면 포기 이벤트만 남기고 아래 ④ 로 «그대로» 떨어진다(포기 경로 불변).
+    //    ⛔ 가드가 꺼졌거나(다른 provider·비-executor) 한 번이라도 도구를 불렀으면 이 블록은 아무것도 안 한다.
+    //    ⭐ 빈 답(finalChars 0)도 «도구 0회»면 같은 정체로 본다 — 빈 답도 종전엔 text-only-accept 로 abandoned 됐다.
+    if (!toolActivity && intentStallGuard && !anyToolActivity) {
+      if (intentStallReprompts < GOAL_INTENT_STALL_MAX_REPROMPTS) {
+        intentStallReprompts += 1;
+        debug.log('goal.loop', 'intent-stall-reprompt', {
+          sessionId: ctx.sessionId, ...runAttribution, iterations, attempt: intentStallReprompts,
+          finalChars: lastResult.finalText.length, provider: intentStallProvider,
+        }, { level: 'info' });
+        messages.push({ role: 'user', content: GOAL_INTENT_STALL_PROMPT });
+        continue;
+      }
+      debug.log('goal.loop', 'intent-stall-exhausted', {
+        sessionId: ctx.sessionId, ...runAttribution, iterations, attempts: intentStallReprompts,
+        provider: intentStallProvider,
+      }, { level: 'warn' });
+    }
+
+    // ④-0b GOAL-LOOP-MIDRUN-STALL — 앞서 도구를 썼는데 이번 턴은 도구 없이 말로 끝났다
+    //    (예: 파일을 읽은 뒤 「이제 수정하겠습니다」 후 멈춤 → 변경 0 abort · 10-10). 같은 가드에서
+    //    같은 GOAL_INTENT_STALL_PROMPT 를 «런당 1회»만 넣는다. 재촉 턴도 maxIterations 에 센다.
+    //    두 번째 중간 정체는 아래 ④ 로 «그대로» 떨어진다(text-only-accept 불변).
+    //    ⛔ 가드가 꺼졌으면(다른 provider·비-executor) 이 블록은 아무것도 안 한다 · ④-0 과는 anyToolActivity 로 배타.
+    if (!toolActivity && intentStallGuard && anyToolActivity && !intentStallMidrunUsed) {
+      intentStallMidrunUsed = true;
+      debug.log('goal.loop', 'intent-stall-midrun', {
+        sessionId: ctx.sessionId, ...runAttribution, iterations,
+        finalChars: lastResult.finalText.length, provider: intentStallProvider,
+      }, { level: 'info' });
+      messages.push({ role: 'user', content: GOAL_INTENT_STALL_PROMPT });
+      continue;
+    }
+
     // ④ 순수 텍스트(도구 없음)로 끝났고 종결 신호도 없음 = 일상 답변(목표성 작업 아님).
     //    재주입하지 않고 그대로 수용해 trivial chat 을 이중 루프하지 않는다.
     if (!toolActivity) {
@@ -887,3 +973,22 @@ export async function runGoalLoop(
     stopLivenessHeartbeat();
   }
 }
+
+/** 가드 provider 를 정한다. 명시 인자가 이긴다(시험·호출부). 생략하면 «구현 자식»(harness role executor)
+ *  프로세스에서만 활성 provider(`resolveActiveProvider` — `ELANOUS_LLM_PROVIDER` 릴레이 포함)를 읽는다.
+ *  ⛔ executor 가 아닌 프로세스(ACP 대시보드·`chat --goal-loop`)는 읽지도 않는다 ⇒ null = 가드 꺼짐.
+ *  읽기 실패도 null(fail-open = 종전 동작). */
+async function resolveIntentStallProvider(explicit: string | null | undefined): Promise<string | null> {
+  if (explicit !== undefined) return explicit?.trim().toLowerCase() || null;
+  if (getHarnessRole() !== 'executor') return null;
+  try {
+    const { getUserConfig, resolveActiveProvider } = await import('../user-config.js');
+    return resolveActiveProvider(getUserConfig());
+  } catch (error) {
+    // fail-open(가드 꺼짐 = 종전 동작)이지만 «왜 꺼졌나»는 남긴다 — 조용한 꺼짐은 관측 안 한 것이다.
+    debug.log('goal.loop', 'intent-stall-provider-unresolved', {
+      error: error instanceof Error ? error.message : String(error),
+    }, { level: 'warn' });
+    return null;
+  }
+}

package/src/dashboard/chat-fold.ts

@@ -0,0 +1,20 @@
+import { format, getMessages } from '../expression/i18n/index.js';
+
+type Locale = NonNullable<Parameters<typeof getMessages>[0]>;
+
+export function splitNoSynthesisTail(text: string): { head: string; tail: string } | null {
+  const index = text.indexOf('[NO FINAL SYNTHESIS]');
+  if (index === -1) return null;
+  return {
+    head: text.slice(0, index).trimEnd(),
+    tail: text.slice(index),
+  };
+}
+
+/** English fallback for locale bundles that do not carry the optional key. */
+const FOLDED_TAIL_FALLBACK = '● Internal notes folded · {n} lines · press f to expand';
+
+export function buildFoldedTailLine(lineCount: number, locale?: Locale): string {
+  const template = getMessages(locale).chatFoldedInternalTail ?? FOLDED_TAIL_FALLBACK;
+  return format(template, { n: lineCount });
+}

package/src/dashboard/first-screen-band.ts

@@ -1,6 +1,111 @@
+import { debug } from '../debug/log.js';
+import { resolveCurrentInstance } from '../instance/current.js';
+import { resolveDaemonEndpoint, type DaemonEndpoint } from '../nexus/daemon-endpoint.js';
+
+export type TuiDaemonLink =
+  | { readonly status: 'checking' }
+  | { readonly status: 'connected'; readonly address: string }
+  | { readonly status: 'absent' | 'unhealthy'; readonly startCommand: string }
+  | { readonly status: 'error'; readonly stage: 'endpoint' | 'health' | 'identity' };
+
+export interface TuiDaemonLinkDeps {
+  readonly endpoint?: () => Pick<DaemonEndpoint, 'baseUrl' | 'healthUrl' | 'source'> | null;
+  readonly probe?: (url: string, init: RequestInit) => Promise<Response>;
+  readonly universe?: () => 'test' | 'prod';
+  /** An explicitly chosen test root (`--test=<root>` / parent stamp); bare `--test` cannot name it. */
+  readonly testRoot?: () => string | undefined;
+  readonly observe?: (data: {
+    status: TuiDaemonLink['status'];
+    stage: 'endpoint' | 'health' | 'identity';
+    universe: 'test' | 'prod' | 'unknown';
+    source: 'registry' | 'lifecycle' | 'none';
+  }) => void;
+}
+
+// C0/C1 controls incl. ESC (ANSI sequences), newline and DEL.
+const CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/;
+
+function shellQuote(value: string): string {
+  return /^[A-Za-z0-9_./:=@%+-]+$/.test(value) ? value : `'${value.replaceAll("'", `'\\''`)}'`;
+}
+
+/** Probe the write target in this universe only; never use a watch/production fallback. */
+export async function resolveTuiDaemonLink(deps: TuiDaemonLinkDeps = {}): Promise<TuiDaemonLink> {
+  const universe = deps.universe ?? (() => resolveCurrentInstance().kind === 'test' ? 'test' : 'prod');
+  const observe = deps.observe ?? ((data) => debug.log('dashboard.tui-daemon-link', 'resolved', data));
+  let kind: 'test' | 'prod' | 'unknown' = 'unknown';
+  let source: 'registry' | 'lifecycle' | 'none' = 'none';
+  const finish = (result: TuiDaemonLink, stage: 'endpoint' | 'health' | 'identity'): TuiDaemonLink => {
+    try { observe({ status: result.status, stage, universe: kind, source }); } catch { /* observation is fail-soft */ }
+    return result;
+  };
+  try {
+    kind = universe();
+  } catch {
+    return finish({ status: 'error', stage: 'identity' }, 'identity');
+  }
+  let explicitRoot: string | undefined;
+  if (kind === 'test') {
+    try {
+      // An injected identity comes with its own root (or none); only the real identity reads the real root.
+      explicitRoot = (deps.testRoot ?? (deps.universe ? () => undefined : () => {
+        const resolution = resolveCurrentInstance();
+        return resolution.layer === 'explicit-flag' || resolution.layer === 'parent-stamp' ? resolution.root : undefined;
+      }))();
+    } catch {
+      return finish({ status: 'error', stage: 'identity' }, 'identity');
+    }
+  }
+  // The start command must name *this* universe: a custom test root is passed as one literal shell argument.
+  // A root with control characters cannot be shown safely (it would rewrite the screen): name no command at all.
+  const startCommand = kind === 'test'
+    ? explicitRoot ? (CONTROL_CHARS.test(explicitRoot) ? '' : `elanous --test=${shellQuote(explicitRoot)} nexus run --hmr`) : 'elanous --test nexus run --hmr'
+    : 'elanous nexus run --hmr';
+  let endpoint: ReturnType<NonNullable<TuiDaemonLinkDeps['endpoint']>>;
+  try {
+    endpoint = (deps.endpoint ?? (() => resolveDaemonEndpoint({ purpose: 'write' })))();
+    if (!endpoint) return finish({ status: 'absent', startCommand }, 'endpoint');
+    source = endpoint.source;
+  } catch {
+    return finish({ status: 'error', stage: 'endpoint' }, 'endpoint');
+  }
+  let address: string;
+  let healthAddress: string;
+  try {
+    const url = new URL(endpoint.baseUrl);
+    const healthUrl = new URL(endpoint.healthUrl);
+    if (!['http:', 'https:'].includes(url.protocol) || !url.hostname || url.username || url.password
+      || url.pathname !== '/' || url.search || url.hash || healthUrl.origin !== url.origin
+      || healthUrl.username || healthUrl.password || healthUrl.pathname !== '/v1/health'
+      || healthUrl.search || healthUrl.hash) {
+      return finish({ status: 'error', stage: 'endpoint' }, 'endpoint');
+    }
+    address = url.origin;
+    healthAddress = `${address}/v1/health`;
+  } catch {
+    return finish({ status: 'error', stage: 'endpoint' }, 'endpoint');
+  }
+  try {
+    const response = await (deps.probe ?? fetch)(healthAddress, { signal: AbortSignal.timeout(1500) });
+    if (!response.ok) return finish({ status: 'unhealthy', startCommand }, 'health');
+    const body: unknown = await response.json();
+    if (!body || typeof body !== 'object' || !('ok' in body) || body.ok !== true) {
+      return finish({ status: 'unhealthy', startCommand }, 'health');
+    }
+    // «Connected» is a claim about *this* universe: the daemon must state its universe and it must match.
+    if (!('testUniverse' in body) || typeof body.testUniverse !== 'boolean' || body.testUniverse !== (kind === 'test')) {
+      return finish({ status: 'error', stage: 'identity' }, 'identity');
+    }
+    return finish({ status: 'connected', address }, 'health');
+  } catch {
+    return finish({ status: 'error', stage: 'health' }, 'health');
+  }
+}
+
 export interface FirstScreenBandInput {
   readonly width: number;
   readonly daemon: boolean;
+  readonly link?: TuiDaemonLink;
   readonly pwa?: {
     readonly tailnet?: string | null;
     readonly lan?: string | null;
@@ -8,6 +113,31 @@ export interface FirstScreenBandInput {
   };
 }
 
+// The link row contains Hangul (two terminal cells per syllable); count display cells, not UTF-16 units.
+function cellWidth(text: string): number {
+  let width = 0;
+  for (const char of text) {
+    const point = char.codePointAt(0)!;
+    if (point >= 0x1100 && (point <= 0x115f || point >= 0x2329 && point <= 0x232a
+      || point >= 0x2e80 && point <= 0xa4cf || point >= 0xac00 && point <= 0xd7a3
+      || point >= 0xf900 && point <= 0xfaff || point >= 0xfe10 && point <= 0xfe6f
+      || point >= 0xff01 && point <= 0xff60 || point >= 0xffe0 && point <= 0xffe6
+      || point >= 0x1f000 && point <= 0x1ffff)) width += 2;
+    else if (point >= 0x300 && point <= 0x36f || point >= 0xfe00 && point <= 0xfe0f) continue;
+    else width++;
+  }
+  return width;
+}
+
+function fitCells(text: string, limit: number): string {
+  let result = '';
+  for (const char of text) {
+    if (cellWidth(result + char) > limit) break;
+    result += char;
+  }
+  return result;
+}
+
 /** A startup transcript band; never includes credentials or a partial address. */
 export function buildFirstScreenBand(input: FirstScreenBandInput): string[] {
   const width = Number.isFinite(input.width) ? Math.max(0, Math.floor(input.width)) : 0;
@@ -27,8 +157,28 @@ export function buildFirstScreenBand(input: FirstScreenBandInput): string[] {
   const fallback = input.pwa === undefined ? 'PWA: not checked' : 'PWA: unavailable';
   const addressLine = address ? `PWA: ${address}` : fallback;
 
+  const daemonLine = (() => {
+    const link = input.link;
+    if (!link) return `elanous | daemon: ${input.daemon ? 'online' : 'offline'}`;
+    if (link.status === 'checking') return 'elanous | 데몬: 확인 중';
+    if (link.status === 'connected') {
+      let address: string;
+      try {
+        const url = new URL(link.address);
+        address = ['http:', 'https:'].includes(url.protocol) && url.hostname ? url.origin : '';
+      } catch { address = ''; }
+      const line = `elanous | 데몬: 연결됨${address ? ` (${address})` : ''}`;
+      return cellWidth(line) <= width ? line : 'elanous | 데몬: 연결됨';
+    }
+    if (link.status === 'error') return `elanous | 데몬: ${link.stage} 조회 오류`;
+    const bare = `elanous | 데몬: ${link.status === 'absent' ? '없음' : '응답 없음'}`;
+    if (!link.startCommand || CONTROL_CHARS.test(link.startCommand)) return bare;
+    const line = `${bare} · 시작: ${link.startCommand}`;
+    return cellWidth(line) <= width ? line : bare;
+  })();
+
   return [
-    fit(`elanous | daemon: ${input.daemon ? 'online' : 'offline'}`),
+    input.link ? fitCells(daemonLine, width) : fit(daemonLine),
     addressLine.length <= width ? addressLine : fit(address ? 'PWA: address available' : fallback),
     fit('Type a message to begin | /help for commands'),
   ];