elanous 0.2.6 → 0.2.8

package/src/field/field-reel.ts

@@ -0,0 +1,203 @@
+// 한 행사 폴더의 업로드 디바운스와 직렬 렌더. 프로세스 안의 폴더별 단일 실행기.
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { spawn, execFileSync } from 'node:child_process';
+import { debug } from '../debug/log.js';
+import { listFieldMedia } from './field-media.js';
+import { startFieldFeed, type FieldFeedStart } from './field-feed-auto.js';
+
+export interface FieldReelResult { ok: boolean; file?: string; seconds: number; error?: string; feed?: FieldFeedStart }
+export type FieldReelRunner = (dir: string, opts: { title: string; sub: string }) => Promise<FieldReelResult>;
+export interface FieldReelStatus {
+  state: 'waiting' | 'rendering' | 'done' | 'failed';
+  items: number;
+  updatedAt: string;
+  startedAt?: string;
+  finishedAt?: string;
+  seconds?: number;
+  file?: string;
+  error?: string;
+}
+export interface FieldReelOptions {
+  quietMs?: number;
+  title?: string;
+  sub?: string;
+  runner?: FieldReelRunner;
+  onDone?: (result: FieldReelResult) => void | Promise<void>;
+  /** 같은 수신자가 앨범 항목마다 예약해도 한 렌더당 한 번만 통지한다. */
+  notificationKey?: string;
+  /** EV10e — 렌더 성공 뒤 인스타 피드 초안 런을 띄운다(기본 켬 · `false` 나 `ELANOUS_FIELD_FEED_AUTO=0` 이면 끔). */
+  autoFeed?: boolean;
+  /** 시험용 — 피드 시작을 바꿔 끼운다. */
+  startFeed?: (dir: string) => FieldFeedStart;
+}
+
+const REEL_FILE = 'reel-9x16.mp4';
+interface Job {
+  timer?: ReturnType<typeof setTimeout>;
+  running: boolean;
+  dirty: boolean;
+  lastUploadAt: number;
+  opts: FieldReelOptions;
+  callbacks: Map<string, NonNullable<FieldReelOptions['onDone']>>;
+}
+const jobs = new Map<string, Job>();
+
+export function fieldReelFile(dir: string): string { return join(dir, 'reel', REEL_FILE); }
+
+/** 요청 경로용 싼 검사 — 파일이 있고 비어 있지 않다. 디코딩 검사는 렌더가 끝날 때 한 번(`isValidFieldReelFile`)만 한다. */
+export function hasFieldReelFile(file: string): boolean {
+  try {
+    const stat = statSync(file);
+    return stat.isFile() && stat.size > 0;
+  } catch {
+    return false;
+  }
+}
+
+/** Publish only a reel with a decodable video frame, not merely valid-looking MP4 boxes.
+ *  렌더 완료 때 한 번만 부른다 — 첫 영상 프레임 하나만 읽는다(`-read_intervals %+#1`) · 긴 영상도 출력이 작다. */
+export function isValidFieldReelFile(file: string): boolean {
+  try {
+    if (!hasFieldReelFile(file)) return false;
+    const probe = JSON.parse(execFileSync('ffprobe', [
+      '-v', 'error', '-select_streams', 'v:0', '-read_intervals', '%+#1', '-show_streams', '-show_frames',
+      '-show_entries', 'stream=codec_type:frame=media_type', '-of', 'json', file,
+    ], { encoding: 'utf8', timeout: 30_000, maxBuffer: 2 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] })) as {
+      streams?: Array<{ codec_type?: string }>;
+      frames?: Array<{ media_type?: string }>;
+    };
+    return probe.streams?.some((stream) => stream.codec_type === 'video') === true
+      && probe.frames?.some((frame) => frame.media_type === 'video') === true;
+  } catch {
+    return false;
+  }
+}
+/** 상태 파일은 `reel/` «밖»에 둔다 — `reel.sh` 가 시작할 때 `reel/` 을 지우므로 안에 두면 렌더 중에 사라진다. */
+export function fieldReelStatusPath(dir: string): string { return join(dir, '.reel-status.json'); }
+const statusPath = fieldReelStatusPath;
+function writeStatus(dir: string, status: Omit<FieldReelStatus, 'updatedAt'>): void {
+  mkdirSync(dir, { recursive: true });
+  const tmp = join(dir, `.reel-status-${randomUUID()}`);
+  try {
+    writeFileSync(tmp, JSON.stringify({ ...status, updatedAt: new Date().toISOString() }));
+    renameSync(tmp, statusPath(dir));
+  } finally {
+    if (existsSync(tmp)) unlinkSync(tmp);
+  }
+}
+
+export function readFieldReelStatus(dir: string): FieldReelStatus | null {
+  try { return JSON.parse(readFileSync(statusPath(dir), 'utf8')) as FieldReelStatus; }
+  catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return null;
+    throw err;
+  }
+}
+
+export const defaultFieldReelRunner: FieldReelRunner = (dir, { title, sub }) => new Promise((finish) => {
+  const script = resolve(import.meta.dir, '../../skills/explainer-video/engine/reel.sh');
+  const started = Date.now();
+  const child = spawn('zsh', [script, dir, '--title', title, '--sub', sub], { stdio: 'ignore' });
+  let settled = false;
+  const done = (error?: string) => {
+    if (settled) return;
+    settled = true;
+    const file = fieldReelFile(dir);
+    const seconds = Math.round((Date.now() - started) / 1000);
+    // 디코딩 검사(ffprobe)는 `render()` 한 곳에서만 한다 — 여기선 존재만 본다(리뷰: 검사 두 번 금지).
+    finish(error || !hasFieldReelFile(file)
+      ? { ok: false, seconds, error: error ?? `invalid or missing MP4 output: ${file}` }
+      : { ok: true, file, seconds });
+  };
+  child.once('error', (err) => done(err.message));
+  child.once('close', (code) => done(code === 0 ? undefined : `reel.sh exited ${code ?? 'unknown'}`));
+});
+
+function arm(dir: string, job: Job): void {
+  if (job.timer) clearTimeout(job.timer);
+  job.timer = setTimeout(() => {
+    job.timer = undefined;
+    if (!job.running) void render(dir, job);
+  }, Math.max(0, (job.opts.quietMs ?? 20_000) - (Date.now() - job.lastUploadAt)));
+  job.timer.unref?.();
+}
+
+async function render(dir: string, job: Job): Promise<void> {
+  job.running = true;
+  job.dirty = false;
+  const items = listFieldMedia(dir).length;
+  const startedAt = new Date().toISOString();
+  const event = dir.split(/[\\/]/).at(-1)!;
+  // 현재 렌더의 수신자 스냅샷. 렌더 중 업로드의 수신자는 다음 렌더로 넘긴다.
+  const callbacks = job.callbacks;
+  const renderOpts = job.opts;
+  job.callbacks = new Map();
+  writeStatus(dir, { state: 'rendering', items, startedAt });
+  mkdirSync(join(dir, 'reel'), { recursive: true }); // 실행기 계약 — 산출 폴더는 있다(reel.sh 는 스스로 다시 만든다)
+  debug.log('field.reel', 'started', { event, items });
+  let result: FieldReelResult;
+  try {
+    const date = new Date();
+    const sub = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
+    let titleLines: string[] = [];
+    try { titleLines = readFileSync(join(dir, 'title.txt'), 'utf8').split(/\r?\n/); }
+    catch (err) { if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err; }
+    result = await (renderOpts.runner ?? defaultFieldReelRunner)(dir, {
+      title: titleLines[0]?.trim() || renderOpts.title || event,
+      sub: titleLines[1]?.trim() || renderOpts.sub || sub,
+    });
+  } catch (err) {
+    result = { ok: false, seconds: 0, error: err instanceof Error ? err.message : String(err) };
+  }
+  if (result.ok && (!result.file || resolve(result.file) !== fieldReelFile(dir) || !isValidFieldReelFile(result.file))) {
+    result = { ok: false, seconds: result.seconds, error: 'render output invalid or missing' };
+  }
+  const finishedAt = new Date().toISOString();
+  writeStatus(dir, { state: result.ok ? 'done' : 'failed', items, startedAt, finishedAt,
+    seconds: result.seconds, ...(result.ok ? { file: result.file } : { error: result.error ?? 'render failed' }) });
+  debug.log('field.reel', result.ok ? 'done' : 'failed', { event, items, seconds: result.seconds });
+  if (result.ok) {
+    // EV10b: 엔진이 timeline.json 에 남긴 비전 호출 수·성공·«현장 N» 강등·걸린 ms — codex 잔량과 겹치므로 관측한다(OP 10-01).
+    try {
+      const t = JSON.parse(readFileSync(join(dir, 'reel', 'timeline.json'), 'utf8')) as { vision?: Record<string, unknown>; music?: unknown };
+      if (t.vision) debug.log('field.reel', 'vision', { event, ...t.vision, music: t.music === true });
+    } catch { debug.log('field.reel', 'vision-unread', { event }); }
+  }
+  // 뒤이은 업로드로 다시 렌더할 예정이면(dirty) 피드는 그 마지막 렌더 뒤에 한 번만 띄운다.
+  if (result.ok && !job.dirty) result = { ...result, feed: (renderOpts.startFeed ?? ((d: string) => startFieldFeed(d, { enabled: renderOpts.autoFeed })))(dir) };
+  job.running = false;
+  if (job.dirty) {
+    writeStatus(dir, { state: 'waiting', items: listFieldMedia(dir).length });
+    arm(dir, job);
+  } else {
+    jobs.delete(dir);
+  }
+  for (const cb of callbacks.values()) {
+    void Promise.resolve().then(() => cb(result)).catch((err) => {
+      debug.log('field.reel', 'delivery-failed', { event, error: String(err) });
+    });
+  }
+}
+
+/** 저장 성공 직후 호출한다. quiet 기간의 연속 업로드를 합치고 렌더 중 변경은 뒤이어 다시 렌더한다. */
+export function scheduleFieldReel(dir: string, opts: FieldReelOptions = {}): void {
+  dir = resolve(dir);
+  const event = dir.split(/[\\/]/).at(-1)!;
+  let job = jobs.get(dir);
+  if (!job) {
+    job = { running: false, dirty: false, lastUploadAt: Date.now(), opts, callbacks: new Map() };
+    jobs.set(dir, job);
+  }
+  job.opts = { ...opts, runner: opts.runner ?? job.opts.runner, quietMs: opts.quietMs ?? job.opts.quietMs };
+  job.lastUploadAt = Date.now();
+  if (opts.onDone) job.callbacks.set(opts.notificationKey ?? 'default', opts.onDone);
+  const items = listFieldMedia(dir).length;
+  if (job.running) job.dirty = true;
+  else {
+    writeStatus(dir, { state: 'waiting', items });
+    arm(dir, job);
+  }
+  debug.log('field.reel', 'scheduled', { event, items });
+}

package/src/grok/credential.ts

@@ -35,11 +35,13 @@ export const GROK_SUBSCRIPTION_BASE_URL = 'https://cli-chat-proxy.grok.com/v1';
 /** API 키 경로 베이스(토큰 과금). */
 export const GROK_API_BASE_URL = 'https://api.x.ai/v1';
 
-/** 프록시가 요구하는 최소 CLI 버전(실측 426 문면). 이보다 낮으면 거절된다. */
-export const GROK_PROXY_MIN_CLI_VERSION = '0.1.202';
-/** 설치본을 못 읽었을 때 신고할 값. ⛔ 하한을 쓰면 프록시가 하한을 «올리는» 날
- *  전부 426 이 된다 — 그래서 아래 `detectGrokCliVersion()` 이 1순위다. */
-const GROK_PROXY_FALLBACK_CLI_VERSION = GROK_PROXY_MIN_CLI_VERSION;
+/** 프록시가 요구하는 최소 CLI 버전(실측 426 문면). 이보다 낮으면 거절된다.
+ *  2026-10-01 실측: «Your Grok CLI version (0.1.202) is outdated. Please update to version 1.0.13 or later». */
+export const GROK_PROXY_MIN_CLI_VERSION = '1.0.13';
+/** 설치본을 못 읽었을 때(grok CLI 없는 기계 · 파드) 신고할 값 — 하한이 아니라 실측된 최근 설치본.
+ *  ⛔ 하한을 쓰면 프록시가 하한을 «올리는» 날 전부 426 이 된다(10-01 파드 자식이 0.1.202 로 전부 거절됨).
+ *  그래서 아래 `detectGrokCliVersion()` 이 1순위다. */
+const GROK_PROXY_FALLBACK_CLI_VERSION = '1.0.41';
 
 /** 설치된 grok CLI 의 버전. ⭐ 하드코딩 하한 대신 «실제 설치본»을 신고한다.
  *

package/src/harness/aside-run-status.ts

@@ -0,0 +1,33 @@
+import { stripScreenAnsi } from './harness-screen.js';
+
+export type AsideRunStatus = {
+  kind: 'ok' | 'not-running' | 'auth-timeout' | 'repl-error' | 'no-marker';
+  hint?: string;
+};
+
+export function classifyAsideRun({ stdout, stderr, exitCode, timedOut = false }: {
+  stdout: string;
+  stderr: string;
+  exitCode: number | null;
+  /** We killed `aside` at our own timeout. */
+  timedOut?: boolean;
+}): AsideRunStatus {
+  const diagnosticStdout = stripScreenAnsi(stdout).split(/\r?\n/).filter((line) => {
+    try { JSON.parse(line.trim()); return false; } catch { return true; }
+  }).join('\n');
+  const diagnostics = `${diagnosticStdout}\n${stripScreenAnsi(stderr)}`;
+  if (exitCode !== 0 && /Aside isn't running/i.test(diagnostics)) {
+    return { kind: 'not-running', hint: 'Aside 브라우저가 안 떠 있음 — Aside 브라우저를 켜고 다시 · 또는 `aside exec --host <host>`' };
+  }
+  if (exitCode !== 0 && /daemon auth challenge/i.test(diagnostics) && /timeout|timed out/i.test(diagnostics)) {
+    return { kind: 'auth-timeout', hint: 'Aside 인증 요청 시간 초과 — Aside 브라우저를 켜고 다시 · 또는 `aside exec --host <host>`' };
+  }
+  // Killed by our timeout with nothing printed: aside never answered — the browser daemon is not reachable.
+  if (timedOut && !stripScreenAnsi(stdout).trim()) {
+    return { kind: 'auth-timeout', hint: 'Aside 가 응답하지 않음 — Aside 브라우저가 떠 있는지 확인하고 다시 · 또는 `aside exec --host <host>`' };
+  }
+  const marker = stripScreenAnsi(stdout).trimEnd().match(/\[(ok|error)\s*\|[^\]]+\]\s*$/);
+  if (marker?.[1] === 'error') return { kind: 'repl-error' };
+  if (marker?.[1] === 'ok') return { kind: 'ok' };
+  return { kind: 'no-marker' };
+}

package/src/harness/browser-verify.ts

@@ -16,9 +16,12 @@ import { createCdpClientFromEndpoint, CdpUnavailable, type CdpClient } from '../
 import { captureWithTimeout, describeCaptureFailure } from './browser-capture-timeout.js';
 import { debug } from '../debug/log.js';
 import { stripScreenAnsi } from './harness-screen.js';
+import { classifyAsideRun, type AsideRunStatus } from './aside-run-status.js';
+import { IMAGE_LOAD_STATE_SOURCE } from './image-load-state.js';
 
 const execFileAsync = promisify(execFile);
-const DEFAULT_ASIDE_TIMEOUT_MS = 10_000;
+// Longer than aside's own ~10 s daemon auth-challenge timeout, so «Aside isn't running» reaches stderr before we kill it (10-01 live).
+const DEFAULT_ASIDE_TIMEOUT_MS = 30_000;
 // Observed load events and complete page content arrive within this window; timeout remains non-blocking.
 const CDP_LOAD_WAIT_TIMEOUT_MS = 3_000;
 
@@ -74,6 +77,8 @@ export interface DeployVerifyResult {
   title?: string;
   bodyLength?: number;
   screenshotBytes?: number;
+  /** 아직 화면 밖이라 요청되지 않은 lazy 그림 수(실패가 아님). */
+  pendingLazyImages?: number;
   /** 렌더 문제(빈 페이지·에러 등). ok=false 면 최소 1건. */
   findings: string[];
   /** findings와 병행하는 등급 있는 판정. 정상·CDP 미가용 결과에는 생략해 기존 결과 모양을 보존한다. */
@@ -81,10 +86,10 @@ export interface DeployVerifyResult {
   /** 측정하지 못한 선택적 신호. 빈 배열은 생략하므로 문제 없음과 구별된다. */
   unmeasured?: DeployUnmeasuredCheck[];
   /** 관측 백엔드 미가용으로 검증 스킵됨(배포는 막지 않음). */
-  skipped?: 'no-cdp' | 'no-aside';
+  skipped?: 'no-cdp' | 'no-aside' | 'aside-not-running';
 }
 
-export type AsideRunner = (command: string, args: string[], options: { timeout: number }) => Promise<{ stdout: string }>;
+export type AsideRunner = (command: string, args: string[], options: { timeout: number }) => Promise<{ stdout: string; stderr?: string; exitCode?: number | null; timedOut?: boolean }>;
 
 export interface DeployVerifyDeps {
   /** 기본 CDP 또는 별도 브라우저 세션을 쓰는 aside. */
@@ -121,9 +126,18 @@ interface PageState {
   title: string;
   bodyLength: number;
   unloadedImageCount: number;
+  pendingLazyImages: number;
   consecutiveDuplicateText: string | null;
 }
 
+const IMAGE_COUNTS_EXPRESSION = `(${IMAGE_LOAD_STATE_SOURCE})(Array.from(document.images, (image) => {
+  const rect = image.getBoundingClientRect();
+  return {
+    complete: image.complete, naturalWidth: image.naturalWidth, loading: image.loading,
+    inViewport: rect.bottom > 0 && rect.right > 0 && rect.top < window.innerHeight && rect.left < window.innerWidth,
+  };
+}))`;
+
 const PAGE_STATE_EXPRESSION = `(() => {
   const isVisible = (element) => {
     for (let current = element; current; current = current.parentElement) {
@@ -141,10 +155,12 @@ const PAGE_STATE_EXPRESSION = `(() => {
     }
   }
   const consecutiveDuplicateText = textUnits.find((text, index) => text === textUnits[index + 1]) ?? null;
+  const imageCounts = ${IMAGE_COUNTS_EXPRESSION};
   return {
     title: document.title,
     bodyLength: document.body ? document.body.innerText.length : 0,
-    unloadedImageCount: Array.from(document.images).filter((image) => !image.complete || image.naturalWidth === 0).length,
+    unloadedImageCount: imageCounts.broken,
+    pendingLazyImages: imageCounts.pendingLazy,
     consecutiveDuplicateText,
   };
 })()`;
@@ -169,7 +185,7 @@ function buildAsideScript(url: string): string {
     '  const page = await openTab(url);',
     '  try {',
     '    const title = await page.title();',
-    "    const state = await page.evaluate(() => ({ bodyLength: document.body?.innerText.length ?? 0, unloadedImageCount: Array.from(document.images).filter((image) => !image.complete || image.naturalWidth === 0).length }));",
+    `    const state = await page.evaluate(() => { const imageCounts = ${IMAGE_COUNTS_EXPRESSION}; return { bodyLength: document.body?.innerText.length ?? 0, unloadedImageCount: imageCounts.broken, pendingLazyImages: imageCounts.pendingLazy }; });`,
     '    const screenshot = await page.screenshot({ fullPage: true });',
     '    console.log(JSON.stringify({ title, ...state, screenshotBytes: screenshot?.length ?? 0 }));',
     '  } finally { try { await closeTab(page); } catch {} }',
@@ -177,7 +193,7 @@ function buildAsideScript(url: string): string {
   ].join('\n');
 }
 
-function parseAsideObservation(stdout: string): { title: string; bodyLength: number; unloadedImageCount: number; screenshotBytes: number } {
+function parseAsideObservation(stdout: string): { title: string; bodyLength: number; unloadedImageCount: number; pendingLazyImages: number; screenshotBytes: number } {
   const normalizedStdout = stripScreenAnsi(stdout);
   const verdict = normalizedStdout.trimEnd().match(/\[(ok|error)\s*\|[^\]]+\]\s*$/);
   if (!verdict) throw new Error('aside observation output missing completion marker');
@@ -189,16 +205,17 @@ function parseAsideObservation(stdout: string): { title: string; bodyLength: num
       const result: unknown = JSON.parse(line.trim());
       parsedJson = true;
       if (!result || typeof result !== 'object' || Array.isArray(result)) throw new Error('aside observation JSON must be an object');
-      const { title, bodyLength, unloadedImageCount, screenshotBytes } = result as Record<string, unknown>;
+      const { title, bodyLength, unloadedImageCount, pendingLazyImages = 0, screenshotBytes } = result as Record<string, unknown>;
       if (
         typeof title !== 'string'
         || typeof bodyLength !== 'number' || !Number.isFinite(bodyLength) || bodyLength < 0
         || typeof unloadedImageCount !== 'number' || !Number.isFinite(unloadedImageCount) || unloadedImageCount < 0
+        || typeof pendingLazyImages !== 'number' || !Number.isFinite(pendingLazyImages) || pendingLazyImages < 0
         || typeof screenshotBytes !== 'number' || !Number.isFinite(screenshotBytes) || screenshotBytes < 0
       ) {
         throw new Error('aside observation JSON has invalid required fields');
       }
-      return { title, bodyLength, unloadedImageCount, screenshotBytes };
+      return { title, bodyLength, unloadedImageCount, pendingLazyImages, screenshotBytes };
     } catch (error) {
       if (parsedJson) throw error;
     }
@@ -206,9 +223,9 @@ function parseAsideObservation(stdout: string): { title: string; bodyLength: num
   throw new Error('aside observation output missing JSON');
 }
 
-function asideErrorResult(url: string, error: unknown): DeployVerifyResult {
+function asideErrorResult(url: string, error: unknown, kind?: AsideRunStatus['kind']): DeployVerifyResult {
   const message = error instanceof Error ? error.message : String(error);
-  const errorFinding = finding('aside-error', `aside 검증 오류: ${message.slice(0, 120)}`, 'confirmed');
+  const errorFinding = finding('aside-error', `aside 검증 오류: ${message.slice(0, 120)}${kind ? ` (${kind})` : ''}`, 'confirmed');
   observe('verify-aside-failed', { url: url.slice(0, 80), error: message.slice(0, 120) });
   return { ok: false, url, findings: [errorFinding.message], structuredFindings: [errorFinding], unmeasured: ['javascript-errors'] };
 }
@@ -224,15 +241,21 @@ async function verifyAsidePage(url: string, deps: DeployVerifyDeps): Promise<Dep
     const runAside = deps.runAside ?? (async (command, args, options) => {
       try {
         const result = await execFileAsync(command, args, { ...options, encoding: 'utf8' });
-        return { stdout: result.stdout };
+        return { stdout: result.stdout, stderr: result.stderr, exitCode: 0 };
       } catch (error) {
         if ((error as NodeJS.ErrnoException).code === 'ENOENT') throw error;
-        const stdout = (error as { stdout?: unknown }).stdout;
-        if (typeof stdout === 'string') return { stdout };
+        const { stdout, stderr, code, killed, signal } = error as { stdout?: unknown; stderr?: unknown; code?: unknown; killed?: unknown; signal?: unknown };
+        if (typeof stdout === 'string' || typeof stderr === 'string') {
+          return {
+            stdout: typeof stdout === 'string' ? stdout : '', stderr: typeof stderr === 'string' ? stderr : '',
+            exitCode: typeof code === 'number' ? code : null,
+            ...(killed === true || typeof signal === 'string' ? { timedOut: true } : {}),
+          };
+        }
         throw error;
       }
     });
-    let observation: { stdout: string };
+    let observation: Awaited<ReturnType<AsideRunner>>;
     try {
       observation = await runAside(deps.asideCommand ?? 'aside', ['repl', script], { timeout: deps.asideTimeoutMs ?? DEFAULT_ASIDE_TIMEOUT_MS });
     } catch (error) {
@@ -242,13 +265,20 @@ async function verifyAsidePage(url: string, deps: DeployVerifyDeps): Promise<Dep
       }
       return asideErrorResult(url, error);
     }
+    const status = classifyAsideRun({ stdout: observation.stdout, stderr: observation.stderr ?? '', exitCode: observation.exitCode ?? null, timedOut: observation.timedOut === true });
+    if (status.kind === 'not-running' || status.kind === 'auth-timeout') {
+      observe('verify-aside-skipped', { url, kind: status.kind });
+      return { ok: false, url, skipped: 'aside-not-running', findings: [status.hint ?? 'Aside 브라우저를 켜고 다시'], unmeasured: ['javascript-errors', 'screenshot'] };
+    }
+    if (status.kind === 'repl-error') return asideErrorResult(url, new Error('aside repl reported error'), status.kind);
+    if (status.kind === 'no-marker') return asideErrorResult(url, new Error('aside observation output missing completion marker'), status.kind);
     const state = parseAsideObservation(observation.stdout);
     const structuredFindings: DeployVerifyFinding[] = [];
     if (state.bodyLength < minBody) structuredFindings.push(finding('empty-body', `페이지 본문이 비어있음(len=${state.bodyLength}·렌더 실패 의심)`, 'suspected'));
     if (state.unloadedImageCount) structuredFindings.push(finding('unloaded-image', `로드되지 못한 그림 ${state.unloadedImageCount}개`, 'confirmed'));
     if (!state.title.trim()) structuredFindings.push(finding('empty-title', '문서 제목이 비어있음', 'confirmed'));
     const findings = structuredFindings.map(({ message }) => message);
-    const result: DeployVerifyResult = { ok: findings.length === 0, url, title: state.title, bodyLength: state.bodyLength, screenshotBytes: state.screenshotBytes, findings, unmeasured: ['javascript-errors'], ...(structuredFindings.length ? { structuredFindings } : {}) };
+    const result: DeployVerifyResult = { ok: findings.length === 0, url, title: state.title, bodyLength: state.bodyLength, screenshotBytes: state.screenshotBytes, findings, unmeasured: ['javascript-errors'], ...(state.pendingLazyImages ? { pendingLazyImages: state.pendingLazyImages } : {}), ...(structuredFindings.length ? { structuredFindings } : {}) };
     observe('verified-aside', { url: url.slice(0, 80), ok: result.ok, bodyLength: state.bodyLength, bytes: state.screenshotBytes, findings: findings.length, unmeasured: result.unmeasured });
     return result;
   } catch (error) {
@@ -334,6 +364,7 @@ async function verifyCdpPage(url: string, deps: DeployVerifyDeps): Promise<Deplo
     return {
       ok, url, title, bodyLength, screenshotBytes: buf?.length ?? 0, findings,
       ...(structuredFindings.length ? { structuredFindings } : {}),
+      ...(state?.pendingLazyImages ? { pendingLazyImages: state.pendingLazyImages } : {}),
       ...(unmeasured ? { unmeasured } : {}),
     };
   } catch (e) {
@@ -362,9 +393,9 @@ export function formatVerifyUrlReport(
   const shotNote = shot === undefined ? '' : shot.written ? ` → ${shot.path}` : ` → ⛔ 못 씀(${shot.path})`;
   const lines = [
     `\n━━ 배포 검증: ${url} ━━`,
-    `  ${result.ok ? '✅ 렌더 정상' : '⚠️ 문제 감지'}`,
+    `  ${result.skipped === 'aside-not-running' ? '⚪ Aside 검증 건너뜀' : result.ok ? '✅ 렌더 정상' : '⚠️ 문제 감지'}`,
     `  title: ${result.title || '(없음)'}`,
-    `  본문 길이: ${result.bodyLength ?? '?'} · 스크린샷: ${result.screenshotBytes ?? 0} bytes${shotNote}`,
+    `  본문 길이: ${result.bodyLength ?? '?'} · 스크린샷: ${result.skipped === 'aside-not-running' ? '못 쟀다' : `${result.screenshotBytes ?? 0} bytes`}${shotNote}`,
   ];
   for (const f of result.findings) lines.push(`  - ${f}`);
   // ⛔⭐ 「못 쟀다」는 초록도 빨강도 아닌 «제 칸»이다 — 「없다」로 접지 않는다.

package/src/harness/harness-cli-command.ts

@@ -21,6 +21,7 @@ import { getUserConfig } from '../user-config.js';
 import { installHarnessCliSinkHook } from './harness-cli-sink.js';
 import { resolveHarnessSubstrate, type ResolvedHarnessSubstrate } from './harness-substrate-default.js';
 import { runHarnessPlanRfc } from './harness-plan-rfc.js';
+import { classifyGarbage, isGarbageProcessTarget, type GarbageProcess } from './process-garbage.js';
 import type { MissionSolveOutcome } from './mission-solve-loop.js';
 import { formatAxis, formatAxisObservations, inspectAskMarkers, inspectUnpressedDecisionSignals } from '../../scripts/ask-marker-check.js';
 
@@ -75,6 +76,7 @@ export class HarnessCliInputError extends Error {
   constructor(message: string) {
     super(message);
     this.name = 'HarnessCliInputError';
+    Object.defineProperty(this, Symbol.for('elanous.cli.HarnessCliInputError'), { value: true });
   }
 }
 
@@ -565,6 +567,7 @@ export interface HarnessProcessReport {
   readonly resourceConsuming: readonly HarnessProcessObservationRow[];
   readonly longRunningOnly: readonly HarnessProcessObservationRow[];
   readonly parentUnknown: readonly HarnessProcessObservationRow[];
+  readonly garbage: readonly GarbageProcess[];
 }
 
 export interface HarnessProcessObservationDeps {
@@ -762,16 +765,22 @@ export function buildHarnessProcessReport(
       resourceConsuming: [],
       longRunningOnly: [],
       parentUnknown: [],
+      garbage: [],
     };
   }
   const livePids = new Set(listed.livePids ?? listed.records.map((record) => record.pid));
   const universe = listed.pidUniverse ?? pidUniverse;
+  const garbage = classifyGarbage(listed.records.map((record) => ({
+    ...record,
+    launchd: resolveHarnessProcessLaunchdEvidence(record.pid, launchd),
+  })), { nowMs }).garbage;
   const resourceConsuming: HarnessProcessObservationRow[] = [];
   const longRunningOnly: HarnessProcessObservationRow[] = [];
   const parentUnknown: HarnessProcessObservationRow[] = [];
   let unclassifiedCount = 0;
   let parentPresentCount = 0;
   for (const record of listed.records) {
+    if (!record.command.includes('elanous.mjs')) continue;
     const classification = classifyHarnessProcess(record, thresholds);
     if (classification === undefined) {
       unclassifiedCount += 1;
@@ -811,6 +820,7 @@ export function buildHarnessProcessReport(
       resourceConsuming,
       longRunningOnly,
       parentUnknown,
+      garbage,
     };
   }
   return {
@@ -822,6 +832,7 @@ export function buildHarnessProcessReport(
     resourceConsuming,
     longRunningOnly,
     parentUnknown,
+    garbage,
   };
 }
 
@@ -855,6 +866,13 @@ function renderHarnessProcessRow(row: HarnessProcessObservationRow): string[] {
   ];
 }
 
+function renderGarbageGroup(garbage: readonly GarbageProcess[]): string[] {
+  return [
+    `가비지 ${garbage.length}:`,
+    ...garbage.map((row) => `- pid=${row.pid} ppid=${row.ppid} elapsed=${formatHarnessProcessElapsed(row.elapsedSeconds)} reason=${row.reason} command=${row.command.slice(0, 120)}`),
+  ];
+}
+
 export function renderHarnessProcessReport(report: HarnessProcessReport): string[] {
   const { resourceCpuPercent, longRunningElapsedSeconds } = report.thresholds;
   const lines = [
@@ -868,6 +886,7 @@ export function renderHarnessProcessReport(report: HarnessProcessReport): string
     const failure = report.observationFailure;
     lines.push(`관찰 실패/확인 불가 (${failure?.stage ?? 'ps-exec'}: ${failure?.reason ?? 'unknown observation failure'})`);
     lines.push('자원소비와 장기실행만은 확인하지 않았다 — 빈 관찰이 아니다');
+    lines.push('가비지 확인 불가 — ps 관찰 실패');
     return lines;
   }
   if (report.observationStatus === 'incomplete') {
@@ -877,7 +896,7 @@ export function renderHarnessProcessReport(report: HarnessProcessReport): string
   }
   if (report.excludedCount > 0) {
     lines.push(`모집단 제외 ${report.excludedCount}행`);
-    lines.push('제외 기준: command에 elanous.mjs를 포함하지 않은 행');
+    lines.push('제외 기준: command에 elanous.mjs가 없고 시험 데몬·러너 대상도 아닌 행');
   }
   lines.push(`분류 제외 ${report.unclassifiedCount}행`);
   lines.push(`부모 생존 제외 ${report.parentPresentCount}행`);
@@ -885,11 +904,13 @@ export function renderHarnessProcessReport(report: HarnessProcessReport): string
   if (report.parentUnknown.length > 0) lines.push(`부모 확인 불가 ${report.parentUnknown.length} — 자원소비/장기실행만에 넣지 않았다`);
   const empty = report.resourceConsuming.length === 0 && report.longRunningOnly.length === 0 && report.parentUnknown.length === 0;
   if (empty && report.observationStatus === 'ok') {
-    lines.push('관찰 대상 없음');
+    if (report.garbage.length === 0) lines.push('관찰 대상 없음');
+    lines.push(...renderGarbageGroup(report.garbage));
     return lines;
   }
   if (empty && report.observationStatus === 'incomplete') {
     lines.push('해석된 행 중 분류 대상이 없다 — 빈 관찰이 아니다');
+    lines.push(...renderGarbageGroup(report.garbage));
     return lines;
   }
   if (report.resourceConsuming.length > 0) {
@@ -904,6 +925,7 @@ export function renderHarnessProcessReport(report: HarnessProcessReport): string
     lines.push('부모 확인 불가:');
     for (const row of report.parentUnknown) lines.push(...renderHarnessProcessRow(row));
   }
+  lines.push(...renderGarbageGroup(report.garbage));
   return lines;
 }
 
@@ -944,7 +966,7 @@ function parseHarnessProcessPsLine(line: string): ParsedHarnessProcessPsLine {
   if (!match) return { kind: 'malformed', line: trimmed, pid: parseHarnessProcessPsPid(line) };
   const command = match[5]!.trim();
   const pid = Number(match[1]);
-  if (!command.includes('elanous.mjs')) return { kind: 'excluded', pid };
+  if (!isGarbageProcessTarget(command)) return { kind: 'excluded', pid };
   const elapsedSeconds = parsePsEtime(match[4]!);
   if (elapsedSeconds === undefined) return { kind: 'malformed', line: trimmed, pid };
   return {

package/src/harness/image-load-state.ts

@@ -0,0 +1,21 @@
+export interface ImageLoadState {
+  complete: boolean;
+  naturalWidth: number;
+  loading: string;
+  inViewport: boolean;
+}
+
+/** Shared by Node tests and the injected browser expression. */
+export function classifyImages(images: ImageLoadState[]): { broken: number; pendingLazy: number } {
+  let broken = 0;
+  let pendingLazy = 0;
+  for (const image of images) {
+    if (image.complete && image.naturalWidth === 0) broken++;
+    else if (!image.complete && image.loading === 'lazy' && !image.inViewport) pendingLazy++;
+    else if (!image.complete) broken++;
+  }
+  return { broken, pendingLazy };
+}
+
+/** Executable function source for CDP and aside, without a module import in the page. */
+export const IMAGE_LOAD_STATE_SOURCE = classifyImages.toString();

package/src/harness/process-garbage.ts

@@ -0,0 +1,45 @@
+export interface GarbageProcessRow {
+  readonly pid: number;
+  readonly ppid: number;
+  readonly elapsedSeconds: number;
+  readonly command: string;
+  readonly launchd?: 'managed' | 'no-evidence' | 'unqueried';
+}
+
+export interface GarbageProcess extends Pick<GarbageProcessRow, 'pid' | 'ppid' | 'elapsedSeconds' | 'command'> {
+  readonly reason: 'orphan-test-daemon' | 'orphan-test-runner' | 'orphan-elanous';
+}
+
+const TEST_PATH = /elanous|repo\.worktrees|self-impl|\.elanous-test|gate-baseline/i;
+const TEST_DAEMON = /(?:^|[\s/])daemon\.ts(?:\s|$)/;
+const TEST_RUNNER = /\bbun\s+test\b|\bgate(?:[-\s]baseline|\b)/i;
+const NEXUS_RUN = /\bnexus\s+run\b/;
+const TEST_MARKER = /\.elanous-test|(?:^|\s)--test(?:\s|$)/;
+
+/** A candidate for inspection only; this module never signals or removes a process. */
+export function isGarbageProcessTarget(command: string): boolean {
+  return command.includes('elanous.mjs')
+    || (TEST_DAEMON.test(command) && /elanous-nexus-|\.elanous-test/.test(command))
+    || (TEST_RUNNER.test(command) && TEST_PATH.test(command));
+}
+
+export function classifyGarbage(
+  rows: readonly GarbageProcessRow[],
+  options: { nowMs?: number; minOrphanSeconds?: number } = {},
+): { garbage: GarbageProcess[] } {
+  const minOrphanSeconds = options.minOrphanSeconds ?? 3 * 60 * 60;
+  const garbage: GarbageProcess[] = [];
+  for (const row of rows) {
+    if (row.ppid !== 1 || row.elapsedSeconds < minOrphanSeconds || row.launchd === 'managed') continue;
+    if (!isGarbageProcessTarget(row.command)) continue;
+    if (NEXUS_RUN.test(row.command) && !TEST_MARKER.test(row.command)) continue;
+    const reason: GarbageProcess['reason'] = TEST_DAEMON.test(row.command)
+      && /elanous-nexus-|\.elanous-test/.test(row.command)
+      ? 'orphan-test-daemon'
+      : TEST_RUNNER.test(row.command) && TEST_PATH.test(row.command)
+        ? 'orphan-test-runner'
+        : 'orphan-elanous';
+    garbage.push({ pid: row.pid, ppid: row.ppid, elapsedSeconds: row.elapsedSeconds, command: row.command, reason });
+  }
+  return { garbage };
+}