elanous 0.2.29 → 0.2.32

package/scripts/intake-social.ts

@@ -0,0 +1,181 @@
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { effectiveInstanceRoot } from '../src/instance/resolve.js';
+import { canonicalUrl } from '../src/intake-plane/items.js';
+
+export interface CommunityPoint { title: string; url: string; text: string }
+export interface SocialCheck { items: { fact: string; line: string; verdict: string; current: string }[] }
+export interface SocialDeps {
+  now?: () => Date;
+  crawl?: () => Promise<CommunityPoint[]>;
+  check?: (facts: readonly string[]) => Promise<SocialCheck>;
+  log?: (message: string) => void;
+}
+
+const QUERY = '최근 24시간 AI 코딩 에이전트·하니스·로컬 LLM 커뮤니티(X·Reddit) 화제와 반응';
+const MAX_POINTS = 8;
+// URL 을 뺀 뒤 남는 서술의 최소 길이 — «링크만 있는 줄» 같은 레이블은 내용 없는 동향이라 흡수하지 않는다.
+const MIN_TREND_TEXT_LENGTH = 12;
+const OMNI_JSON_BEGIN = '---BEGIN_OMNI_CRAWL_JSON---';
+const OMNI_JSON_END = '---END_OMNI_CRAWL_JSON---';
+
+/** grok-community rawText(마크다운 보고서)에서 불릿/번호 줄만 뽑아 링크 있는 동향 점으로 만든다. */
+export function parseCommunityReport(rawText: string): CommunityPoint[] {
+  const points: CommunityPoint[] = [];
+  for (const rawLine of rawText.split('\n')) {
+    const line = rawLine.trim();
+    if (!/^(?:[-*•·]|\d{1,2}[.)])\s+/.test(line)) continue;
+    const url = line.match(/https?:\/\/[^\s)\]]+/)?.[0];
+    if (!url) continue;
+    const text = line
+      .replace(/^(?:[-*•·]|\d{1,2}[.)])\s+/, '')
+      .replace(/\[([^\]]*)\]\(https?:\/\/[^)]*\)/g, '$1')
+      .replace(/\*\*([^*]+)\*\*/g, '$1')
+      .replace(/\*([^*]+)\*/g, '$1')
+      .replace(/https?:\/\/\S+/g, '')
+      .replace(/\s+/g, ' ')
+      .trim();
+    if (text.length < MIN_TREND_TEXT_LENGTH) continue;
+    points.push({ title: text.slice(0, 120), url, text });
+  }
+  return points;
+}
+
+/** omni-crawl `--json` 페이로드(results[].items ⊕ results[].summary)에서 커뮤니티 동향 점을 합친다. URL 로 중복을 뺀다. */
+export function parseOmniCrawlPayload(payload: { results?: { items?: { url?: unknown; title?: unknown; text?: unknown }[]; summary?: unknown }[] }): CommunityPoint[] {
+  const points: CommunityPoint[] = [];
+  const urls = new Set<string>();
+  for (const result of payload.results ?? []) {
+    const fromItems = (result.items ?? []).flatMap((item) => {
+      const url = typeof item.url === 'string' && /^https?:\/\//.test(item.url) ? item.url : '';
+      const title = typeof item.title === 'string' ? item.title.trim() : '';
+      const text = typeof item.text === 'string' ? item.text.trim() : '';
+      return url && (title || text) ? [{ title: (title || text).slice(0, 120), url, text: text || title }] : [];
+    });
+    const fromSummary = parseCommunityReport(typeof result.summary === 'string' ? result.summary : '');
+    for (const point of [...fromItems, ...fromSummary]) {
+      const key = canonicalUrl(point.url) ?? point.url;
+      if (urls.has(key)) continue;
+      urls.add(key);
+      points.push(point);
+    }
+  }
+  return points;
+}
+
+/** omni-crawl 스킬의 grok-community 엔진을 실제로 돌린다(스킬 .env 를 엔진이 알아서 적재한다). */
+async function crawlWithOmniCrawl(): Promise<CommunityPoint[]> {
+  const dir = process.env.OMNI_CRAWL_DIR || join(homedir(), '.claude', 'skills', 'omni-crawl');
+  if (!existsSync(dir)) throw new Error(`omni-crawl 스킬 디렉터리 없음: ${dir}`);
+  const result = spawnSync('bun', ['scripts/main.ts', QUERY, '--engine', 'grok-community', '--json', '--no-save'], {
+    cwd: dir, encoding: 'utf8', timeout: 600_000, maxBuffer: 32 * 1024 * 1024,
+  });
+  if (result.error || result.status !== 0) throw new Error(result.error?.message ?? result.stderr?.trim() ?? `omni-crawl exited ${result.status}`);
+  const begin = result.stdout.indexOf(OMNI_JSON_BEGIN);
+  const end = result.stdout.lastIndexOf(OMNI_JSON_END);
+  if (begin < 0 || end <= begin) throw new Error('omni-crawl JSON 마커 없음');
+  return parseOmniCrawlPayload(JSON.parse(result.stdout.slice(begin + OMNI_JSON_BEGIN.length, end)) as Parameters<typeof parseOmniCrawlPayload>[0]);
+}
+
+/** 함의 판정은 로컬 흉내가 아니라 CLI(intake check) 가 정본이다. 칸이나 판을 바꾸지 않는다. */
+async function checkWithCli(facts: readonly string[]): Promise<SocialCheck> {
+  const result = spawnSync('bun', ['bin/elanous.mjs', '--test', 'intake', 'check', ...facts.flatMap((fact) => ['--fact', fact]), '--json'], {
+    cwd: resolve(import.meta.dir, '..'), encoding: 'utf8', timeout: 120_000, maxBuffer: 4 * 1024 * 1024,
+  });
+  if (result.error || result.status !== 0) throw new Error(result.error?.message ?? result.stderr?.trim() ?? `intake check exited ${result.status}`);
+  const start = result.stdout.indexOf('{');
+  if (start < 0) throw new Error('intake check JSON 없음');
+  const parsed = JSON.parse(result.stdout.slice(start)) as SocialCheck;
+  if (!Array.isArray(parsed.items)) throw new Error('intake check items 없음');
+  return parsed;
+}
+
+function splitSentences(text: string): string[] {
+  const clean = text.replace(/\s+/g, ' ').trim();
+  if (!clean) return [];
+  return clean.split(/(?<=[.!?。])\s+/).map((sentence) => sentence.trim()).filter(Boolean)
+    .map((sentence) => sentence.slice(0, 240)).slice(0, 5);
+}
+
+export async function runIntakeSocial(options: { root: string; deps?: SocialDeps }): Promise<{ written: number; failed: number }> {
+  const { root, deps = {} } = options;
+  const log = deps.log ?? ((message: string) => console.error(message));
+  const now = (deps.now ?? (() => new Date()))();
+  const day = new Date(now.getTime() + 9 * 3600_000).toISOString().slice(0, 10);
+  const state = join(root, 'intake', 'social-seen.jsonl');
+  const lens = join(root, 'intake', 'outbox', 'lens', `${day}.jsonl`);
+  const seen = new Set(existsSync(state) ? readFileSync(state, 'utf8').split('\n').filter(Boolean) : []);
+  // 렌즈에 이미 쓴 동향도 «본 것» — 상태 기록이 죽어도 재실행이 같은 점을 다시 쓰지 않는다(24h 창이라 어제·오늘 파일).
+  const yesterday = new Date(now.getTime() + 9 * 3600_000 - 86_400_000).toISOString().slice(0, 10);
+  for (const lensDay of [yesterday, day]) {
+    const file = join(root, 'intake', 'outbox', 'lens', `${lensDay}.jsonl`);
+    if (!existsSync(file)) continue;
+    for (const line of readFileSync(file, 'utf8').split('\n')) {
+      try { const id = (JSON.parse(line) as { id?: unknown }).id; if (typeof id === 'string') seen.add(id); } catch { /* 깨진 줄은 건너뛴다 */ }
+    }
+  }
+  let written = 0;
+  let failed = 0;
+  const crawl = deps.crawl ?? crawlWithOmniCrawl;
+  let points: CommunityPoint[] = [];
+  try {
+    points = await crawl();
+  } catch (error) {
+    failed++;
+    log(`못 모음: grok-community — ${error instanceof Error ? error.message : String(error)}`);
+    return { written, failed };
+  }
+  for (const point of points) {
+    if (written >= MAX_POINTS) break;
+    if (!/^https?:\/\//.test(point.url)) continue;
+    const id = createHash('sha256').update(canonicalUrl(point.url) ?? point.url).digest('hex').slice(0, 16);
+    if (seen.has(id)) continue;
+    try {
+      const summary = splitSentences(point.text);
+      if (!summary.length) throw new Error('요약 줄 없음');
+      // 동향 자체는 기능 주장이 아니다. 제목과 본문에 실제로 적힌 제품 주장만 추가로 대조한다.
+      const isProductClaim = (fact: string) => /^(?:elanous|엘라누스)\s*(?:는|은)\s+/i.test(fact);
+      const facts = [...new Set([
+        ...summary.slice(0, 2),
+        ...splitSentences(point.title).filter(isProductClaim),
+        ...summary.filter(isProductClaim),
+      ])];
+      const check = await (deps.check ?? checkWithCli)(facts);
+      if (!check.items.length) throw new Error('intake check 항목 없음');
+      const productClaims = new Set(facts.filter(isProductClaim));
+      const judgedClaims = check.items.filter((item) => productClaims.has(item.fact));
+      const suggestions = judgedClaims.filter((item) => item.verdict === '없음' || item.verdict === '판단 필요')
+        .map((item) => ({ kind: '칸 제안', fact: item.fact, status: '제안', verdict: item.verdict }));
+      const verdict = suggestions.length ? '보강'
+        : judgedClaims.length && !judgedClaims.every((item) => item.verdict === '있음') ? '경쟁 대조' : '참고';
+      const implication = facts.map((fact) => productClaims.has(fact)
+        ? check.items.find((item) => item.fact === fact)?.line ?? `점검 결과 없음: ${fact}`
+        : `커뮤니티 동향 참고: ${fact}`);
+      const record = {
+        id, at: now.toISOString(), source: 'grok-community', url: point.url, title: point.title.slice(0, 120),
+        summary, implication, suggestions,
+        lensVerdict: verdict, why: `${judgedClaims.length ? '엘라누스 대조' : '커뮤니티 동향 참고'}: ${implication.join(' · ')}`.slice(0, 500),
+        target: point.text.match(/\b[A-Z][A-Z0-9]{2,}\b/)?.[0] ?? '커뮤니티',
+      };
+      mkdirSync(dirname(lens), { recursive: true });
+      appendFileSync(lens, `${JSON.stringify(record)}\n`);
+      mkdirSync(dirname(state), { recursive: true });
+      appendFileSync(state, `${id}\n`);
+      seen.add(id);
+      written++;
+    } catch (error) {
+      failed++;
+      log(`못 모음: ${point.url} — ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return { written, failed };
+}
+
+if (import.meta.main) {
+  const result = await runIntakeSocial({ root: effectiveInstanceRoot() });
+  console.log(`intake-social: ${result.written}건 · 못 모음 ${result.failed}건`);
+  if (result.failed) process.exitCode = 1;
+}

package/scripts/lecture-note/node.ts

@@ -1,12 +1,18 @@
 #!/usr/bin/env bun
 import { spawnSync } from 'node:child_process';
-import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { constants, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, extname, isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
 import { debug } from '../../src/debug/log.js';
 import { runOcr } from '../../skills/omni-digest/src/ocr.js';
 import { streamLLM } from '../../src/llm.js';
+import { decodeFieldAudio } from '../../src/field-note/telegram.js';
+import { createBatchSttEngine, transcribeFieldAudio, type FieldAudio, type TranscriptionEngine } from '../../src/field-note/transcribe.js';
+import { createSTTProvider } from '../../src/voice/stt-provider.js';
+import { resolveObsidianRoot } from '../../src/acp/fs-roots.js';
+import { assertVaultWriteAllowed } from '../../src/obsidian/vault-write-guard.js';
 import { unified } from 'unified';
 import remarkParse from 'remark-parse';
 import remarkGfm from 'remark-gfm';
@@ -15,7 +21,7 @@ import rehypeSanitize from 'rehype-sanitize';
 import rehypeStringify from 'rehype-stringify';
 
 export type Stage = 'collect' | 'draft' | 'render' | 'html' | 'pdf';
-export interface Input { name: string; kind: 'pdf' | 'image' | 'markdown'; text: string }
+export interface Input { name: string; kind: 'pdf' | 'image' | 'markdown' | 'audio'; text: string }
 export interface Counts { inputs: number; diagrams: number; rendered: number; html: 'yes' | 'no'; pdf: 'yes' | 'skipped' }
 export interface StageResult extends Counts { outcome: 'ok' | 'skipped' }
 export interface StageOptions {
@@ -23,11 +29,15 @@ export interface StageOptions {
   ocr?: (filePath: string) => Promise<string>;
   toolsPath?: string;
   referenceRoot?: string;
+  engine?: TranscriptionEngine;
+  decodeAudio?: (filePath: string, recordedAt: string) => FieldAudio;
+  vaultRoot?: string;
 }
 
 const ownRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../skills');
 const kinds: Record<string, Input['kind']> = {
   '.pdf': 'pdf', '.md': 'markdown', '.png': 'image', '.jpg': 'image', '.jpeg': 'image', '.webp': 'image',
+  '.wav': 'audio', '.mp3': 'audio', '.m4a': 'audio', '.ogg': 'audio', '.webm': 'audio',
 };
 const mermaid = /^```mermaid\s*\n([\s\S]*?)^```\s*$/gm;
 const escapeHtml = (text: string) => text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
@@ -92,13 +102,20 @@ export async function collect(folder: string, options: StageOptions = {}): Promi
   const sources = resolve(folder, 'sources/common');
   const scan = [{ base: folder, prefix: '' }, ...(pathStatus(sources)?.isDirectory() && !pathStatus(sources)?.isSymbolicLink()
     ? [{ base: sources, prefix: 'sources/common/' }] : [])];
+  let engine = options.engine;
   for (const { base, prefix } of scan) for (const entry of readdirSync(base, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
     const kind = kinds[extname(entry.name).toLowerCase()];
     if (!entry.isFile() || !kind) continue;
     const at = join(base, entry.name);
     let text: string;
     if (kind === 'markdown') text = readFileSync(at, 'utf8');
-    else if (kind === 'image') {
+    else if (kind === 'audio') {
+      if (!engine) engine = createBatchSttEngine(await createSTTProvider({ id: 'openai-whisper' }));
+      const recordedAt = statSync(at).mtime.toISOString();
+      const entries = await transcribeFieldAudio((options.decodeAudio ?? decodeFieldAudio)(at, recordedAt), engine);
+      if (!entries.length) throw new Error(`오디오 전사 결과가 비었다: ${prefix + entry.name}`);
+      text = entries.map(({ timestamp, speaker, text }) => `${timestamp} · ${speaker}: ${text}`).join('\n');
+    } else if (kind === 'image') {
       try {
         const extracted = await (options.ocr ?? runOcr)(at);
         if (!extracted.trim()) throw new Error('Upstage/OCR.space 폴백 결과가 비었다');
@@ -130,14 +147,63 @@ export async function draft(folder: string, options: StageOptions = {}): Promise
   const dir = outputDir(folder);
   const inputs = readInputs(dir);
   if (!inputs.length) throw new Error('강의 자료가 없다');
-  const prompt = `${instructions}\n\n자료:\n${inputs.map(i => `### ${i.name} (${i.kind})\n${i.text}`).join('\n\n')}`;
+  const audioInstructions = inputs.some(i => i.kind === 'audio')
+    ? '\n오디오 전사에서 근거를 찾아 노트 본문에 ## 요약 (내용 포함) 및 ## 할 일 셋 (번호 목록 1. 2. 3.)을 작성하라. 근거 없는 할 일은 만들지 말고 해당 항목은 없음으로 표시하라.' : '';
+  const prompt = `${instructions}${audioInstructions}\n\n자료:\n${inputs.map(i => `### ${i.name} (${i.kind})\n${i.text}`).join('\n\n')}`;
   const ask = options.llm ?? ((request: string) => streamLLM([{ role: 'user', content: request }], () => {}));
   const notes = (await ask(prompt)).trim();
   if (!notes) throw new Error('LLM 초안이 비었다');
+  if (audioInstructions && !hasAudioSummaryAndTasks(notes)) {
+    throw new Error('오디오 노트에 요약·할 일 셋이 없다');
+  }
   writeFileSync(artifact(dir, 'notes.md'), notes + '\n');
   return { ...counts(dir), outcome: 'ok' };
 }
 
+function hasAudioSummaryAndTasks(notes: string): boolean {
+  const lines = notes.split(/\r?\n/);
+  const section = (title: string): string | undefined => {
+    const start = lines.findIndex(line => line.trimEnd() === `## ${title}`);
+    if (start < 0) return undefined;
+    const next = lines.slice(start + 1).findIndex(line => /^#{1,2}\s/.test(line));
+    return lines.slice(start + 1, next < 0 ? undefined : start + 1 + next).join('\n').trim();
+  };
+  const summary = section('요약');
+  const tasks = section('할 일 셋');
+  const summaryContent = summary?.split('\n').some(line => line.trim() && !/^#{1,6}\s/.test(line));
+  return !!summaryContent && !!tasks && /^1\. [^\S\n]*\S[^\n]*\n(?:[^\S\n]*\n)*2\. [^\S\n]*\S[^\n]*\n(?:[^\S\n]*\n)*3\. [^\S\n]*\S[^\n]*/m.test(tasks);
+}
+
+function publishAudioNote(folder: string, dir: string, notes: string, options: StageOptions): void {
+  if (!readInputs(dir).some(i => i.kind === 'audio')) return;
+  if (!hasAudioSummaryAndTasks(notes)) {
+    throw new Error('오디오 노트에 요약·할 일 셋이 없다');
+  }
+  const resolvedVault = options.vaultRoot ? { root: resolve(options.vaultRoot), available: true } : resolveObsidianRoot();
+  if (!resolvedVault.available) return;
+  const vault = resolve(resolvedVault.root);
+  const vaultStatus = pathStatus(vault);
+  if (vaultStatus?.isSymbolicLink()) throw new Error('vault 루트가 안전하지 않다');
+  if (!vaultStatus?.isDirectory()) return;
+  const course = resolve(folder);
+  const target = join(vault, 'lecture-notes', `${createHash('sha256').update(course + '\0' + notes.trim()).digest('hex')}.md`);
+  const section = pathStatus(join(vault, 'lecture-notes'));
+  if (section && (!section.isDirectory() || section.isSymbolicLink())) throw new Error('vault 강의 노트 폴더가 안전하지 않다');
+  assertVaultWriteAllowed(target);
+  if (!section) mkdirSync(join(vault, 'lecture-notes'));
+  const existing = pathStatus(target);
+  if (existing && (!existing.isFile() || existing.isSymbolicLink())) throw new Error('vault 노트 파일이 안전하지 않다');
+  if (existing && readFileSync(target, 'utf8') !== notes) throw new Error('vault 노트 해시 충돌');
+  if (!existing) {
+    try { copyFileSync(artifact(dir, 'notes.md'), target, constants.COPYFILE_EXCL); }
+    catch (error) {
+      const current = pathStatus(target);
+      if ((error as NodeJS.ErrnoException).code !== 'EEXIST' || !current?.isFile() ||
+          current.isSymbolicLink() || readFileSync(target, 'utf8') !== notes) throw error;
+    }
+  }
+}
+
 export function render(folder: string, options: StageOptions = {}): StageResult {
   const dir = outputDir(folder);
   const notes = readFileSync(join(dir, 'notes.md'), 'utf8');
@@ -208,6 +274,7 @@ export function html(folder: string, options: StageOptions = {}): StageResult {
     `<style>${css}</style></head><body><div class="cover"><h1>${escapeHtml(title)}</h1></div>` +
     `<div class="toc"><h2>목차</h2><ol>${sections.join('\n')}</ol></div><div class="section">${numbered}</div></body></html>\n`;
   writeFileSync(artifact(dir, 'notes.html'), page);
+  publishAudioNote(folder, dir, notes, options);
   return { ...counts(dir), outcome: 'ok' };
 }
 

package/scripts/lib/android-toolchain.ts

@@ -0,0 +1,32 @@
+// 안드로이드 Gradle 빌드를 «실제로» 돌리는 시험의 전제 — JDK ⊕ Android SDK.
+//
+// ⛔ 0.2.20 컷(리눅스 게이트 Pod)에서 두 시험이 «JAVA_HOME is not set» 으로 빨갛게 떴다.
+//    Pod 이미지에는 JDK·Android SDK 가 없고, 넣으려면 SDK·Gradle 의존을 네트워크로 받아야 한다
+//    (게이트 Pod 의 몫이 아니다). macOS 개발 기계·`bun run test:android` 경로는 그대로 돈다.
+// ⇒ 전제가 «없을 때만» 건너뛰고, 그 이유를 한 줄로 남긴다(조용한 skip 금지).
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+export function resolveJavaHome(): string | undefined {
+  if (process.env.JAVA_HOME) return process.env.JAVA_HOME;
+  for (const args of [['-v', '17'], []]) {
+    const probe = spawnSync('/usr/libexec/java_home', args, { encoding: 'utf8' });
+    if (probe.status === 0 && probe.stdout.trim()) return probe.stdout.trim();
+  }
+  return undefined;
+}
+
+export function resolveAndroidSdkDir(): string {
+  return process.env.ANDROID_HOME ?? join(process.env.HOME ?? '', 'Library/Android/sdk');
+}
+
+/** 없는 전제를 사람이 읽을 문장으로 준다. 다 있으면 null. */
+export function androidToolchainMissing(): string | null {
+  const missing: string[] = [];
+  const javaOnPath = spawnSync('java', ['-version'], { encoding: 'utf8' }).status === 0;
+  if (!resolveJavaHome() && !javaOnPath) missing.push('JDK(JAVA_HOME·java_home·PATH 의 java 모두 없음)');
+  const sdk = resolveAndroidSdkDir();
+  if (!existsSync(sdk)) missing.push(`Android SDK(${sdk} 없음)`);
+  return missing.length ? missing.join(' · ') : null;
+}

package/scripts/lib/deterministic-env.ts

@@ -10,6 +10,7 @@
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { envLiteral } from '../../src/platform/env-literal.js';
 
 /** True when the variable name has the SHAPE of a credential.
  *
@@ -89,3 +90,64 @@ export function prepareDeterministicChildEnvironment(
     throw error;
   }
 }
+
+// A deterministic test child is not a harness executor: these inherited
+// markers would activate write-boundary policy against each test's temp files.
+const HARNESS_TEST_ENV_KEYS = [
+  'ELANOUS_HARNESS_SPACE',
+  'ELANOUS_HARNESS_SPACE_ID',
+  'ELANOUS_HARNESS_BOUNDARY',
+  'ELANOUS_HARNESS_ROLE',
+  'ELANOUS_HARNESS_DETACHED',
+] as const;
+
+// Discovery: rg -n "process\.env\.ELANOUS_(HOST|RUN|ORIGIN|SUPERVISOR|PARENT)" src
+// These are ambient execution identities, not inputs to a deterministic test.
+// debug.log also attributes SUBSTRATE and ARM_ID to every plain-object record.
+export const GIT_LOCATION_ENV_KEYS = [
+  'GIT_DIR', 'GIT_WORK_TREE', 'GIT_COMMON_DIR', 'GIT_INDEX_FILE',
+  'GIT_OBJECT_DIRECTORY', 'GIT_ALTERNATE_OBJECT_DIRECTORIES',
+] as const;
+
+const EXECUTION_ORIGIN_ENV_KEYS = [
+  'ELANOUS_HOST_ID',
+  'ELANOUS_RUN_ID',
+  'ELANOUS_RUN_CONTEXT',
+  'ELANOUS_PARENT_RUN_ID',
+  'ELANOUS_PARENT_PTY_ID',
+  'ELANOUS_PARENT_SELF_DEV_RUNS_DIR',
+  'ELANOUS_SUBSTRATE',
+  'ELANOUS_ARM_ID',
+  // Parent account selection changes CLI rotation assertions in the child.
+  'ELANOUS_CODEX_ACCOUNT',
+  // A parent's derived-root label must not reclassify a test's explicit state dir.
+  'ELANOUS_STATE_DIR_SOURCE',
+] as const;
+
+export function prepareIsolatedTestEnv(sourceEnv: NodeJS.ProcessEnv, testRoot: string): NodeJS.ProcessEnv {
+  const env = Object.fromEntries(
+    Object.entries(sourceEnv).filter(([key]) => !isCredentialKey(key)
+      && !HARNESS_TEST_ENV_KEYS.includes(key as typeof HARNESS_TEST_ENV_KEYS[number])
+      && !EXECUTION_ORIGIN_ENV_KEYS.includes(key as typeof EXECUTION_ORIGIN_ENV_KEYS[number])
+      && !GIT_LOCATION_ENV_KEYS.includes(key as typeof GIT_LOCATION_ENV_KEYS[number])),
+  );
+  env.HOME = testRoot;
+  // userConfigPath() warns whenever XDG_CONFIG_HOME is set, including when
+  // config.json is absent. Use its non-XDG path; migrateLegacyXdgUserConfig()
+  // resolves the old path through ELANOUS_TEST_HOME rather than the real home.
+  delete env.XDG_CONFIG_HOME;
+  env.ELANOUS_TEST_HOME = testRoot;
+  // HOME and ELANOUS_STATE_DIR isolate both the state and default config roots.
+  // ELANOUS_CONFIG_DIR is not a config-dir override; discard an inherited value
+  // rather than passing an ignored variable that appears to provide isolation.
+  env.ELANOUS_STATE_DIR = join(testRoot, 'state');
+  delete env.ELANOUS_CONFIG_DIR;
+  // All ambient execution identities are removed by EXECUTION_ORIGIN_ENV_KEYS
+  // above, before the child is spawned; logger API-shape tests need their absence.
+  // ⚠️ No `ELANOUS_TEST_DETERMINISTIC` marker is exported. Nothing reads it yet,
+  // and an env var with no consumer is a surface that looks like a contract
+  // while guaranteeing nothing — a later test could branch on it believing it
+  // means something. The tier work in PLAN-test-suite-diet introduces the
+  // signal together with the code that honours it.
+  return envLiteral(env);
+}

package/scripts/lib/gate-test-env.ts

@@ -0,0 +1,19 @@
+/** Shared deterministic environment for release and self gate test children. No process side effects. */
+export const GATE_POD_ENV_BASELINE: Readonly<Record<string, string>> = Object.freeze({
+  TZ: 'UTC',
+  LANG: 'C.UTF-8',
+  LC_ALL: 'C.UTF-8',
+  ELANOUS_TEST_FAKE_LLM: '1',
+});
+
+/** Preserve an explicit fake-LLM choice (including '0'); pin locale and timezone. */
+export function gateTestBaseline(source: NodeJS.ProcessEnv): Record<string, string> {
+  return {
+    ...GATE_POD_ENV_BASELINE,
+    ELANOUS_TEST_FAKE_LLM: source.ELANOUS_TEST_FAKE_LLM ?? GATE_POD_ENV_BASELINE.ELANOUS_TEST_FAKE_LLM,
+  };
+}
+
+export function withGateTestEnv(source: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+  return { ...source, ...gateTestBaseline(source) };
+}

package/scripts/measure-goal-grounding-corpus.ts

@@ -14,6 +14,7 @@ import { debug } from '../src/debug/log.js';
 import { groundMissionInCodebase, type CodebaseGrounding, type SearchTermFn } from '../src/autopilot/mission-codebase-gate.js';
 import { groundForGoalAuthor, type GoalAuthorGroundingPath } from '../src/self-implement/goal-author.js';
 import { groundGoalInCodebase, GROUNDING_HEADER } from '../src/self-implement/ground-goal.js';
+import { TUI_ENTRY_PATH } from '../test/helpers/dashboard-source.js';
 
 type CorpusItem = { id: string; kind: string; ask: string; answers: readonly string[]; pr: number | null; searchTerms: readonly string[]; note?: string };
 
@@ -21,7 +22,7 @@ const CORPUS = [
   { id: 'B1', kind: 'B', ask: 'elanous logs 조회가 0건일 때 그 0이 무엇을 뜻하는지 함께 알려주도록 고쳐줘', answers: ['src/cli/logs-cli.ts'], pr: 5806, searchTerms: ['elanous', 'logs', '조회'] },
   { id: 'B2', kind: 'B', ask: '격리된 테스트 인스턴스가 살아있는 체크아웃을 조용히 편집하지 못하게 막아줘', answers: ['src/boot/tool-cwd.ts', 'src/boot/daemon-runtime.ts', 'src/nexus/index.ts'], pr: 5814, searchTerms: ['격리', '테스트', '체크아웃', '편집'] },
   { id: 'B3', kind: 'B', ask: '동시에 도는 턴들이 서로의 세션 식별자를 덮어쓰지 않게 해줘', answers: ['src/core-turn/run-core-turn.ts', 'src/debug/log.ts'], pr: 5809, searchTerms: ['동시에', '턴', '세션', '식별자'] },
-  { id: 'B4', kind: 'B', ask: '인자 없이 부르면 격리 판정이 항상 운영으로 나오는 문제를 고쳐줘', answers: ['src/instance/current.ts', 'src/boot/tool-cwd.ts', 'src/cli/where-cli.ts', 'src/dashboard/index.ts', 'src/nexus/index.ts'], pr: 5820, searchTerms: ['인자', '격리', '판정', '운영'] },
+  { id: 'B4', kind: 'B', ask: '인자 없이 부르면 격리 판정이 항상 운영으로 나오는 문제를 고쳐줘', answers: ['src/instance/current.ts', 'src/boot/tool-cwd.ts', 'src/cli/where-cli.ts', TUI_ENTRY_PATH, 'src/nexus/index.ts'], pr: 5820, searchTerms: ['인자', '격리', '판정', '운영'] },
   { id: 'B5', kind: 'B', ask: '팬아웃이 배달 0 을 냈을 때 그것이 어떤 종류의 0 인지 갈라서 알려줘', answers: ['src/session/session-fanout.ts'], pr: 5805, searchTerms: ['팬아웃', '배달', '종류'] },
   { id: 'A1', kind: 'A', ask: 'src/self-implement/goal-author.ts 가 근거를 모을 때 집계기를 쓰도록 바꿔줘', answers: ['src/self-implement/goal-author.ts'], pr: null, searchTerms: ['goal-author', '근거', '집계기'] },
   { id: 'A2', kind: 'A', ask: 'src/boot/tool-cwd.ts 의 죽은 타입을 살려서 경로 누출을 컴파일 에러로 만들어줘', answers: ['src/boot/tool-cwd.ts'], pr: 5815, searchTerms: ['tool-cwd', '타입', '경로'] },

package/scripts/measure-si-task-cpu.ts

@@ -0,0 +1,143 @@
+#!/usr/bin/env bun
+/** Read-only, point-in-time CPU measurement of si-task Pods. No Jobs or Pods are created. */
+import { readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+
+type Pod = {
+  metadata?: { name?: string; creationTimestamp?: string };
+  status?: { phase?: string; containerStatuses?: Array<{ state?: { terminated?: { finishedAt?: string } } }> };
+  spec?: { containers?: Array<{ name?: string; resources?: { requests?: { cpu?: string } } }> };
+};
+type PodMetric = { metadata?: { name?: string }; timestamp?: string; containers?: Array<{ name?: string; usage?: { cpu?: string } }> };
+type KubeList<T> = { items?: T[] };
+
+export type CpuObservation = {
+  dateKst: string;
+  context: string;
+  namespace: string;
+  measuredAt: string;
+  coverage: 'point-in-time-current-pods-only';
+  podsSeenToday: number;
+  unknownOverlapPods: number;
+  podsWithMetric: number;
+  podsWithoutMetric: number;
+  oldestMetricAgeSeconds: number | null;
+  cpuMillis: { p50: number | null; p95: number | null; max: number | null };
+  candidates: Array<{ request: string; requestMillis: number; p95OfRequest: number | null; observedComparison: string; decision: string }>;
+  pods: Array<{ name: string; phase: string; requestMillis: number | null; usageMillis: number | null; metricTimestamp: string | null; metricAgeSeconds: number | null }>;
+};
+
+/** Kubernetes CPU quantity to millicores; null means unusable evidence. */
+export function cpuMillis(value: unknown): number | null {
+  if (typeof value !== 'string') return null;
+  const match = /^(\d+(?:\.\d+)?)(n|u|m)?$/.exec(value);
+  if (!match) return null;
+  const factor = match[2] === 'n' ? 0.000001 : match[2] === 'u' ? 0.001 : match[2] === 'm' ? 1 : 1000;
+  const result = Number(match[1]) * factor;
+  return Number.isFinite(result) ? result : null;
+}
+
+function percentile(sorted: readonly number[], fraction: number): number | null {
+  if (!sorted.length) return null;
+  return Math.round(sorted[Math.ceil(fraction * sorted.length) - 1]! * 100) / 100;
+}
+
+export function measureSiTaskCpu(
+  pods: KubeList<Pod>, metrics: KubeList<PodMetric>,
+  options: { dateKst: string; context: string; namespace: string; now?: Date },
+): CpuObservation {
+  const start = Date.parse(`${options.dateKst}T00:00:00+09:00`);
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(options.dateKst) || !Number.isFinite(start)
+    || new Date(start + 9 * 60 * 60 * 1000).toISOString().slice(0, 10) !== options.dateKst)
+    throw new Error(`invalid KST date: ${options.dateKst}`);
+  const end = start + 24 * 60 * 60 * 1000;
+  const now = options.now ?? new Date();
+  const byName = new Map((metrics.items ?? []).map((metric) => [metric.metadata?.name, metric]));
+  let unknownOverlapPods = 0;
+  const rows = (pods.items ?? []).filter((pod) => {
+    const name = pod.metadata?.name ?? '';
+    const created = Date.parse(pod.metadata?.creationTimestamp ?? '');
+    const finished = pod.status?.containerStatuses?.map((item) => Date.parse(item.state?.terminated?.finishedAt ?? ''))
+      .filter(Number.isFinite).sort((a, b) => b - a)[0];
+    const terminal = ['Succeeded', 'Failed'].includes(pod.status?.phase ?? '');
+    if (!name.startsWith('si-task-') || !Number.isFinite(created) || created >= end) return false;
+    if (created < start && terminal && finished === undefined) {
+      unknownOverlapPods++;
+      return false;
+    }
+    return !terminal || finished === undefined || finished >= start;
+  }).map((pod) => {
+    const name = pod.metadata!.name!;
+    const metric = byName.get(name);
+    const timestamp = Date.parse(metric?.timestamp ?? '');
+    const values = metric?.containers?.map((item) => cpuMillis(item.usage?.cpu)) ?? [];
+    const expected = pod.spec?.containers ?? [];
+    const namesMatch = expected.every((container) => !container.name || metric?.containers?.some((item) => item.name === container.name));
+    const containersComplete = expected.length > 0 && values.length === expected.length && namesMatch;
+    // Missing any container value is missing Pod usage, not a zero.
+    const ageSeconds = Math.round((now.getTime() - timestamp) / 1000);
+    const usageMillis = Number.isFinite(timestamp) && timestamp >= start && timestamp < end
+      && ageSeconds >= -120 && ageSeconds <= 120
+      && containersComplete && values.every((value) => value !== null)
+      ? Math.round((values as number[]).reduce((sum, value) => sum + value, 0) * 100) / 100 : null;
+    const requests = pod.spec?.containers?.map((item) => cpuMillis(item.resources?.requests?.cpu)) ?? [];
+    return {
+      name, phase: pod.status?.phase ?? 'Unknown',
+      requestMillis: requests.length > 0 && requests.every((value) => value !== null)
+        ? Math.round((requests as number[]).reduce((sum, value) => sum + value, 0) * 100) / 100 : null,
+      usageMillis, metricTimestamp: Number.isFinite(timestamp) ? metric!.timestamp! : null,
+      metricAgeSeconds: Number.isFinite(timestamp) ? ageSeconds : null,
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+  const measured = rows.flatMap((row) => row.usageMillis === null ? [] : [row.usageMillis]).sort((a, b) => a - b);
+  const ages = rows.flatMap((row) => row.metricAgeSeconds === null ? [] : [row.metricAgeSeconds]);
+  const oldestMetricAgeSeconds = ages.length ? Math.max(...ages) : null;
+  const stale = rows.some((row) => row.metricTimestamp !== null && row.metricAgeSeconds !== null
+    && (Date.parse(row.metricTimestamp) < start || Date.parse(row.metricTimestamp) >= end
+      || row.metricAgeSeconds < -120 || row.metricAgeSeconds > 120));
+  const p95 = percentile(measured, 0.95);
+  const candidates = [250, 500, 1000].map((requestMillis) => ({
+    request: requestMillis === 1000 ? '1' : `${requestMillis}m`, requestMillis,
+    p95OfRequest: p95 === null ? null : Math.round(p95 / requestMillis * 1000) / 10,
+    observedComparison: p95 === null ? 'unmeasured' : p95 <= requestMillis ? 'observed-p95-within-request' : 'observed-p95-above-request',
+    // A single metrics-server snapshot cannot justify a request change, even with full current-Pod coverage.
+    decision: stale ? 'stale-snapshot' : p95 === null ? 'unmeasured'
+      : measured.length < rows.length || unknownOverlapPods > 0 ? 'incomplete-coverage' : 'needs-time-series',
+  }));
+  return {
+    dateKst: options.dateKst, context: options.context, namespace: options.namespace,
+    measuredAt: now.toISOString(), coverage: 'point-in-time-current-pods-only',
+    podsSeenToday: rows.length, unknownOverlapPods, podsWithMetric: measured.length, podsWithoutMetric: rows.length - measured.length,
+    oldestMetricAgeSeconds,
+    cpuMillis: { p50: percentile(measured, 0.5), p95, max: measured.at(-1) ?? null }, candidates, pods: rows,
+  };
+}
+
+function kubectl(args: string[]): unknown {
+  const result = spawnSync('kubectl', args, { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, timeout: 20_000 });
+  if (result.error || result.status !== 0) throw new Error(`kubectl ${args.at(-1)} failed: ${result.error?.message ?? result.stderr?.trim() ?? result.status}`);
+  return JSON.parse(result.stdout);
+}
+
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  const option = (flag: string): string | undefined => {
+    const index = args.indexOf(flag);
+    return index < 0 ? undefined : args[index + 1];
+  };
+  const usage = 'Usage: bun scripts/measure-si-task-cpu.ts [--context pool-node-b] [--namespace elanous-test] [--date YYYY-MM-DD] [--pods-json FILE --metrics-json FILE]';
+  const known = new Set(['--context', '--namespace', '--date', '--pods-json', '--metrics-json']);
+  if (args.includes('--help')) { console.log(usage); process.exit(0); }
+  if (args.some((arg, index) => index % 2 === 0 ? !known.has(arg) : arg.startsWith('--')) || args.length % 2) throw new Error(usage);
+  const podsPath = option('--pods-json');
+  const metricsPath = option('--metrics-json');
+  const offline = Boolean(podsPath || metricsPath);
+  const context = option('--context') ?? (offline ? 'unknown' : 'pool-node-b');
+  const namespace = option('--namespace') ?? (offline ? 'unknown' : 'elanous-test');
+  const dateKst = option('--date') ?? new Intl.DateTimeFormat('en-CA', { timeZone: 'Asia/Seoul', year: 'numeric', month: '2-digit', day: '2-digit' }).format(new Date());
+  if (Boolean(podsPath) !== Boolean(metricsPath)) throw new Error('both --pods-json and --metrics-json are required for offline input');
+  const pods = podsPath ? JSON.parse(readFileSync(podsPath, 'utf8')) : kubectl(['--context', context, '-n', namespace, 'get', 'pods', '-o', 'json']);
+  const metrics = metricsPath ? JSON.parse(readFileSync(metricsPath, 'utf8'))
+    : kubectl(['--context', context, 'get', '--raw', `/apis/metrics.k8s.io/v1beta1/namespaces/${encodeURIComponent(namespace)}/pods`]);
+  console.log(JSON.stringify(measureSiTaskCpu(pods, metrics, { dateKst, context, namespace }), null, 2));
+}