elanous 0.2.4 → 0.2.6

package/src/self-implement/seams.ts

@@ -60,7 +60,7 @@ import { pwaReachableSrcFiles } from './pwa-import-graph.js';
 import { stageNonGitDir, stageFile, applyShadowToTarget, applyFileToTarget } from './shadow-stage.js';
 import type { TargetKind } from './target-kind.js';
 import { basename } from 'node:path';
-import { makePrManager, type PrManager } from '../autopilot/pr-manager.js';
+import { ghAutomationEnv, makePrManager, type PrManager } from '../autopilot/pr-manager.js';
 import { defaultSpawnGh, lookupOpenDraftPrs } from '../cli/logs-abandoned-draft-prs.js';
 import { loadRunLedger, runLedgerDir } from './run-ledger.js';
 import { readdirSync } from 'node:fs';
@@ -2347,8 +2347,10 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
     closePr: (prUrl, comment) => (o.prManager ?? makePrManager()).closePr(prUrl, comment),
 
     postPrComment: async ({ number, body, cwd }) => {
+      // Round comments go out as the GitHub App like the PR itself — a personal `gh` login made the owner a
+      // participant and mailed them on merge (#22089).
       await execFileAsync('gh', ['pr', 'comment', String(number), '--body', body], {
-        cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, maxBuffer: 64 * 1024 * 1024,
+        cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, maxBuffer: 64 * 1024 * 1024, env: ghAutomationEnv(process.env),
       });
     },
 

package/src/session/index.ts

@@ -434,12 +434,20 @@ function readIndex(root: string = sessionRoot()): SessionMeta[] {
   }
 }
 
-function writeIndex(entries: SessionMeta[], root: string = sessionRoot()): void {
+// 여러 프로세스(`elanous ask` 동시 실행 등)가 같은 목록을 «읽고-고치고-통째로 쓰기» 한다.
+// 쓰기 직전 잠금 안에서 디스크의 최신 목록을 다시 읽어 id 로 합치고, 임시 파일 이름은 프로세스마다 다르게 한다
+// (10-01 MK 재현: 고정 `index.json.tmp` → 한쪽 ENOENT · 덮어쓰기로 남의 세션이 목록에서 사라짐).
+function writeIndex(entries: SessionMeta[], root: string = sessionRoot(), removed: Iterable<string> = []): void {
   ensureRoots(root);
   const p = indexPath(root);
-  const tmp = p + '.tmp';
-  writeFileSync(tmp, JSON.stringify(entries, null, 2) + '\n', 'utf-8');
-  renameSync(tmp, p);
+  withDirLock(join(root, '.index.lock'), INDEX_LOCK_TIMEOUT_MS, () => {
+    const mine = new Set(entries.map((m) => m.id));
+    const gone = new Set(removed);
+    const peers = readIndex(root).filter((m) => !mine.has(m.id) && !gone.has(m.id));
+    const tmp = `${p}.${process.pid}.${randomUUID().slice(0, 8)}.tmp`;
+    writeFileSync(tmp, JSON.stringify([...peers, ...entries], null, 2) + '\n', 'utf-8');
+    renameSync(tmp, p);
+  });
 }
 
 // ── Tier 1 Phase 3 — listener primitive ──────────────────────────────
@@ -661,7 +669,7 @@ export function rewriteSessionMessages(
   const body = messages
     .map(m => JSON.stringify(m.turn_id !== undefined ? m : { ...m, turn_id: mintTurnUri() }))
     .join('\n');
-  const tmp = file + '.tmp';
+  const tmp = `${file}.${process.pid}.${randomUUID().slice(0, 8)}.tmp`;
   writeFileSync(tmp, body ? body + '\n' : '', 'utf-8');
   renameSync(tmp, file);
 
@@ -800,8 +808,13 @@ function residentSessionLockPath(root: string): string {
 
 function withResidentSessionLock<T>(root: string, action: () => T): T {
   ensureRoots(root);
-  const lock = residentSessionLockPath(root);
-  const deadline = Date.now() + RESIDENT_SESSION_LOCK_TIMEOUT_MS;
+  return withDirLock(residentSessionLockPath(root), RESIDENT_SESSION_LOCK_TIMEOUT_MS, action);
+}
+
+const INDEX_LOCK_TIMEOUT_MS = 10_000;
+
+function withDirLock<T>(lock: string, timeoutMs: number, action: () => T): T {
+  const deadline = Date.now() + timeoutMs;
   for (;;) {
     try {
       mkdirSync(lock);
@@ -814,7 +827,7 @@ function withResidentSessionLock<T>(root: string, action: () => T): T {
           continue;
         }
       } catch { continue; }
-      if (Date.now() >= deadline) throw new Error(`timed out acquiring resident session lock for ${root}`);
+      if (Date.now() >= deadline) throw new Error(`timed out acquiring lock ${lock}`);
       Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
       void error;
     }
@@ -855,7 +868,7 @@ export function deleteSession(id: string, root: string = sessionRoot()): boolean
   const before = idx.length;
   const next = idx.filter(m => m.id !== id);
   if (next.length === before) return false;
-  writeIndex(next, root);
+  writeIndex(next, root, [id]);
   // Clear active marker if it pointed at the deleted session.
   if (getActiveSessionId() === id) clearActiveSessionId();
   return true;
@@ -876,7 +889,7 @@ export function deleteSessions(ids: string[], root: string = sessionRoot()): num
   const idx = readIndex(root);
   const next = idx.filter(m => !set.has(m.id));
   const removed = idx.length - next.length;
-  if (removed > 0) writeIndex(next, root);
+  if (removed > 0) writeIndex(next, root, set);
   const active = getActiveSessionId();
   if (active && set.has(active)) clearActiveSessionId();
   return removed;

package/src/skills/tools/dev-harness.ts

@@ -13,7 +13,9 @@
 // ★ 제1원칙: front door 결정 observe(harness.frontdoor) — objective digest·autoDrive·terminal.
 //   autoDrive 'safe'(기본): 저위험 자율·고위험(PR open)만 ux.confirm(막 채널 없으면 fail-closed).
 
+import { createHash } from 'node:crypto';
 import { tierModel } from '../../llm/model-defaults.js';
+import { dispatchTask, type DispatchTaskDeps } from '../../execution-loop/dispatch-task.js';
 import type { LLMToolSpec } from '../../llm.js';
 import type { DaemonToolDispatchCtx } from '../../boot/daemon-tools/types.js';
 import type { SelfImplementSeams } from '../../self-implement/orchestrator.js';
@@ -96,6 +98,9 @@ export function buildRunDevHarnessTool(): LLMToolSpec {
 export interface DevHarnessDeps {
   /** 하니스 구동(기본 runStagedHarnessOnSurface). */
   runHarness?: (opts: RunHarnessOnSurfaceOptions) => Promise<HarnessResult>;
+  /** In-process 실행 직전의 관측 전용 디스패치 seam. */
+  dispatchTask?: typeof dispatchTask;
+  dispatchTaskDeps?: DispatchTaskDeps;
   /** seam 팩토리(기본 defaultSeams). */
   seamsFactory?: (o: DefaultSeamsOptions) => SelfImplementSeams;
   /** 비대화형 HITL relay 팩토리 seam(기본 buildLlmHitlRelay). */
@@ -468,6 +473,43 @@ export async function dispatchRunDevHarness(
   const runHarness = deps?.runHarness ?? runStagedHarnessOnSurface;
   const knobs = resolveHarnessKnobs(rawArgs, ctx?.userText);   // ★ B1 관통 — C1~C4 노브를 surface 파라미터에서 막으로
   const harnessMention = harnessMentionState(ctx?.userText);
+  // Outer pipeline/Pod observations are not repeated; this decision never controls the harness.
+  const dispatchSkipped = rawArgs.plan_staged === true ? 'plan-staged'
+    : rawArgs.dispatch_recorded === true || process.env.ELANOUS_DISPATCH_RECORDED === '1' ? 'dispatch-recorded'
+    : process.env.ELANOUS_EXECUTION_LOOP_DISPATCH === 'off' && !deps?.dispatchTask && !deps?.dispatchTaskDeps ? 'disabled'
+    : undefined;
+  if (dispatchSkipped) {
+    try { debug.log('execution-loop.gate', 'dispatch-skipped', { reason: dispatchSkipped, runId }); } catch { /* fail-soft */ }
+  } else {
+    try {
+      const spec = { input: { text: objective }, executor: { kind: 'self' as const }, plan: true, runId };
+      const observer = new AbortController();
+      const timeoutMs = Math.min(5_000, Math.max(0, deps?.dispatchTaskDeps?.timeoutMs ?? 5_000));
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      try {
+        await Promise.race([
+          Promise.resolve().then(() => (deps?.dispatchTask ?? dispatchTask)({
+            goalId: `request-${createHash('sha256').update(objective).digest('hex').slice(0, 32)}`,
+            title: objective.split(/\r?\n/, 1)[0]?.trim() || 'Untitled request',
+            goalText: objective,
+            targetPaths: [],
+            spec,
+            runKey: runId,
+          }, { ...deps?.dispatchTaskDeps, signal: observer.signal })),
+          new Promise<never>((_, reject) => {
+            timer = setTimeout(() => {
+              observer.abort();
+              reject(new Error(`dispatch observation timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+          }),
+        ]);
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+    } catch (error) {
+      try { debug.log('execution-loop.gate', 'dispatch-unavailable', { reason: String(error), runId }); } catch { /* fail-soft */ }
+    }
+  }
   const result = await runHarness({
     // ⛔⭐ `naturalLanguageDispatch` 를 «단정»하지 않는다 — 증거로 정한다.
     //   이 함수는 «둘» 이 지난다: ⑴ 모델이 부른 도구(사용자 턴 문면이 ctx.userText 로 온다)

package/src/steward/steward-cards.ts

@@ -0,0 +1,45 @@
+import { createHash } from 'node:crypto';
+import { CardStore, redactSecrets, type AppendSectionInput, type CreateCardInput, type TaskCard } from '../task-cards/card-store.js';
+import type { ScheduledDecision, TriageIssue } from './triage.js';
+
+export interface StewardCardStore {
+  createCard(input: CreateCardInput): TaskCard;
+  appendSection(id: string, input: AppendSectionInput): TaskCard;
+  close(): void;
+}
+
+export interface StewardCardDeps {
+  store?: StewardCardStore;
+  root?: string;
+  now?: () => Date;
+}
+
+/** Record observe-only intake and the latest scheduled judgment without launching any work. */
+export function recordTriageOnCards(decisions: ScheduledDecision[], issues: TriageIssue[], deps: StewardCardDeps = {}): void {
+  const store = deps.store ?? new CardStore(deps.root);
+  const byIssue = new Map(issues.map(issue => [issue.identifier, issue]));
+  try {
+    for (const decision of decisions) {
+      const issue = byIssue.get(decision.issue);
+      if (!issue) throw new Error(`Missing issue ${decision.issue}`);
+      const card = store.createCard({ goalId: `linear:${issue.identifier}`, title: redactSecrets(issue.title) });
+      const intakeKey = `intake:${issue.identifier}`;
+      if (!card.sections.some(section => section.key === intakeKey)) {
+        const directiveSource = /^출처: (telegram|pwa|tui|cli)$/m.exec(issue.body)?.[1];
+        const directiveTime = /^시각: (\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)$/m.exec(issue.body)?.[1];
+        store.appendSection(card.id, {
+          key: intakeKey, owner: 'steward',
+          content: JSON.stringify({ summary: redactSecrets(issue.title), source: directiveSource ?? `linear:${issue.identifier}`, at: directiveTime ?? (deps.now ?? (() => new Date()))().toISOString() }),
+        });
+      }
+      const { rung, dependsOn, priority, disposition, hitlReason, why, owner } = decision;
+      const judgment = { rung, dependsOn, priority, disposition: rung === 'hitl' || hitlReason ? 'hitl' : disposition, hitlReason: hitlReason ?? null, why: redactSecrets(why), ...(owner ? { owner } : {}) };
+      const key = `triage:${createHash('sha256').update(JSON.stringify(judgment)).digest('hex')}`;
+      if (!card.sections.some(section => section.key === key)) {
+        store.appendSection(card.id, { key, owner: 'steward', content: JSON.stringify(judgment) });
+      }
+    }
+  } finally {
+    if (!deps.store) store.close();
+  }
+}

package/src/steward/triage.ts

@@ -4,30 +4,39 @@ import { fetchLinearIssues } from '../connectors/linear.js';
 import { getSecretAsync } from '../nexus/config/secrets/index.js';
 import { getUserConfig } from '../user-config.js';
 import { emitDecision } from '../live/detail-switch.js';
+import { debug, redactSecretText } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { redactSecrets } from '../task-cards/card-store.js';
 import { directiveHash } from './directive.js';
+import { recordTriageOnCards, type StewardCardDeps } from './steward-cards.js';
 
 export type Rung = 0 | 1 | 2 | 3 | 4 | 5 | 'hitl';
-export type HitlReason = 'money' | 'public' | 'security' | 'irreversible';
+/** `other` = the judge chose human review for a reason outside the four named ones (kept as HITL, never downgraded). */
+export type HitlReason = 'money' | 'public' | 'security' | 'irreversible' | 'other';
 export interface TriageIssue { identifier: string; ref: string; title: string; body: string }
 export interface TriageDecision {
   issue: string; rung: Rung; dependsOn: string[]; priority: number; duplicateOf?: string;
   hitlReason?: HitlReason; why: string; role?: string; cost?: number;
+  /** Owner track from `loops.steward.tracks` (absent when no table is configured or the judge picked none of its keys). */
+  owner?: string;
 }
 export interface ScheduledDecision extends TriageDecision { disposition: 'now' | 'wait' | 'hitl' }
 export interface StewardSettings {
   mode?: 'observe' | 'act'; linearTeam?: string;
   roles?: Record<string, { maxConcurrent?: number }>;
   budget?: number;
+  tracks?: Record<string, string>;
 }
 export interface StewardDeps {
   fetch?: typeof fetch;
   getSecret?: (id: string) => Promise<string | undefined>;
-  judge?: (issue: TriageIssue, issues: TriageIssue[]) => Promise<unknown>;
+  judge?: (issue: TriageIssue, issues: TriageIssue[], tracks?: Record<string, string>) => Promise<unknown>;
   decide?: typeof emitDecision;
   sendDigest?: (text: string) => Promise<void>;
   now?: () => Date;
   root?: string;
+  cardStore?: StewardCardDeps['store'];
+  warn?: (message: string) => void;
 }
 
 export function stewardSettings(): StewardSettings {
@@ -41,7 +50,7 @@ const unsafe: Array<[HitlReason, RegExp]> = [
   ['irreversible', /비가역|강제\s*푸시|force.push|영구\s*삭제|리셋권\s*소비|drop\s*table|초기화/i],
 ];
 
-function parseJudgment(issue: TriageIssue, raw: unknown): TriageDecision {
+function parseJudgment(issue: TriageIssue, raw: unknown, tracks?: Record<string, string>): TriageDecision {
   const value = typeof raw === 'string' ? JSON.parse(raw) as unknown : raw;
   if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`Invalid triage judgment: ${issue.identifier}`);
   const d = value as Record<string, unknown>;
@@ -51,8 +60,9 @@ function parseJudgment(issue: TriageIssue, raw: unknown): TriageDecision {
     throw new Error(`Invalid triage judgment: ${issue.identifier}`);
   }
   const forced = unsafe.find(([, pattern]) => pattern.test(`${issue.title}\n${issue.body}`))?.[0];
-  const hitlReason = forced ?? (unsafe.some(([reason]) => reason === d.hitlReason) ? d.hitlReason as HitlReason : undefined);
-  if (d.rung === 'hitl' && !hitlReason) throw new Error(`HITL reason required: ${issue.identifier}`);
+  const named = forced ?? (unsafe.some(([reason]) => reason === d.hitlReason) ? d.hitlReason as HitlReason : undefined);
+  // A HITL judgment without one of the four named reasons stays HITL (`other`) — one issue must not stop the stage.
+  const hitlReason = named ?? (d.rung === 'hitl' ? 'other' as const : undefined);
   return {
     issue: issue.identifier, rung: hitlReason ? 'hitl' : d.rung as Rung,
     dependsOn: d.dependsOn as string[], priority: d.priority as number,
@@ -60,24 +70,40 @@ function parseJudgment(issue: TriageIssue, raw: unknown): TriageDecision {
     ...(hitlReason ? { hitlReason } : {}), why: (d.why as string).trim().replace(/\s+/g, ' '),
     ...(typeof d.role === 'string' ? { role: d.role } : {}),
     ...(typeof d.cost === 'number' && Number.isFinite(d.cost) && d.cost >= 0 ? { cost: d.cost } : {}),
+    ...(tracks && typeof d.owner === 'string' && Object.hasOwn(tracks, d.owner) ? { owner: d.owner } : {}),
   };
 }
 
-async function judgeStewardIssue(issue: TriageIssue, issues: TriageIssue[]): Promise<unknown> {
-  const prompt = `스튜어드 트리아지. JSON 객체만 출력: {"rung":0|1|2|3|4|5|"hitl","dependsOn":[],"priority":1,"duplicateOf":null,"hitlReason":null,"why":"한 문장","role":"builder","cost":0}.\n0=이미됨/중복, 1=셸, 2=CLI, 3=조사, 4=하니스 골, 5=외부 에이전트. 돈·공개·보안·비가역은 hitl. 확인되지 않은 완료/중복은 추측하지 마라. 의존은 제공된 이슈 키만 써라.\n이슈 목록: ${JSON.stringify(issues.map(i => ({ key: i.identifier, title: i.title })))}\n판정 대상: ${JSON.stringify(issue)}`;
+/** The role table as prompt lines — read from config so a reorg edits one place. */
+export function trackTablePrompt(tracks?: Record<string, string>): string {
+  if (!tracks || !Object.keys(tracks).length) return '';
+  const keys = Object.keys(tracks);
+  return `\n담당 트랙(owner) — 아래 중 하나(${keys.map(k => JSON.stringify(k)).join('|')}) · 이슈가 어느 트랙 일인지:\n${keys.map(k => `- ${k}: ${tracks[k]}`).join('\n')}`;
+}
+
+async function judgeStewardIssue(issue: TriageIssue, issues: TriageIssue[], tracks?: Record<string, string>): Promise<unknown> {
+  const ownerField = tracks && Object.keys(tracks).length ? `,"owner":${JSON.stringify(Object.keys(tracks)[0])}` : '';
+  const prompt = `스튜어드 트리아지. JSON 객체만 출력: {"rung":0|1|2|3|4|5|"hitl","dependsOn":[],"priority":1,"duplicateOf":null,"hitlReason":null,"why":"한 문장","role":"builder","cost":0${ownerField}}.\n0=이미됨/중복, 1=셸, 2=CLI, 3=조사, 4=하니스 골, 5=외부 에이전트. 돈·공개·보안·비가역은 hitl(hitlReason = "money"|"public"|"security"|"irreversible" · 그 밖의 이유로 사람 확인이 필요하면 "other"). 확인되지 않은 완료/중복은 추측하지 마라. 의존은 제공된 이슈 키만 써라.${trackTablePrompt(tracks)}\n이슈 목록: ${JSON.stringify(issues.map(i => ({ key: i.identifier, title: i.title })))}\n판정 대상: ${JSON.stringify(issue)}`;
   const { streamLLM } = await import('../llm.js');
   const { tierModel } = await import('../llm/model-defaults.js');
   const result = await streamLLM([{ role: 'user', content: prompt }], () => {}, { model: tierModel('best') });
   return JSON.parse(result.replace(/^```(?:json)?\s*|\s*```$/g, '').trim()) as unknown;
 }
 
-export async function triageIssues(issues: TriageIssue[], judge: NonNullable<StewardDeps['judge']> = judgeStewardIssue, decide: typeof emitDecision = emitDecision): Promise<TriageDecision[]> {
+export async function triageIssues(issues: TriageIssue[], judge: NonNullable<StewardDeps['judge']> = judgeStewardIssue, decide: typeof emitDecision = emitDecision, tracks?: Record<string, string>): Promise<TriageDecision[]> {
   const decisions: TriageDecision[] = [];
   for (const issue of issues) {
-    const result = parseJudgment(issue, await judge(issue, issues));
+    let result: TriageDecision;
+    try {
+      result = parseJudgment(issue, await judge(issue, issues, tracks), tracks);
+    } catch (error) {
+      // A malformed or failed judgment for one issue goes to a human; the other issues are still triaged.
+      try { debug.log('steward.stage', 'judgment-invalid', { issue: issue.identifier, reason: redactSecrets(String(error)) }); } catch { /* fail-soft */ }
+      result = { issue: issue.identifier, rung: 'hitl', hitlReason: 'other', dependsOn: [], priority: 0, why: 'triage judgment unavailable — human review' };
+    }
     decisions.push(result);
     decide({ kind: result.rung === 'hitl' ? 'ESCALATE' : 'ROUTE', what: issue.identifier, reason: result.why,
-      purpose: 'steward triage', target: String(result.rung), refs: { issue: issue.identifier } });
+      purpose: 'steward triage', target: result.owner ? `${result.rung} · ${result.owner}` : String(result.rung), refs: { issue: issue.identifier } });
   }
   return decisions;
 }
@@ -99,7 +125,7 @@ export function scheduleTriage(decisions: TriageDecision[], settings: StewardSet
   const slots = { ...running };
   let remaining = settings.budget ?? Infinity;
   return sorted.map(item => {
-    const role = item.role ?? String(item.rung);
+    const role = item.owner ?? item.role ?? String(item.rung);
     const max = settings.roles?.[role]?.maxConcurrent ?? Infinity;
     const blocked = item.dependsOn.some(dep => !completed.has(dep));
     const status: ScheduledDecision['disposition'] = item.rung === 'hitl' || item.hitlReason ? 'hitl' :
@@ -146,7 +172,7 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
   } else if (stage === 'triage') {
     const issues = JSON.parse(readFileSync(snapshot, 'utf8')) as TriageIssue[];
     const judge = deps.judge ?? judgeStewardIssue;
-    writeFileSync(judgments, JSON.stringify(await triageIssues(issues, judge, deps.decide)));
+    writeFileSync(judgments, JSON.stringify(await triageIssues(issues, judge, deps.decide, settings.tracks)));
   } else if (stage === 'schedule') {
     const decisions = JSON.parse(readFileSync(judgments, 'utf8')) as TriageDecision[];
     const pending = new Set(decisions.flatMap(decision => decision.dependsOn));
@@ -163,6 +189,13 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
     const state = readState(path);
     const at = (deps.now ?? (() => new Date()))().toISOString();
     const issues = JSON.parse(readFileSync(snapshot, 'utf8')) as TriageIssue[];
+    try {
+      recordTriageOnCards(rows, issues, { root, store: deps.cardStore, now: deps.now });
+    } catch (error) {
+      const message = `steward report: card write failed: ${redactSecrets(error instanceof Error ? error.message : String(error))}`;
+      debug.log('steward.cards', 'write-failed', { error: message });
+      (deps.warn ?? console.warn)(message);
+    }
     for (const row of rows) {
       const issue = issues.find(item => item.identifier === row.issue);
       if (!issue) throw new Error(`Missing issue ${row.issue}`);
@@ -195,8 +228,11 @@ if (import.meta.main) {
     console.error('steward: expected sync|triage|schedule|report');
     process.exitCode = 2;
   } else {
-    runStewardStage(stage as 'sync' | 'triage' | 'schedule' | 'report').catch(() => {
-      console.error(`steward ${stage}: stage failed`);
+    runStewardStage(stage as 'sync' | 'triage' | 'schedule' | 'report').catch((error: unknown) => {
+      // Say why (secrets masked) — 09-29 the first resident run failed as a bare «stage failed» on a missing Linear key.
+      const reason = redactSecretText(error instanceof Error ? error.message : String(error)).slice(0, 300);
+      console.error(`steward ${stage}: stage failed — ${reason}`);
+      debug.log('steward.stage', 'failed', { stage, reason });
       process.exitCode = 1;
     });
   }

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

@@ -2,6 +2,8 @@ import { lstatSync, mkdirSync, 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';
 
 const FILE_LIMIT = 5 * 1024 * 1024;
 const TOTAL_LIMIT = 20 * 1024 * 1024;
@@ -79,14 +81,63 @@ export function parsePodArtifactChunks(logs: string): ParseResult {
   return error.length ? { error, artifacts } : artifacts;
 }
 
+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',
+  };
+}
+
+/** 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 } {
+  if (!store) return { imported: 0, skipped: 0 };
+  const text = bytes.toString('utf8');
+  const rows: Array<{ rec: LogRecord; surface: string }> = [];
+  let skipped = 0;
+  for (const line of text.split(/\r?\n/)) {
+    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);
+  }
+  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. */
-export function collectPodArtifacts(logs: string, { dir, job, log = (c, e, d) => debug.log(c, e, d) }: {
+export function collectPodArtifacts(logs: string, { dir, job, log = (c, e, d) => debug.log(c, e, d), logStore = getDefaultLogStore() }: {
   dir: string;
   job: string;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
+  logStore?: LogStore | null;
 }): void {
   const parsed = parsePodArtifactChunks(logs);
-  const podLogsPath = 'pod-logs/logs.jsonl';
+  const podLogsPath = POD_LOGS_PATH;
   let podLogsReturned = false;
   let podLogsMissingReason = logs.split(/\r?\n/).find((line) => line.startsWith(`ELANOUS_POD_ARTIFACT_SKIPPED ${podLogsPath} `))
     ? 'artifact skipped (size limit or encoding failure)'
@@ -123,7 +174,14 @@ export function collectPodArtifacts(logs: string, { dir, job, log = (c, e, d) =>
       log('self-implement.pod', 'artifact-collected', { job, path, bytes: bytes.length });
       if (path === podLogsPath) {
         podLogsReturned = true;
-        log('self-implement.pod', 'pod-logs-returned', { job, path: destination, lines: bytes.length ? bytes.toString('utf8').split('\n').length - (bytes.at(-1) === 10 ? 1 : 0) : 0 });
+        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) });
+        }
       }
     } catch (e) {
       const reason = (e as NodeJS.ErrnoException).code === 'EEXIST' ? 'exists' : e instanceof Error ? e.message : String(e);

package/src/task-orchestrator/surfaces/pod-bun-cache.ts

@@ -0,0 +1,18 @@
+export const POD_BUN_CACHE_HOST_PATH = 'POD_BUN_CACHE_HOST_PATH';
+
+/** A host-backed Bun install cache; only opt into it when the mounted directory is writable. */
+export function podBunCacheVolume(hostPath: string) {
+  return {
+    volume: { name: 'bun-cache', hostPath: { path: hostPath, type: 'DirectoryOrCreate' } },
+    volumeMount: { name: 'bun-cache', mountPath: '/bun-cache', readOnly: false },
+    shellPrefix: 'if [ -d /bun-cache ] && [ -w /bun-cache ]; then export BUN_INSTALL_CACHE_DIR=/bun-cache; fi;',
+  };
+}
+
+/** First Bun install timing in a combined shard log (including a no-op install). */
+export function parseInstallSeconds(log: string): number | null {
+  const match = /(?:\d+ packages? installed|Checked \d+ installs across \d+ packages(?: \(no changes\))?)\s*\[(\d+(?:\.\d+)?)(ms|s)\]/.exec(log);
+  if (!match) return null;
+  const duration = Number(match[1]);
+  return match[2] === 'ms' ? duration / 1000 : duration;
+}

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

@@ -6,12 +6,15 @@
 // 명령 인자는 셸 문자열로 이어붙이지 않고 `"$@"` 로 따로 인용한다.
 
 import { spawnSync } from 'node:child_process';
+import { isAbsolute } from 'node:path';
+import { getUserConfig } from '../../user-config.js';
 import { debug } from '../../debug/log.js';
 import { effectiveInstanceRoot } from '../../instance/resolve.js';
 import { collectPodArtifacts } from './pod-artifact-return.js';
+import { podBunCacheVolume } from './pod-bun-cache.js';
 import { type PodPoolMember, PodPoolScheduler, resolvePodPoolSpec, parsePodPool, checkPodPool, syncPoolImages, type PoolKubectl } from './pod-pool.js';
 import { readSkillEnvFiles } from './pod-skills.js';
-import { podSourceScript } from './pod-source-receive.js';
+import { podSourceScript, type PodSource } from './pod-source-receive.js';
 import {
   POD_CHILD_REQUESTS,
   POD_JOB_DEADLINE_SECONDS,
@@ -73,6 +76,11 @@ export interface PodCommandJobInput {
   llm?: 'grok';
   /** 저장소를 clone 한다 — 비공개 저장소라 GitHub 토큰이 Secret 으로 간다(명시 opt-in). 기본은 clone 없이 `~/work` 에서 이미지의 `elanous` 로 돈다. */
   clone?: boolean;
+  hostMirror?: string;
+  bunCache?: string;
+  /** 컨테이너 메모리 한도(기본 16Gi) — 게이트가 파일 하나 격리 Job 에 올린다. */
+  memoryLimit?: string;
+  source?: PodSource;
   deadlineSeconds: number;
   runId?: string;
 }
@@ -88,6 +96,7 @@ export function podCommandJobManifest(o: PodCommandJobInput): Record<string, unk
     if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(name)) throw new Error(`pod command skill name rejected: ${name}`);
   }
   const grok = o.llm === 'grok';
+  const bunCache = o.bunCache ? podBunCacheVolume(o.bunCache) : undefined;
   const quotedArgs = o.command.map(bashSingleQuote).join(' ');
   const credLines = [
     ...(grok ? ['mkdir -p ~/.grok && install -m 600 /creds/grok-auth.json ~/.grok/auth.json'] : []),
@@ -100,8 +109,9 @@ export function podCommandJobManifest(o: PodCommandJobInput): Record<string, unk
     ...credLines,
     'curl -s -m 3 -o /dev/null http://host.orb.internal:31415/health && { echo "[pod] ISOLATION FAIL"; exit 3; }',
     ...(o.clone
-      ? ['export GH_TOKEN="$(cat /creds/gh-token)" && gh auth setup-git', podSourceScript({ kind: 'default' }, o.repoUrl)]
+      ? ['export GH_TOKEN="$(cat /creds/gh-token)" && gh auth setup-git', podSourceScript(o.source ?? { kind: 'default' }, o.repoUrl)]
       : ['mkdir -p ~/work && cd ~/work']),
+    ...(bunCache ? [bunCache.shellPrefix] : []),
     `set -- ${quotedArgs}`,
     '"$@"',
     'rc=$?',
@@ -125,16 +135,24 @@ 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: '16Gi', cpu: '4' } },
+            resources: { requests: { ...POD_CHILD_REQUESTS }, limits: { memory: o.memoryLimit ?? '16Gi', cpu: '4' } },
             command: ['bash', '-c'], args: [script],
             env: [
               ...(o.runId ? [{ name: 'ELANOUS_RUN_ID', value: o.runId }] : []),
               { name: 'ELANOUS_SUBSTRATE', value: 'pod' },
               { name: 'ELANOUS_POD_NAME', valueFrom: { fieldRef: { fieldPath: 'metadata.name' } } },
             ],
-            ...(secretKeys ? { volumeMounts: [{ name: 'creds', mountPath: '/creds', readOnly: true }] } : {}),
+            ...(secretKeys || o.hostMirror || bunCache ? { volumeMounts: [
+              ...(secretKeys ? [{ name: 'creds', mountPath: '/creds', readOnly: true }] : []),
+              ...(o.hostMirror ? [{ name: 'host-mirror', mountPath: '/host-mirror', readOnly: true }] : []),
+              ...(bunCache ? [bunCache.volumeMount] : []),
+            ] } : {}),
           }],
-          ...(secretKeys ? { volumes: [{ name: 'creds', secret: { secretName: `${o.name}-creds`, defaultMode: 0o400 } }] } : {}),
+          ...(secretKeys || o.hostMirror || bunCache ? { volumes: [
+            ...(secretKeys ? [{ name: 'creds', secret: { secretName: `${o.name}-creds`, defaultMode: 0o400 } }] : []),
+            ...(o.hostMirror ? [{ name: 'host-mirror', hostPath: { path: o.hostMirror, type: 'Directory' } }] : []),
+            ...(bunCache ? [bunCache.volume] : []),
+          ] } : {}),
         },
       },
     },
@@ -188,6 +206,11 @@ export interface RunPodCommandOptions {
   skills?: readonly string[];
   llm?: 'grok';
   clone?: boolean;
+  hostMirror?: string;
+  bunCache?: string;
+  /** 컨테이너 메모리 한도(기본 16Gi). */
+  memoryLimit?: string;
+  source?: PodSource;
   ghToken?: () => string;
   deadlineSeconds?: number;
   namespace?: string;
@@ -207,6 +230,7 @@ export interface RunPodCommandOptions {
   sleep?: (ms: number) => Promise<void>;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
   env?: NodeJS.ProcessEnv;
+  configHostMirror?: () => string | undefined;
 }
 
 function jobFinished(types: string): 'complete' | 'failed' | null {
@@ -243,6 +267,11 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
   const deadlineSeconds = options.deadlineSeconds ?? POD_COMMAND_DEADLINE_SECONDS;
   const name = options.name ?? podJobName(`cmd-${Date.now().toString(36)}`);
   const env = options.env ?? process.env;
+  const hostMirror = (options.hostMirror ?? env.ELANOUS_POD_HOST_MIRROR
+    ?? (options.configHostMirror ?? (() => getUserConfig().pod?.hostMirror))())?.trim() || undefined;
+  if (hostMirror && !isAbsolute(hostMirror)) throw new Error('pod.hostMirror must be an absolute directory path');
+  const bunCache = options.bunCache?.trim() || undefined;
+  if (bunCache && !isAbsolute(bunCache)) throw new Error('pod.bunCache must be an absolute directory path');
 
   let member: PodPoolMember | null = null;
   let pool = options.poolScheduler;
@@ -307,7 +336,8 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
     const manifest = podCommandJobManifest({
       name, namespace, image: member?.imageRef ?? image,
       ...(member?.imageRef ? { imagePullPolicy: 'IfNotPresent' as const } : {}),
-      repoUrl, command, skills, ...(llm ? { llm } : {}), ...(options.clone ? { clone: true } : {}), deadlineSeconds,
+      repoUrl, command, skills, ...(llm ? { llm } : {}), ...(options.clone ? { clone: true } : {}),
+      ...(options.source ? { source: options.source } : {}), ...(hostMirror ? { hostMirror } : {}), ...(bunCache ? { bunCache } : {}), ...(options.memoryLimit ? { memoryLimit: options.memoryLimit } : {}), deadlineSeconds,
       ...(options.runId ? { runId: options.runId } : {}),
     });
     kubectl(['-n', namespace, 'delete', 'job', name, '--ignore-not-found']);