elanous 0.2.13 → 0.2.15

package/src/steward/triage.ts

@@ -260,9 +260,56 @@ function skipOverlappingRun(root: string, open: FailureStreak['open'] & { pid?:
   }
   debug.log('steward.stage', 'skipped-overlap', { openStage: open.stage, pid: open.pid });
   writeFileSync(skippedPath(root), JSON.stringify({ openStage: open.stage, pid: open.pid }));
+  logTickDecision(root, 'skipped', `overlapping ${open.stage} (pid ${open.pid ?? 'unknown'})`);
 }
 
 function reportPath(root: string): string { return join(root, 'steward', 'observe.json'); }
+
+type TickDecision = { verdict: 'launched' | 'failed'; reason: string; goalId?: string };
+
+function logTickDecision(root: string | undefined, verdict: 'launched' | 'skipped' | 'reported' | 'failed', reason: string, goalId?: string): void {
+  const runId = graphRunId();
+  const marker = root && runId && existsSync(join(root, 'steward')) ? join(root, 'steward', `decision-logged-${runId}.json`) : undefined;
+  const decision = { verdict, reason: redactSecretText(reason), ...(goalId ? { goalId } : {}), ...(runId ? { runId } : {}) };
+  if (marker) try {
+    const previous = JSON.parse(readFileSync(marker, 'utf8')) as { verdict?: string; reason?: string };
+    // A replay keeps the first success; a failure replaces a success; a success after a failure replaces the failure.
+    if (previous.verdict === decision.verdict && previous.reason === decision.reason) return;
+    if (previous.verdict !== 'failed' && verdict !== 'failed') return;
+  } catch { /* Missing or stale marker: retry the observation. */ }
+  try {
+    debug.log('loop.steward', 'decision', decision);
+    if (marker) writeFileSync(marker, JSON.stringify(decision));
+  } catch { /* Observation must not change the tick outcome. */ }
+}
+
+function tickDecisionPath(root: string, runId: string): string {
+  return join(root, 'steward', `decision-${runId}.json`);
+}
+function rememberLaunchDecision(root: string, entry: TickDecision): void {
+  const runId = graphRunId();
+  if (!runId) return;
+  const path = tickDecisionPath(root, runId);
+  try {
+    let current: TickDecision | undefined;
+    try { current = JSON.parse(readFileSync(path, 'utf8')) as TickDecision; }
+    catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') return; }
+    // Keep the first failure (and its goal/cause), even if a retried schedule later succeeds.
+    if (current?.verdict === 'failed' || current?.verdict === entry.verdict) return;
+    writeFileSync(path, JSON.stringify(entry));
+  } catch { /* An unavailable observation store must not block execution. */ }
+}
+function readLaunchDecision(root: string): TickDecision | undefined {
+  const runId = graphRunId();
+  if (!runId) return undefined;
+  try { return JSON.parse(readFileSync(tickDecisionPath(root, runId), 'utf8')) as TickDecision; }
+  catch { return undefined; }
+}
+function logStageFailure(root: string, stage: StewardStage, reason: string): void {
+  const runId = graphRunId();
+  if (runId) try { rmSync(tickDecisionPath(root, runId), { force: true }); } catch { /* Observation must not change the failure. */ }
+  logTickDecision(root, 'failed', `${stage}: ${reason}`);
+}
 function readState(path: string): { issues: Record<string, string>; digestDay?: string } {
   try { return JSON.parse(readFileSync(path, 'utf8')) as ReturnType<typeof readState>; }
   catch (error) { if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { issues: {} }; throw error; }
@@ -396,10 +443,18 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
       const entry = raiseHitl(issue, row, launchDeps);
       recordHitlOnCard(issue, entry, cardDeps);
     }
+    let launchDecision: TickDecision | undefined;
     for (const item of plan.launches) {
       const entry = launch(item, launchDeps);
+      const decision: TickDecision | undefined = entry.status === 'launched'
+        ? { verdict: 'launched', reason: 'harness run spawned', goalId: `linear:${item.issue.identifier}` }
+        : entry.status === 'failed'
+          ? { verdict: 'failed', reason: entry.reason ?? 'launch failed', goalId: `linear:${item.issue.identifier}` }
+          : undefined;
+      if (decision && (!launchDecision || (decision.verdict === 'failed' && launchDecision.verdict !== 'failed'))) launchDecision = decision;
       recordLaunchOnCard(item.issue, entry, cardDeps);
     }
+    if (launchDecision) rememberLaunchDecision(root, launchDecision);
     if (settings.mode === 'shadow') {
       const { recordShadowTick } = await import('./readiness.js');
       const tick = recordShadowTick(root, rows, plan, (deps.now ?? (() => new Date()))());
@@ -459,12 +514,18 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
       }
     }
     const day = at.slice(0, 10);
+    let digested = false;
     if (state.digestDay !== day) {
       const send = deps.sendDigest ?? sendStewardDigest;
       await send(`스튜어드 ${day}: ${rows.map(row => `${row.issue} ${row.disposition}`).join(' · ')}`);
       state.digestDay = day;
       writeFileSync(path, JSON.stringify(state));
+      digested = true;
     }
+    const launched = readLaunchDecision(root);
+    if (launched) logTickDecision(root, launched.verdict, launched.reason, launched.goalId);
+    else if (outcomes.length || digested) logTickDecision(root, 'reported', outcomes.length ? `${outcomes.length} outcome(s) reported` : 'daily digest sent');
+    else logTickDecision(root, 'skipped', 'no new outcome or digest');
   }
   outcome = 'ok';
   } finally {
@@ -513,10 +574,14 @@ async function withStageSlot<T>(root: string, run: () => Promise<T>, onBusy?: ()
 
 /** The command-node boundary records both normal exits and an unclosed stage from a killed process. */
 export async function runStewardStageCommand(stage: StewardStage, deps: StewardCommandDeps = {}): Promise<0 | 1> {
-  if (resolvedStewardSettings(deps.launchSettings).mode === 'off') return 0;
+  if (resolvedStewardSettings(deps.launchSettings).mode === 'off') {
+    if (stage === 'sync') logTickDecision(deps.root ?? effectiveInstanceRoot(), 'skipped', 'steward mode off');
+    return 0;
+  }
   const root = deps.root ?? effectiveInstanceRoot();
   if (stage !== 'sync' && existsSync(skippedPath(root))) return 0;
-  return withStageSlot(root, async () => {
+  try {
+    return await withStageSlot(root, async () => {
     const now = deps.now ?? (() => new Date());
     const threshold = stewardSettings().alertAfterFailures ?? 3;
     const alertIfNeeded = async (state: FailureStreak): Promise<void> => {
@@ -564,10 +629,16 @@ export async function runStewardStageCommand(stage: StewardStage, deps: StewardC
     if (!ok) {
       console.error(`steward ${stage}: stage failed — ${reason}`);
       debug.log('steward.stage', 'failed', { stage, reason });
+      if (stage === 'sync' || !existsSync(skippedPath(root))) logStageFailure(root, stage, reason);
       return 1;
     }
     return 0;
-  }, stage === 'sync' ? () => { skipOverlappingRun(root, currentOpen(root, stage)); return 0 as const; } : undefined);
+    }, stage === 'sync' ? () => { skipOverlappingRun(root, currentOpen(root, stage)); return 0 as const; } : undefined);
+  } catch (error) {
+    try { if (stage === 'sync' || !existsSync(skippedPath(root))) logStageFailure(root, stage, error instanceof Error ? error.message : String(error)); }
+    catch { /* Observation must not change the stage error. */ }
+    throw error;
+  }
 }
 
 export async function runStewardNodeCommand(

package/src/steward/working-backwards.ts

@@ -53,7 +53,10 @@ export async function recordWorkingBackwardsOnCards(
     }
     const card = store.createCard({ goalId: `linear:${issue.identifier}`, title: redactSecrets(issue.title) });
     if (card.sections.some(section => section.key.startsWith('prfaq:')) && card.sections.some(section => section.key.startsWith('manual:'))) continue;
-    if (card.sections.some(section => section.key.startsWith('launch:'))) throw new Error(`Working-backwards draft follows launch: ${issue.identifier}`);
+    if (card.sections.some(section => section.key.startsWith('launch:'))) {
+      debug.log('steward.working-backwards', 'skipped-launched-before-draft', { issueId: issue.identifier });
+      continue;
+    }
     const draft = await draftWorkingBackwards(issue, ask);
     for (const [section, content] of [['prfaq', draft.prfaq], ['manual', draft.manual]] as const) {
       const key = `${section}:${createHash('sha256').update(content).digest('hex')}`;

package/src/task-cards/card-cli.ts

@@ -1,7 +1,7 @@
 import type { Command } from 'commander';
 import { join, resolve } from 'node:path';
 import { scanWishFolder } from '../intake-plane/wish-folder.js';
-import { LINEAR_WISH_KEY_MISSING, scanLinearWishes } from '../intake-plane/linear-wish.js';
+import { LINEAR_WISH_KEY_MISSING, scanLinearWishes, suggestLinearWishes } from '../intake-plane/linear-wish.js';
 import type { fetchLinearIssues } from '../connectors/linear.js';
 import { CardStore, type TaskCard } from './card-store.js';
 
@@ -145,10 +145,18 @@ export function registerCardCommand(program: Command, deps: CardCliDeps = {}): C
     .description('Create wish cards from open Linear issues')
     .requiredOption('--team <key>', 'Linear team key')
     .option('--label <name>', 'Wish label or title prefix', 'wish')
+    .option('--suggest', 'Suggest wish labels without writing to Linear or creating cards')
     .option('--json', 'Output JSON')
-    .action(async (options: { team: string; label: string; json?: boolean }) => {
+    .action(async (options: { team: string; label: string; suggest?: boolean; json?: boolean }) => {
       let store: CardStore | undefined;
       try {
+        if (options.suggest) {
+          const suggestions = await suggestLinearWishes({ teamKey: options.team,
+            deps: { getApiKey: deps.getApiKey, fetchIssues: deps.fetchIssues } });
+          write(options.json ? `${JSON.stringify(suggestions)}\n` :
+            suggestions.map(item => `${item.identifier}\t${item.title}\t${item.reason}\n`).join(''));
+          return;
+        }
         store = createStore();
         const result = await scanLinearWishes({ teamKey: options.team, label: options.label, store,
           deps: { getApiKey: deps.getApiKey, fetchIssues: deps.fetchIssues } });

package/src/task-cards/card-store.ts

@@ -42,7 +42,7 @@ export const SECTION_OWNERS: Readonly<Record<string, string | null>> = {
   gates: 'execution-loop', relations: 'execution-loop', memory: 'execution-loop',
   workspace: 'executor', run: 'executor',
   landing: 'landing-loop', release: 'release-loop', 'test-diet': 'test-diet',
-  incidents: null,
+  incidents: null, orch: 'orchestrator', flow: 'flow',
 };
 
 export function sectionOf(key: string): string {
@@ -80,10 +80,11 @@ export class CardStore {
   private readonly db: Database;
   readonly root: string;
 
-  constructor(root: string = elanousStateRoot()) {
+  constructor(root: string = elanousStateRoot(), private readonly readOnly = false) {
     this.root = root;
-    mkdirSync(taskCardsDir(root), { recursive: true });
-    this.db = new Database(cardIndexPath(root));
+    if (!readOnly) mkdirSync(taskCardsDir(root), { recursive: true });
+    this.db = readOnly ? new Database(cardIndexPath(root), { readonly: true }) : new Database(cardIndexPath(root));
+    if (readOnly) return;
     try {
       this.db.exec('PRAGMA busy_timeout = 5000');
       this.db.exec('PRAGMA journal_mode = WAL');
@@ -127,6 +128,7 @@ export class CardStore {
   }
 
   private reconcile(): void {
+    if (this.readOnly) return;
     for (const file of readdirSync(taskCardsDir(this.root))) {
       if (!/^[a-zA-Z0-9_-]+\.jsonl$/.test(file)) continue;
       const id = file.slice(0, -'.jsonl'.length);
@@ -220,6 +222,7 @@ export class CardStore {
   }
 
   getCard(id: string): TaskCard | null {
+    if (this.readOnly) return this.readCard(id);
     return this.db.transaction(() => {
       this.reconcile();
       return this.readCard(id);
@@ -227,12 +230,13 @@ export class CardStore {
   }
 
   listCards(options: { open?: boolean } = {}): TaskCard[] {
-    return this.db.transaction(() => {
+    const list = () => {
       this.reconcile();
       const rows = this.db.query(`SELECT id FROM cards ${options.open ? "WHERE status = 'open'" : ''} ORDER BY created_at DESC, id DESC`)
         .all() as Array<{ id: string }>;
       return rows.map(({ id }) => this.readCard(id)!);
-    }).immediate();
+    };
+    return this.readOnly ? list() : this.db.transaction(list).immediate();
   }
 
   close(): void {

package/src/task-orchestrator/surfaces/pod-artifact-return.ts

@@ -1,9 +1,9 @@
-import { lstatSync, mkdirSync, writeFileSync } from 'node:fs';
+import { lstatSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { gunzipSync } from 'node:zlib';
 import { debug } from '../../debug/log.js';
 import { getDefaultLogStore, type LogStore } from '../../mss/logging/log-store.js';
-import type { LogRecord } from '../../mss/logging/record.js';
+import { fromJsonl, type LogRecord } from '../../mss/logging/record.js';
 
 const FILE_LIMIT = 5 * 1024 * 1024;
 const TOTAL_LIMIT = 20 * 1024 * 1024;
@@ -83,50 +83,58 @@ export function parsePodArtifactChunks(logs: string): ParseResult {
 
 const POD_LOGS_PATH = 'pod-logs/logs.jsonl';
 
-function childRunId(data: unknown): string | undefined {
-  if (!data || typeof data !== 'object' || Array.isArray(data)) return undefined;
-  const value = (data as Record<string, unknown>).runId;
-  return typeof value === 'string' && value.length > 0 ? value : undefined;
-}
-
-function decisionRecord(line: string): { rec: LogRecord; surface: string } | undefined {
-  let parsed: unknown;
-  try { parsed = JSON.parse(line); } catch { return undefined; }
-  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return undefined;
-  const row = parsed as Record<string, unknown>;
-  if (row.category !== 'harness.decision') return undefined;
-  if (typeof row.ts !== 'string' || typeof row.event !== 'string') return undefined;
-  const runId = childRunId(row.data);
-  if (!runId) return undefined;
-  const data = { ...(row.data as Record<string, unknown>), podJob: '', importedFrom: 'pod' as const };
-  return {
-    rec: {
-      ts: row.ts,
-      category: 'harness.decision',
-      event: row.event,
-      data,
-      ...(typeof row.level === 'string' ? { level: row.level as LogRecord['level'] } : {}),
-      ...(typeof row.trace_id === 'string' ? { trace_id: row.trace_id } : {}),
-    },
-    surface: typeof row.surface === 'string' && row.surface ? row.surface : 'pod',
-  };
+/** Last measured child ledger context when a failed Pod emitted no terminal JSON. */
+export function podNoResultDiagnostic(ledger: string): string | null {
+  let stage: string | undefined;
+  let round: number | undefined;
+  let mustFix: string | undefined;
+  for (const line of ledger.split(/\r?\n/)) {
+    try {
+      const entry = JSON.parse(line) as { event?: unknown; data?: Record<string, unknown> };
+      if (!entry || typeof entry !== 'object' || !entry.data || typeof entry.data !== 'object' || typeof entry.event !== 'string' || entry.event === 'pod-ledger-incomplete') continue;
+      if (typeof entry.data.round === 'number' && Number.isSafeInteger(entry.data.round)) round = entry.data.round;
+      if (entry.event !== 'run-origin') stage = entry.event;
+      // `reviewed` carries pointers only (count + finding ids); the text stays in the review artifact.
+      if (entry.event === 'reviewed' && typeof entry.data.mustFix === 'number') {
+        const ids = Array.isArray(entry.data.findingIds) ? entry.data.findingIds.filter((id): id is string => typeof id === 'string') : [];
+        mustFix = `${entry.data.mustFix}${ids.length ? ` ${JSON.stringify(ids)}` : ''}`;
+      }
+    } catch { /* incomplete ledger line */ }
+  }
+  return stage ? `child terminal result missing; last ledger stage=${stage}; round=${round ?? 'unknown'}; mustFix=${mustFix ?? 'unknown'}` : null;
 }
 
-/** Import only harness.decision rows from a returned pod log into the launching host store. */
-export function importPodDecisionLogs(bytes: Buffer, job: string, store: LogStore | null = getDefaultLogStore()): { imported: number; skipped: number } {
+/** Import valid JSONL log records into the launching host store, with durable per-job line receipts. */
+export function importPodLogs(bytes: Buffer, job: string, store: LogStore | null = getDefaultLogStore()): { imported: number; skipped: number } {
   if (!store) return { imported: 0, skipped: 0 };
-  const text = bytes.toString('utf8');
-  const rows: Array<{ rec: LogRecord; surface: string }> = [];
+  const rows: Array<{ rec: LogRecord; surface: string; line: number }> = [];
   let skipped = 0;
-  for (const line of text.split(/\r?\n/)) {
+  for (const [lineNumber, line] of bytes.toString('utf8').split(/\r?\n/).entries()) {
     if (!line) continue;
-    const row = decisionRecord(line);
-    if (!row) { skipped += 1; continue; }
-    row.rec.data = { ...(row.rec.data as Record<string, unknown>), podJob: job };
-    rows.push(row);
+    const rec = fromJsonl(line);
+    if (!rec || !Number.isFinite(Date.parse(rec.ts))) { skipped++; continue; }
+    const data = rec.data && typeof rec.data === 'object' && !Array.isArray(rec.data)
+      ? rec.data as Record<string, unknown>
+      : rec.data === undefined ? {} : { originalData: rec.data };
+    const surface = (rec as LogRecord & { surface?: unknown }).surface;
+    rows.push({
+      rec: { ...rec, data: { ...data, origin: 'pod', podJob: job } },
+      surface: typeof surface === 'string' && surface ? surface : 'pod',
+      line: lineNumber,
+    });
+  }
+  return { imported: store.insertPodBatch(job, rows), skipped };
+}
+
+function importReturnedLogs(bytes: Buffer, job: string, store: LogStore | null,
+  log: (category: string, event: string, data: Record<string, unknown>) => void): void {
+  try {
+    if (!store) throw new Error('host log store unavailable');
+    const imported = importPodLogs(bytes, job, store);
+    log('self-implement.pod', 'pod-logs-imported', { job, imported: imported.imported, skipped: imported.skipped });
+  } catch (error) {
+    debug.log('self-implement.pod', 'pod-logs-import-failed', { job, reason: error instanceof Error ? error.message : String(error) });
   }
-  if (rows.length > 0) store.insertBatch(rows);
-  return { imported: rows.length, skipped };
 }
 
 /** Reject symlink parents as well as lexical traversal; never replace a host file. */
@@ -176,17 +184,24 @@ export function collectPodArtifacts(logs: string, { dir, job, log = (c, e, d) =>
         podLogsReturned = true;
         const lines = bytes.length ? bytes.toString('utf8').split('\n').length - (bytes.at(-1) === 10 ? 1 : 0) : 0;
         log('self-implement.pod', 'pod-logs-returned', { job, path: destination, lines });
-        try {
-          const imported = importPodDecisionLogs(bytes, job, logStore);
-          log('self-implement.pod', 'pod-decisions-imported', { job, imported: imported.imported, skipped: imported.skipped });
-        } catch (error) {
-          log('self-implement.pod', 'pod-logs-import-failed', { job, reason: error instanceof Error ? error.message : String(error) });
-        }
+        importReturnedLogs(bytes, job, logStore, log);
       }
     } catch (e) {
       const reason = (e as NodeJS.ErrnoException).code === 'EEXIST' ? 'exists' : e instanceof Error ? e.message : String(e);
-      if ((e as NodeJS.ErrnoException).code === 'EEXIST') log('self-implement.pod', 'artifact-collect-skipped', { job, path, reason });
-      else log('self-implement.pod', 'artifact-collect-incomplete', { job, path, reason });
+      if ((e as NodeJS.ErrnoException).code === 'EEXIST') {
+        log('self-implement.pod', 'artifact-collect-skipped', { job, path, reason });
+        if (path === podLogsPath) {
+          try {
+            const existing = resolve(dir, job, path);
+            if (!lstatSync(existing).isSymbolicLink() && readFileSync(existing).equals(bytes)) {
+              podLogsReturned = true;
+              importReturnedLogs(bytes, job, logStore, log);
+            }
+          } catch (error) {
+            debug.log('self-implement.pod', 'pod-logs-import-failed', { job, reason: error instanceof Error ? error.message : String(error) });
+          }
+        }
+      } else log('self-implement.pod', 'artifact-collect-incomplete', { job, path, reason });
       if (path === podLogsPath) podLogsMissingReason = reason;
     }
   }

package/src/task-orchestrator/surfaces/pod-command-job.ts

@@ -7,6 +7,7 @@
 
 import { randomBytes } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
 import { isAbsolute, resolve } from 'node:path';
 import { getUserConfig } from '../../user-config.js';
 import { debug } from '../../debug/log.js';
@@ -35,6 +36,14 @@ export const POD_LITE_IMAGE = 'elanous-harness-lite:local';
 
 export const POD_LITE_MEMORY_LIMIT = '2Gi';
 
+/** 요청은 한도를 넘을 수 없다(쿠버네티스가 Job 을 거부한다) — lite 2Gi 처럼 한도가 기본 요청보다 작으면 한도로 맞춘다. */
+export function memoryRequestWithin(limit: string | undefined): string {
+  const gi = (value: string | undefined) => { const m = /^(\d+)Gi$/.exec(value ?? ''); return m ? Number(m[1]) : null; };
+  const request = gi(POD_CHILD_REQUESTS.memory);
+  const max = gi(limit);
+  return request !== null && max !== null && request > max ? limit! : POD_CHILD_REQUESTS.memory;
+}
+
 /** POD7 must-fix: the skill list alone can't tell a network-only job from one that needs ffmpeg/browser — so lite is
  *  only ever chosen when the caller says so (`lite`), and then only for network skills without a clone. Anything we
  *  can't judge keeps the full image. A lite request that doesn't fit is refused with the reason, not silently widened. */
@@ -50,6 +59,26 @@ export function podCommandImageFor(skills: readonly string[], clone: boolean, li
 
 const COMMAND_LOG_CHARS = 80;
 
+/** 자식 로그 전문 상한(바이트) — 넘으면 끝부분을 남긴다. config `pod.childLogMaxBytes` 가 양의 정수일 때만 그 값. */
+export const POD_CHILD_LOG_MAX_BYTES_DEFAULT = 1_048_576;
+
+export function podChildLogMaxBytes(read: () => number | undefined = () => getUserConfig().pod?.childLogMaxBytes): number {
+  const configured = read();
+  return typeof configured === 'number' && Number.isSafeInteger(configured) && configured > 0
+    ? configured
+    : POD_CHILD_LOG_MAX_BYTES_DEFAULT;
+}
+
+/** 크기 상한을 넘으면 끝부분을 남긴다(잘린 앞은 표시). */
+export function tailBytes(text: string, maxBytes: number): string {
+  const bytes = Buffer.from(text);
+  if (bytes.length <= maxBytes) return text;
+  const cut = bytes.subarray(bytes.length - maxBytes);
+  let start = 0;
+  while (start < cut.length && (cut[start]! & 0xc0) === 0x80) start += 1;
+  return `…[앞 ${bytes.length - maxBytes}바이트 생략]\n${cut.subarray(start).toString('utf8')}`;
+}
+
 const GATE = `ok=0
 for i in $(seq 1 60); do
   if curl -s -m 1 -o /dev/null http://host.orb.internal:31415/health || curl -s -m 1 -o /dev/null http://core.elanous-prod:8080/; then ok=0; else ok=$((ok+1)); fi
@@ -156,7 +185,7 @@ export function podCommandJobManifest(o: PodCommandJobInput): Record<string, unk
           initContainers: [{ name: 'isolation-gate', image: o.image, imagePullPolicy: o.imagePullPolicy ?? 'Never', command: ['bash', '-c'], args: [GATE] }],
           containers: [{
             name: 'child', image: o.image, imagePullPolicy: o.imagePullPolicy ?? 'Never',
-            resources: { requests: { ...POD_CHILD_REQUESTS }, limits: { memory: o.memoryLimit ?? '16Gi', cpu: '4' } },
+            resources: { requests: { ...POD_CHILD_REQUESTS, memory: memoryRequestWithin(o.memoryLimit) }, limits: { memory: o.memoryLimit ?? '16Gi', cpu: '4' } },
             command: ['bash', '-c'], args: [script],
             env: [
               ...(o.runId ? [{ name: 'ELANOUS_RUN_ID', value: o.runId }] : []),
@@ -214,12 +243,23 @@ export function podCommandSecretKeys(secret: Record<string, unknown> | null): st
   return Object.keys((secret.stringData as Record<string, string> | undefined) ?? {});
 }
 
+export interface PodArtifactCollection {
+  /** 회수한 산출 파일 수(child.log 제외). 로그 조회 실패면 null. */
+  files: number | null;
+  /** 회수한 산출 파일의 상대 경로. */
+  names: string[];
+  /** 로그 조회 자체가 실패했을 때의 사유. 성공이면 null. */
+  error: string | null;
+}
+
 export interface PodCommandResult {
   exitCode: number;
   artifactsDir: string;
   job: string;
   /** 이 런이 실제로 쓴 이미지(레지스트리 판 태그 또는 로컬 이름). */
   image?: string;
+  /** collectPodArtifacts 가 회수한 파일. 로그 조회 실패면 files=null · error=사유. runPodCommand 는 항상 채운다. */
+  artifacts?: PodArtifactCollection;
 }
 
 export interface RunPodCommandOptions {
@@ -255,6 +295,8 @@ export interface RunPodCommandOptions {
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
   env?: NodeJS.ProcessEnv;
   configHostMirror?: () => string | undefined;
+  /** 자식 로그 전문 상한(바이트). 생략 시 config `pod.childLogMaxBytes`, 없으면 1MiB. 넘으면 끝부분 우선. */
+  childLogMaxBytes?: number;
 }
 
 function jobFinished(types: string): 'complete' | 'failed' | null {
@@ -263,6 +305,19 @@ function jobFinished(types: string): 'complete' | 'failed' | null {
   return null;
 }
 
+function artifactNames(logs: string): string[] {
+  const names = new Set<string>();
+  for (const line of logs.split(/\r?\n/)) {
+    const match = /^ELANOUS_POD_ARTIFACT (\S+) \d+\/\d+ /.exec(line);
+    if (!match) continue;
+    try {
+      const path = Buffer.from(match[1]!, 'base64url').toString('utf8');
+      if (path && !path.split('/').some((part) => part === '' || part === '.' || part === '..')) names.add(path);
+    } catch { /* 회수 쪽(collectPodArtifacts)이 불완전 사유를 남긴다 */ }
+  }
+  return [...names];
+}
+
 function exitCodeFromPod(kubectl: Kubectl, namespace: string, job: string, state: 'complete' | 'failed'): number {
   const got = kubectl(['-n', namespace, 'get', 'pods', '-l', `job-name=${job}`, '-o', 'jsonpath={.items[0].status.containerStatuses[?(@.name=="child")].state.terminated.exitCode}']);
   const code = Number(got.stdout.trim());
@@ -316,7 +371,7 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
   }
   if (pool) {
     for (;;) {
-      member = pool.tryAcquire();
+      member = await pool.tryAcquire();
       if (member) break;
       await sleep(options.pollMs ?? 15_000);
     }
@@ -387,12 +442,29 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       if (finished) { state = finished; break; }
       await sleep(options.pollMs ?? 15_000);
     }
-    const logs = kubectl(['-n', namespace, 'logs', `job/${name}`, '-c', 'child']).stdout;
-    collectPodArtifacts(logs, {
-      dir: options.artifactsRoot ?? `${effectiveInstanceRoot()}/pod-artifacts`,
-      job: name,
-      log: (c, e, d) => log(c, e, d),
-    });
+    const logsResult = kubectl(['-n', namespace, 'logs', `job/${name}`, '-c', 'child']);
+    const logsFailed = logsResult.status !== 0;
+    const logs = logsFailed ? '' : logsResult.stdout;
+    const artifactDir = options.artifactsRoot ?? `${effectiveInstanceRoot()}/pod-artifacts`;
+    let artifacts: PodArtifactCollection;
+    if (logsFailed) {
+      const reason = logsResult.stderr.trim() || `kubectl logs exit ${logsResult.status}`;
+      artifacts = { files: null, names: [], error: reason };
+      log('pod.command', 'artifact-collect-failed', { job: name, reason });
+    } else {
+      collectPodArtifacts(logs, {
+        dir: artifactDir,
+        job: name,
+        log: (c, e, d) => log(c, e, d),
+      });
+      const names = artifactNames(logs);
+      artifacts = { files: names.length, names, error: null };
+    }
+    // 표지가 없어도 알리는 경로는 실제로 존재해야 한다. 자식 로그 전문은 child.log (상한 넘으면 끝부분).
+    mkdirSync(artifactsDir, { recursive: true });
+    const maxBytes = options.childLogMaxBytes ?? podChildLogMaxBytes();
+    const childLog = logsFailed ? `산출 회수 못 함: ${artifacts.error}` : tailBytes(logs, maxBytes);
+    writeFileSync(resolve(artifactsDir, 'child.log'), childLog);
     const exitCode = exitCodeFromPod(kubectl, namespace, name, state);
     cleanupSecret();
     log('pod.command', 'job-finished', {
@@ -401,8 +473,11 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       skills,
       llm: llm ?? null,
       command: command.join(' ').slice(0, COMMAND_LOG_CHARS),
+      artifactsDir,
+      artifacts,
+      ...(logsFailed ? { artifactError: `산출 회수 못 함: ${artifacts.error}` } : {}),
     });
-    return { exitCode, artifactsDir, job: name, image: imageRef ?? image };
+    return { exitCode, artifactsDir, job: name, image: imageRef ?? image, artifacts };
   } catch (err) {
     cleanupSecret();
     throw err;

package/src/task-orchestrator/surfaces/pod-failure-reason.ts

@@ -0,0 +1,48 @@
+/** Extract a human-readable reason from a failed child Pod without treating transfer markers as child errors. */
+export function extractPodFailureReason(input: {
+  logs: string;
+  logTailReason?: string;
+  containerReason?: string | null;
+  jobReason?: string;
+  deadlineSeconds?: number;
+}): string {
+  if (input.jobReason === 'DeadlineExceeded') {
+    return `DeadlineExceeded: Job 수명 상한 ${input.deadlineSeconds ?? 'unknown'}초 초과`;
+  }
+  if (input.containerReason === 'OOMKilled') return 'OOMKilled: 컨테이너 메모리 한도 초과';
+
+  const isBookkeeping = (line: string): boolean =>
+    /^ELANOUS_(?:MEM|RUN_LEDGER|USAGE_ROLLUP|POD_)/u.test(line) || /^(?:at\s+\S|\.\.\.\s+\d+\s+more\b|cleanup\s+(?:complete|done|finished)\b)/iu.test(line);
+  const isError = (line: string): boolean =>
+    /\berror\b|\bfail(?:ed|ure)?\b|exception|fatal|denied|timed?\s*out|exceeded|overloaded|unavailable|exhausted|오류|실패/iu.test(line);
+  const meaningful: Array<{ text: string; terminal: boolean }> = [];
+  for (const line of input.logs.split(/\r\n|\n|\r/u)) {
+    const trimmed = line.trim();
+    if (!trimmed || isBookkeeping(trimmed)) continue;
+    if (trimmed.startsWith('{')) {
+      let parsed: unknown;
+      try { parsed = JSON.parse(trimmed); } catch { /* An ordinary line may begin with a brace. */ }
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        const row = parsed as Record<string, unknown>;
+        if (typeof row.ok === 'boolean' && typeof row.stage === 'string') {
+          meaningful.length = 0;
+          if (row.ok === false && typeof row.error === 'string') {
+            const errorLines = row.error.split(/\r\n|\n|\r/u).map((part) => part.trim())
+              .filter((part) => part && !isBookkeeping(part));
+            const errorLine = [...errorLines].reverse().find(isError) ?? errorLines.at(-1);
+            if (errorLine) meaningful.push({ text: errorLine, terminal: true });
+          }
+          continue;
+        }
+        // A JSON transfer/observation is not a plain-text failure reason.
+        continue;
+      }
+    }
+    meaningful.push({ text: trimmed, terminal: false });
+  }
+  const errorLine = [...meaningful].reverse().find((line) => line.terminal || isError(line.text));
+  const reason = errorLine?.text.replace(/\/home\/[^/\s]+\//gu, '~/').slice(0, 240);
+  if (reason) return reason;
+  const why = input.logTailReason?.trim() || (input.logs.trim() ? '로그에 읽을 수 있는 오류 줄 없음' : '자식 로그 비어 있음');
+  return `사유 못 읽음: ${why.replace(/\/home\/[^/\s]+\//gu, '~/').slice(0, 240)}`;
+}

package/src/task-orchestrator/surfaces/pod-lease.ts

@@ -12,12 +12,15 @@ export const POD_HOST_LEASE_ANNOTATION = 'elanous.dev/host-lease-admitted';
 
 // `get pods --all-namespaces -o json` on a busy cluster is several MB — the default spawnSync
 // buffer fails with ENOBUFS (10-03 node-b measured). Same proxy stripping as the Pod launch kubectl.
-const LEASE_KUBECTL_MAX_BUFFER = 256 * 1024 * 1024;
+export const LEASE_KUBECTL_MAX_BUFFER = 256 * 1024 * 1024;
 export function leaseKubectl(args: readonly string[], input?: string): { status: number | null; stdout: string; stderr: string } {
   const env = { ...process.env };
   for (const k of ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy', 'ALL_PROXY', 'all_proxy']) delete env[k];
   const r = spawnSync('kubectl', [...args], { encoding: 'utf8', input, env, timeout: 120_000, maxBuffer: LEASE_KUBECTL_MAX_BUFFER });
-  return { status: r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + (r.error ? String(r.error) : '') };
+  const error = (r.error as NodeJS.ErrnoException | undefined)?.code === 'ENOBUFS'
+    ? `kubectl 출력 너무 큼 (ENOBUFS; maxBuffer=${LEASE_KUBECTL_MAX_BUFFER} bytes)`
+    : r.error ? String(r.error) : '';
+  return { status: r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + error };
 }
 
 export interface PodLeaseMember {