elanous 0.2.24 → 0.2.27

package/src/self-implement/regate-detail.ts

@@ -0,0 +1,79 @@
+/**
+ * HOST-REGATE-REASON-LOST (2nd · 2026-10-12): a host-regate failure must say «why» on the ledger.
+ *
+ * The first repair (#26215) put `hostRegateFailure` on the pr-terminal row but kept only the first 300 characters,
+ * and the gate's own `run()` cut every git/gh error to its first 300 characters as well. A git merge lists one
+ * `CONFLICT` line per file and gh puts the GraphQL reason at the end, so a head cut loses exactly the cause
+ * (run-caaf045f · PR #26472: the autopsy could not tell a conflict from a gate failure).
+ *
+ * The detail is bounded (ledger rows are append-only and replayed) but keeps both ends.
+ */
+export const HOST_REGATE_DETAIL_MAX = 4096;
+
+/** Keep `text` within `max` characters, preserving its head (an eighth) and its tail (the rest). */
+export function clipRegateDetail(text: string, max = HOST_REGATE_DETAIL_MAX): string {
+  if (text.length <= max) return text;
+  const marker = ` …[${text.length - max} chars elided]… `;
+  const head = Math.floor(max / 8);
+  const tail = Math.max(0, max - head - marker.length);
+  return text.slice(0, head) + marker + text.slice(text.length - tail);
+}
+
+/** Files named by `git merge` CONFLICT lines (`CONFLICT (content): Merge conflict in <path>` and the rename/delete forms). */
+export function parseConflictFiles(text: string): string[] {
+  const files = new Set<string>();
+  for (const raw of text.split('\n')) {
+    const line = /^CONFLICT \(([^)]*)\): (.*)$/.exec(raw);
+    if (!line) continue;
+    const rest = line[2]!;
+    const inPath = /Merge conflict in (.+)$/.exec(rest);
+    // modify/delete · rename/delete · file/directory name the path first; other free text is not a path.
+    const path = inPath ? inPath[1] : /^(?:modify\/delete|rename\/delete)$/.test(line[1]!)
+      ? /^(.+?) (?:deleted|renamed) in /.exec(rest)?.[1]
+      : undefined;
+    if (path) files.add(path);
+  }
+  return [...files].sort();
+}
+
+export type MergeFailureKind = 'base-modified' | 'head-moved' | 'conflict' | 'branch-policy' | 'other';
+
+/** Classify a `gh pr merge` failure so a reader can tell a race from a conflict from a policy block without the raw text. */
+export function classifyMergeFailure(detail: string, expectedHead?: string, actualHead?: string | null): MergeFailureKind {
+  if (/base branch was modified/i.test(detail)) return 'base-modified';
+  if (/head branch was modified/i.test(detail)) return 'head-moved';
+  if (expectedHead && actualHead && expectedHead !== actualHead) return 'head-moved';
+  if (/required status|review is required|protected branch|branch policy|not authorized|merge queue/i.test(detail)) return 'branch-policy';
+  if (/\bconflicts?\b/i.test(detail) && !/\bno conflicts?\b/i.test(detail)) return 'conflict';
+  return 'other';
+}
+
+/** One host-regate failure. The optional facts are filled for the pr-head, merge-conflict and merge steps. */
+export interface HostRegateFailure {
+  step: string;
+  detail: string;
+  expectedHead?: string;
+  actualHead?: string | null;
+  conflictFiles?: string[];
+  /** Number omitted from conflictFiles when the ledger's 200-path bound is reached. */
+  conflictFilesOmitted?: number;
+  mergeFailureKind?: MergeFailureKind;
+}
+
+/** The optional facts of a failure, copied only when well-formed (ledger rows come back from disk). */
+export function regateFailureFacts(failure: unknown): Omit<HostRegateFailure, 'step' | 'detail'> {
+  if (!failure || typeof failure !== 'object') return {};
+  const f = failure as Record<string, unknown>;
+  const sha = (value: unknown): value is string => typeof value === 'string' && /^[0-9a-f]{40}$/i.test(value);
+  const kinds: readonly MergeFailureKind[] = ['base-modified', 'head-moved', 'conflict', 'branch-policy', 'other'];
+  const conflictFiles = Array.isArray(f.conflictFiles) ? f.conflictFiles.filter((p): p is string => typeof p === 'string') : undefined;
+  const priorOmitted = Number.isSafeInteger(f.conflictFilesOmitted) && (f.conflictFilesOmitted as number) > 0 ? f.conflictFilesOmitted as number : 0;
+  const conflictFilesOmitted = Math.max(0, (conflictFiles?.length ?? 0) - 200) + priorOmitted;
+  return {
+    ...(sha(f.expectedHead) ? { expectedHead: f.expectedHead } : {}),
+    ...(sha(f.actualHead) || f.actualHead === null ? { actualHead: f.actualHead as string | null } : {}),
+    ...(conflictFiles ? { conflictFiles: conflictFiles.slice(0, 200) } : {}),
+    ...(conflictFilesOmitted > 0 ? { conflictFilesOmitted } : {}),
+    ...(typeof f.mergeFailureKind === 'string' && kinds.includes(f.mergeFailureKind as MergeFailureKind) ? { mergeFailureKind: f.mergeFailureKind as MergeFailureKind } : {}),
+  };
+}

package/src/self-implement/review-deferred-to-host.ts

@@ -0,0 +1,21 @@
+// REVIEW-ACP-POD ②-b — Pod 안 리뷰를 «호스트 리뷰로 미룸».
+//
+// S  ②-a(#26457)로 호스트가 Pod merge-ready PR 을 Claude ACP 로 리뷰한다. 그런데 Pod 안 하니스 리뷰는 그대로 api 로 돌아
+//    켜면 리뷰가 «둘»(돈 두 번)이다.
+// C  오케스트레이터는 «실제 리뷰»(`reviewed=true`)가 있어야 merge-ready 를 낸다 — 그냥 끄면 `no-real-review` 로 멎는다.
+// Q  Pod 안 리뷰를 어떻게 «정직하게» 비우나?
+// A  발사 호스트가 ACP 리뷰를 맡을 때만 자식 env 에 표지를 싣는다. 자식은 api 리뷰를 부르지 않고
+//    `reviewed=false` ⊕ `failureReason=deferred-to-host` 를 낸다(⛔ verdict 를 clean 으로 꾸미지 않는다).
+//    오케스트레이터는 «호스트 병합(mergeByHost)» 런에서만 그 상태를 merge-ready 로 받고 `mergeReason` 에 적어 호스트로 돌려보낸다.
+//    호스트는 그 표지를 보면 ACP 리뷰를 «반드시» 하고, 못 하면(refused) 병합하지 않는다(fail-closed).
+
+/** 발사 호스트 → Pod 자식: 「리뷰는 호스트가 Claude ACP 로 한다 — Pod 안 api 리뷰를 부르지 마라」. 값 `1` 만 켠다. */
+export const REVIEW_DEFERRED_TO_HOST_ENV = 'ELANOUS_REVIEW_DEFERRED_TO_HOST';
+/** 미룬 리뷰의 `failureReason`(`reviewed=false` 의 «왜»). */
+export const REVIEW_DEFERRED_TO_HOST_FAILURE = 'deferred-to-host';
+/** 자식 merge-ready 결과의 `mergeReason` — 호스트가 이 값으로 «Pod 리뷰 없음»을 안다. */
+export const REVIEW_DEFERRED_TO_HOST_MERGE_REASON = 'review-deferred-to-host';
+
+export function reviewDeferredToHostFromEnv(env: Readonly<Record<string, string | undefined>>): boolean {
+  return env[REVIEW_DEFERRED_TO_HOST_ENV]?.trim() === '1';
+}

package/src/self-implement/rework-budget-judgment.ts

@@ -1,4 +1,5 @@
 import { executeClassifyNode } from '../workflow-runtime/nodes/classify.js';
+import { buildPremiseCard, type PremiseReviewCard, type PremiseReviewInput } from './premise-review.js';
 import { SUPERVISION_REWORK_SOURCES, type SupervisionReworkSource } from './supervision-vocabulary.js';
 import type { ClassifyNode, JudgmentContext, JudgmentResult, NodeExecContext, WorkflowDefinition, WorkflowDeps } from '../workflow-runtime/types.js';
 
@@ -22,6 +23,8 @@ interface ObservedValue {
 interface ReworkBudgetEvidence {
   observations: Record<'goal' | 'outcome' | 'history' | 'kind', ObservedValue>;
   modelReasoning: string;
+  /** UNCONVERGEABLE 직전에 세운 premise-review 카드(FLEX-RFC §A-③). 카드를 안 만든 판정에는 키가 없다. */
+  premiseReview?: PremiseReviewCard | undefined;
 }
 
 type EvidencedJudgmentResult = JudgmentResult & { evidence: ReworkBudgetEvidence };
@@ -108,7 +111,13 @@ export function reworkBudgetEvidenceForObservation(readEvidence: () => unknown):
   }
 }
 
-export function createReworkBudgetJudgment(callLLM: WorkflowDeps['callLLM']) {
+/** `createReworkBudgetJudgment` 의 선택 인자 — 주지 않으면 카드 없이 지금 동작 그대로. */
+export interface ReworkBudgetJudgmentOpts {
+  /** UNCONVERGEABLE 판정 직전에 세울 premise-review 카드의 입력(값 객체). */
+  premiseInput?: PremiseReviewInput | undefined;
+}
+
+export function createReworkBudgetJudgment(callLLM: WorkflowDeps['callLLM'], opts: ReworkBudgetJudgmentOpts = {}) {
   let latestEvidence: ReworkBudgetEvidence | undefined;
   const provider = async (contractId: string, ctx: JudgmentContext): Promise<JudgmentResult> => {
     if (contractId !== REWORK_BUDGET_JUDGMENT) {
@@ -145,6 +154,7 @@ export function createReworkBudgetJudgment(callLLM: WorkflowDeps['callLLM']) {
       toolPolicy: {},
     };
     let modelReasoning = '';
+    let premiseReview: PremiseReviewCard | undefined;
     const result = await executeClassifyNode(node, execContext, {
       callLLM: async (args) => {
         modelReasoning = await callLLM(args);
@@ -152,7 +162,11 @@ export function createReworkBudgetJudgment(callLLM: WorkflowDeps['callLLM']) {
       },
       runBash: async () => ({ stdout: '', stderr: '', exitCode: 0 }),
     });
-    const evidence = (): ReworkBudgetEvidence => ({ observations, modelReasoning });
+    const evidence = (): ReworkBudgetEvidence => ({
+      observations,
+      modelReasoning,
+      ...(premiseReview === undefined ? {} : { premiseReview }),
+    });
     const evidenced = (judgment: JudgmentResult): EvidencedJudgmentResult => {
       const resultWithEvidence = withEvidence(judgment, evidence());
       latestEvidence = resultWithEvidence.evidence;
@@ -172,7 +186,13 @@ export function createReworkBudgetJudgment(callLLM: WorkflowDeps['callLLM']) {
           + ` expected one of EXTEND|SUFFICIENT|UNCONVERGEABLE`,
       });
     }
-    return evidenced({ ok: true, output: picked, verdict: mapReworkBudgetVerdict(picked, kind) });
+    const verdict = mapReworkBudgetVerdict(picked, kind);
+    // FLEX-RFC §A-③ — UNCONVERGEABLE 을 «내기 전에» 전제를 되짚는다. 카드는 기존 증거 관측에 실려
+    // 원장('rework-budget' 사건)으로 나간다 — 사건 형식은 그대로, 카드는 증거 안의 추가 칸이다.
+    if (picked === 'UNCONVERGEABLE' && opts.premiseInput !== undefined) {
+      premiseReview = buildPremiseCard(opts.premiseInput);
+    }
+    return evidenced({ ok: true, output: picked, verdict });
   };
   return Object.assign(provider, { evidenceForObservation: () => latestEvidence });
 }

package/src/self-implement/running-runs.ts

@@ -566,7 +566,7 @@ export function queryRunningRuns(options: { includeTest?: boolean; runIds?: read
   }
 }
 
-function isPartialRunningRuns(result: RunningRunsResult): boolean {
+export function isPartialRunningRuns(result: RunningRunsResult): boolean {
   return (result.count !== undefined && typeof result.count !== 'number' && result.count.count === null)
     || result.completeness === 'partial' || hasUnreadableLedgerObservation(result.ledger) || (result.unreadable?.length ?? 0) > 0;
 }
@@ -624,7 +624,7 @@ function formatElapsed(ms: number): string {
 export function renderRunProgressTable(result: RunningRunsResult, nowMs: number = Date.now()): string {
   const partial = isPartialRunningRuns(result);
   const header = partial
-    ? `부분 관측 — 최소 ${runningRunsLowerBound(result)} (읽지 못한 원장: ${runningRunsUnreadable(result).map((item) => `${item.dir}:${item.reason}`).join(',') || '없음'})`
+    ? `부분 관측 — 최소 ${runningRunsLowerBound(result)} (읽지 못한 원장: ${runningRunsUnreadable(result).map((item) => `${item.dir}:${item.reason}`).join(',') || '목록 미관측'})`
     : `도는 런 ${result.counts.running + result.counts['probable-running']} (확인 ${result.counts.running} · 추정 ${result.counts['probable-running']})`;
   const rows = buildRunProgressRows(result, nowMs).map((row) => {
     const phaseUnreadable = row.phaseObservation === 'unreadable' || row.phaseObservation === 'partially-unreadable';

package/src/self-implement/scope-adjacency.ts

@@ -0,0 +1,23 @@
+// SCOPE-HELD-DELIVER (0.2.25) — which out-of-scope edits sit right next to a declared target.
+// 10-11~12: 34 scope-held runs auto-answered «Stay in scope» after 30 unanswered minutes and threw away finished work;
+// the outside files were a declared file's same-folder neighbours (its other tests, a sibling helper, the folder's
+// plugin.json). Those are adjacent: the run goes on to its gate instead of parking on a question nobody answers.
+
+const normalize = (path: string): string => path.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');
+const dirOf = (path: string): string => { const at = path.lastIndexOf('/'); return at < 0 ? '' : path.slice(0, at); };
+
+/** Split out-of-scope files into those adjacent to a declared target and the rest. A file is adjacent when it sits in
+ *  the same folder as a declared file. A declared folder adds nothing (its contents are already in scope), and a
+ *  declared repo-root file adds nothing (the root holds the whole repo's config). */
+export function classifyOutOfScope(outsideFiles: readonly string[], declaredPaths: readonly string[]): { adjacent: string[]; other: string[] } {
+  const folders = new Set<string>();
+  for (const declared of declaredPaths.map(normalize)) {
+    const dir = dirOf(declared);
+    // A path with an extension names a file; without one it names a folder.
+    if (dir && /\.[A-Za-z0-9]+$/.test(declared.slice(dir.length + 1))) folders.add(dir);
+  }
+  const adjacent: string[] = [];
+  const other: string[] = [];
+  for (const file of outsideFiles) (folders.has(dirOf(normalize(file))) ? adjacent : other).push(file);
+  return { adjacent, other };
+}

package/src/self-implement/seams.ts

@@ -15,6 +15,7 @@
 import { fileURLToPath } from 'node:url';
 import { judgePredictionAccuracy, mustFixTrendFromHistory, renderJudgeOwnSignals, renderJudgePredictionAccuracy } from './judge-prediction-accuracy.js';
 import { isElanousRuntimeArtifactPath } from './gate-scope.js';
+import { buildPrConclusionCard, firstParagraphOf, prConclusionCardHeader } from '../context-card/index.js';
 import { spawn, spawnSync, execFile } from 'node:child_process';
 import { randomUUID, timingSafeEqual } from 'node:crypto';
 import { existsSync, lstatSync, mkdtempSync, readFileSync, realpathSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
@@ -71,6 +72,7 @@ import { ghAutomationEnv, makePrManager, type PrManager } from '../autopilot/pr-
 import { defaultSpawnGh, lookupOpenDraftPrs } from '../cli/logs-abandoned-draft-prs.js';
 import { loadRunLedger, runLedgerDir } from './run-ledger.js';
 import { readdirSync } from 'node:fs';
+import { REVIEW_DEFERRED_TO_HOST_FAILURE } from './review-deferred-to-host.js';
 import { budgetReviewerContext, reviewDiffBudgetObservation, reviewPullRequest, renderReview, type ReviewerContextItem } from '../agent-substrate/pr-reviewer.js';
 import { buildReviewIntent, type ReviewIntentInput } from '../agent-substrate/review-intent.js';
 import { OFF_DIFF_EVIDENCE_PROMPT, requiredEvidenceFromGoal, renderRequiredEvidencePrompt, tailWithOmissionMarker } from './off-diff-evidence.js';
@@ -849,16 +851,34 @@ export function changedFileTypecheck(
   }
 }
 
-/** 헤드리스 elanous 가 이 feature 를 구현하도록 주입하는 프롬프트. goal-loop 계약 + 검증된 클린-빌드
- *  앵커(측정→운영·[[REPORT-gemma-goalloop-lever-2026-07-20]])를 명시. 앵커가 gemma 를 99 로 끌어올렸고
- *  강한 모델엔 무해 — self-run 어느 provider 든 동일 규율. */
-export function buildPrBody(cwd: string, body: string): string {
+export interface PrBodyConclusionInput {
+  /** 결론줄 «포인터:» 에 붙일 원본 위치(원문 전문을 가리키는 참조). */
+  readonly pointers?: readonly string[];
+  /** 원문 본문을 읽지 못한 경우 — «결론: 확인 불가» 로 떨어진다. */
+  readonly unreadable?: boolean;
+}
+
+/** RFC context-diet §3a — PR 본문 첫 단락을 «결론: <한 줄> · 포인터: <원본>» 결론줄로 앞세우고
+ *  원문 본문은 결론줄 아래 그대로 둔다(지우지 않는다). 결론이 없으면 «결론: 없음(원문에 결론 없음)». */
+export function buildPrBody(cwd: string, body: string, conclusion?: PrBodyConclusionInput): string {
+  const card = buildPrConclusionCard({
+    id: 'pr-body-conclusion',
+    firstParagraph: firstParagraphOf(body),
+    ...(conclusion?.unreadable ? { unreadable: true } : {}),
+    pointers: [...(conclusion?.pointers ?? [])],
+    source: 'pr-body',
+    updatedAt: new Date().toISOString(),
+  });
+  const header = prConclusionCardHeader(card);
   const templatePath = join(cwd, '.github', 'pull_request_template.md');
-  if (!existsSync(templatePath)) return body;
-  const template = readFileSync(templatePath, 'utf8').trim();
-  return template ? `${template}\n\n${body}` : body;
+  const template = existsSync(templatePath) ? readFileSync(templatePath, 'utf8').trim() : '';
+  const withConclusion = `${header}\n\n${body}`;
+  return template ? `${template}\n\n${withConclusion}` : withConclusion;
 }
 
+/** 헤드리스 elanous 가 이 feature 를 구현하도록 주입하는 프롬프트. goal-loop 계약 + 검증된 클린-빌드
+ * 앵커(측정→운영·[[REPORT-gemma-goalloop-lever-2026-07-20]])를 명시. 앵커가 gemma 를 99 로 끌어올렸고
+ * 강한 모델엔 무해 — self-run 어느 provider 든 동일 규율. */
 export function featurePrompt(feature: string, cwd?: string, reviewerContext?: readonly ReviewerContextItem[]): string {
   const worktreeNotice = cwd?.trim()
     ? `작업 디렉토리는 \`${cwd}\`다. 이 트리 안에서만 편집하고, 경로가 필요하면 추측하지 말고 이 경로를 기준으로 삼아라.`
@@ -1063,6 +1083,9 @@ export interface DefaultSeamsOptions {
    * ⛔ llmReview 시그니처는 그대로(prompt-in/text-out · 도구 채널 없음).
    */
   reviewerCanSelfRead?: boolean;
+  /** REVIEW-ACP-POD ②-b — 참이면 reviewDiff 가 리뷰어를 부르지 않고 `reviewed=false` ⊕ `failureReason=deferred-to-host` 를 낸다
+   *  (발사 호스트가 Claude ACP 로 리뷰한다). 기본 거짓 = 종전. */
+  reviewDeferredToHost?: boolean;
   /** CLI가 적재한 리뷰어 컨텍스트. 비어 있으면 기존 ReviewInput 형태를 유지한다. */
   reviewerContext?: ReviewerContextItem[];
   /** 기존 LLM HITL relay builder의 테스트 seam. 생성 실패 시 기본 dispatch를 그대로 유지한다. */
@@ -2587,6 +2610,18 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
             ...(o.reviewerCanSelfRead !== undefined ? { canSelfRead: o.reviewerCanSelfRead } : {}),
           };
         }
+        if (o.reviewDeferredToHost) {
+          // REVIEW-ACP-POD ②-b — 리뷰어 호출 0. ⛔ 통과로 꾸미지 않는다(reviewed=false) — 판정은 호스트 ACP 리뷰가 맡는다.
+          debug.log('self-implement', 'review.done', {
+            verdict: 'warn', reviewed: false, reason: REVIEW_DEFERRED_TO_HOST_FAILURE,
+            ...(ctx?.round !== undefined ? { round: ctx.round } : {}),
+          });
+          try { emitDecision(reviewDecision({ runId: ctx?.runId, verdict: 'warn', reviewed: false, reason: REVIEW_DEFERRED_TO_HOST_FAILURE })); } catch { /* observation must not change the review result */ }
+          return {
+            verdict: 'warn' as const, mustFix: [], shouldFix: [], summary: '(리뷰를 호스트 Claude ACP 리뷰로 미뤘다)', reviewed: false,
+            failureReason: REVIEW_DEFERRED_TO_HOST_FAILURE, deferredToHost: true as const,
+          };
+        }
         const intentInput = toReviewIntentInput(ctx);
         const phaseIntent = intentInput ? buildReviewIntent(intentInput) : 'self-implement 변경 리뷰';
         const evidenceNote = [

package/src/self-implement/self-implement-runtime.ts

@@ -456,11 +456,36 @@ function parseGoals(req: SelfImplementRuntimeRequest): string[] | undefined {
   return goals;
 }
 
-function formatOrchestrationResults(results: readonly SelfDevJobResult[]): string {
+interface SelfImplementGoalResult {
+  goal: string;
+  status: SelfDevJobResult['status'];
+  runId?: string;
+  stage?: string;
+  reason?: string;
+  parentPrNumber?: number;
+}
+
+function observedGoalResults(results: readonly SelfDevJobResult[]): SelfImplementGoalResult[] {
+  return results.map((result, index) => ({
+    goal: result.feature || `골 ${index + 1}`,
+    status: result.status,
+    ...(result.runId ? { runId: result.runId } : {}),
+    ...(result.stage ? { stage: result.stage } : {}),
+    ...(result.error?.message || result.stopReason || result.blockReason
+      ? { reason: result.error?.message || result.stopReason || (result.blockReason === 'parent-unlanded'
+        ? result.parentPrNumber ? `선행 PR #${result.parentPrNumber} 미착지` : '선행 골 미착지'
+        : result.blockReason) }
+      : {}),
+    ...(result.parentPrNumber ? { parentPrNumber: result.parentPrNumber } : {}),
+  }));
+}
+
+function formatOrchestrationResults(results: readonly SelfDevJobResult[], goals: readonly SelfImplementGoalResult[]): string {
   const done = results.filter(result => result.status === 'done').length;
   const merged = results.filter(result => result.merged).length;
   const failed = results.filter(result => result.status === 'failed').length;
-  return `[self-implement] parallel ${results.length} goal · done ${done}${merged ? ` (병합 ${merged})` : ''}${failed ? ` · 실패 ${failed}` : ''}`;
+  const summary = `[self-implement] parallel ${results.length} goal · done ${done}${merged ? ` (병합 ${merged})` : ''}${failed ? ` · 실패 ${failed}` : ''}`;
+  return [summary, ...goals.map(goal => `- ${goal.goal}: ${goal.status} · 런 ${goal.runId ?? '미관측'}${goal.stage ? ` · 단계 ${goal.stage}` : ''}${goal.reason ? ` · 이유 ${goal.reason}` : ''}`)].join('\n');
 }
 
 export function resolveDocumentReferences(paths: readonly string[], repositoryRoot = process.cwd()): DocumentReferenceStatus[] {
@@ -476,7 +501,15 @@ function documentReferenceStatusLines(references: readonly DocumentReferenceStat
 
 function formatResult(feature: string, r: SelfImplementResult, references: readonly DocumentReferenceStatus[] = []): string {
   const head = `[self-implement] ${r.stage}`;
-  const lines: string[] = [head, ...documentReferenceStatusLines(references)];
+  const next = r.runId ? `eln self run ${r.runId}` : r.ok ? 'eln self running-runs' : '실패 이유를 확인한 뒤 다시 요청';
+  const lines: string[] = [
+    r.ok
+      ? r.runId
+        ? `하니스가 맡았습니다 · 런 ${r.runId} · 노드 ${r.node || '미관측'} · 다음 조회: ${next} · 이 턴에서 파일을 직접 편집하지 마세요`
+        : `하니스 응답을 받았지만 런 식별자는 아직 미관측입니다 · 진행 중 런 조회: ${next} · 일치하는 런이 없으면 요청을 다시 보내세요 · 이 턴에서 파일을 직접 편집하지 마세요`
+      : `하니스가 발사되지 않았거나 실패했습니다: ${r.detail ?? r.stage} · 다음: ${next} · 이 턴에서 파일을 직접 편집하지 마세요`,
+    head, ...documentReferenceStatusLines(references),
+  ];
   if (r.branch) lines.push(`branch: ${r.branch}`);
   if (r.worktreePath) lines.push(`worktree: ${r.worktreePath}`);
   if (r.stage === 'pr-opened' && r.prUrl) {
@@ -494,6 +527,12 @@ function formatResult(feature: string, r: SelfImplementResult, references: reado
 export interface SelfImplementRunResult {
   output: string;
   ok: boolean;
+  kind: 'launched' | 'observed-only' | 'failed' | 'pending';
+  next?: string;
+  reason?: string;
+  missing?: string[];
+  /** 병렬 골마다 실제로 관측된 종료 상태·식별자·이유. */
+  goalResults?: SelfImplementGoalResult[];
   // ⛔ 관측 전용 반환에는 **단계가 없다** — 아무 노드도 돌지 않았다. 없는 것을 있는 값으로 적으면
   //   «안 돌았다» 와 «어느 단계에서 끝났다» 가 같은 값이 된다(부재와 미지를 같은 값으로 적지 않는다).
   stage?: SelfImplementResult['stage'];
@@ -506,8 +545,10 @@ export interface SelfImplementRunResult {
   observed?: true;
   /** 명시적 Fabric 분해의 상태·기존 3결말·미산출 사유. */
   fabricDecomposition?: FabricDecompositionOutcome;
-  /** 즉시 반환 모드에서 할당한 런 식별자. 블로킹 기본 경로에는 없어 기존 반환 모양을 보존한다. */
+  /** 실제 런 결과에서 확인한 식별자. 선할당된 비동기 ID는 반환하지 않는다. */
   runId?: string;
+  /** 비동기 요청 조회용 상관 ID. 발사된 런의 증거가 아니다. */
+  requestId?: string;
   /** 호출이 블로킹인지 비블로킹인지. 기본 경로에는 없어 기존 반환 모양을 보존한다. */
   invocationMode?: 'blocking' | 'non-blocking';
 }
@@ -516,6 +557,7 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
   id: 'self_implement',
   spec: buildSelfImplementSpec(),
   async run(req, ctx: ToolRuntimeContext): Promise<SelfImplementRunResult> {
+    try {
     const hasFeature = req.feature !== undefined;
     const hasGoals = req.goals !== undefined;
     if (hasFeature === hasGoals) {
@@ -604,7 +646,7 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
     if (observeOnly.enabled) {
       const requestSummary = feature ?? goals!.join(' · ');
       debug.log('self-implement', 'runtime.observed', { surface: ctx.surface, ...(feature ? { feature: feature.slice(0, 120) } : { goals: goals!.length }), observeOnly: observeOnly.enabled, observeOnlySource: observeOnly.source });
-      return { output: `SelfImplement 관측 전용 측정 모드 — 호출이 접수되어 기록되었습니다. 이 세션에서는 구현을 진행하지 않습니다. 같은 요청을 이 턴에서 직접 구현하지 말고 응답을 마무리하세요: ${requestSummary.slice(0, 120)}${documentReferenceStatusLines(documentReferences).length ? `\n${documentReferenceStatusLines(documentReferences).join('\n')}` : ''}`, ok: true, observed: true };
+      return { output: `관측 전용이라 런을 발사하지 않았습니다 · 코드도 안 바꿨습니다 · 이 결과를 구현 실패로 읽고 직접 Write/Edit 하지 마세요. 실제 발사를 원하면 관측 전용 모드를 끈 뒤 다시 요청하세요: ${requestSummary.slice(0, 120)}${documentReferenceStatusLines(documentReferences).length ? `\n${documentReferenceStatusLines(documentReferences).join('\n')}` : ''}`, ok: true, kind: 'observed-only', observed: true, missing: ['runId', 'node'], next: '관측 전용 모드를 끈 뒤 다시 요청' };
     }
 
     const allocatedRunId = nonBlocking ? mintRunId() : undefined;
@@ -637,9 +679,14 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
           fabricDecomposition = fabricDecompositionOutcome(fabricResult);
           observeFabricDecomposition(fabricDecomposition, ctx.surface, fabricResult.status === 'decomposed' ? fabricResult.goals.length : undefined);
           if (fabricResult.status !== 'decomposed') {
+            const observedOnly = fabricDecomposition.outcome !== 'llm-failed';
             return {
-              output: formatFabricDecompositionOutcome(fabricDecomposition),
-              ok: fabricDecomposition.outcome !== 'llm-failed',
+              output: `${formatFabricDecompositionOutcome(fabricDecomposition)}${observedOnly ? '\n관측 전용이라 런을 발사하지 않았습니다 · 코드도 안 바꿨습니다 · 이 결과를 구현 실패로 읽고 직접 Write/Edit 하지 마세요.' : '\n이 턴에서 파일을 직접 편집하지 마세요.'}`,
+              ok: observedOnly,
+              kind: observedOnly ? 'observed-only' : 'failed',
+              next: observedOnly ? '분해 결과를 확인하고 구현 골을 다시 요청' : '분해 실패 이유를 확인한 뒤 다시 요청',
+              missing: ['runId', 'node'],
+              ...(observedOnly ? { observed: true as const } : { reason: formatFabricDecompositionOutcome(fabricDecomposition) }),
               fabricDecomposition,
             };
           }
@@ -674,10 +721,40 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
         ...(forwardedSupervise === undefined ? {} : { supervise: forwardedSupervise }),
         ...(deliverable === undefined ? {} : { deliverable }),
       });
-      const failed = results.filter(result => result.status === 'failed').length;
+      const goalResults = observedGoalResults(results);
+      const failedGoals = goalResults.filter(result => result.status === 'failed' || result.status === 'cancelled');
+      const blockedGoals = goalResults.filter(result => result.status === 'blocked');
+      const allRunsIdentified = goalResults.length > 0 && goalResults.every(result => result.runId);
+      const kind = goalResults.length === 0 || failedGoals.length > 0 || blockedGoals.length > 0 ? 'failed' : allRunsIdentified ? 'launched' : 'pending';
+      const parentBlockedPrNumbers = [...new Set(results.flatMap(result => result.status === 'blocked' && result.blockReason === 'parent-unlanded' && result.parentPrNumber ? [result.parentPrNumber] : []))];
+      const parentBlockedWithoutPr = results.some(result => result.status === 'blocked' && result.blockReason === 'parent-unlanded' && !result.parentPrNumber && !result.runId);
+      const otherFailureWithoutId = results.some(result => !result.runId && ['failed', 'cancelled', 'blocked'].includes(result.status) && result.blockReason !== 'parent-unlanded');
+      const runQueries = [...new Set(goalResults.flatMap(result => result.runId ? [`eln self run ${result.runId}`] : []))];
+      const availableQueries = [
+        ...parentBlockedPrNumbers.map(pr => `eln gh pr view ${pr}`),
+        ...runQueries,
+      ];
+      const pendingWithoutId = goalResults.some(result => !result.runId && !['failed', 'cancelled', 'blocked'].includes(result.status));
+      const next = [
+        ...availableQueries,
+        ...(pendingWithoutId ? ['eln self running-runs', '일치하는 런이 없으면 ID 미확정 골을 다시 요청'] : []),
+        ...(parentBlockedPrNumbers.length ? ['선행 PR 착지 뒤 차단된 골을 재실행하세요'] : []),
+        ...(parentBlockedWithoutPr ? ['선행 골 상태를 확인한 뒤 해당 골을 재실행하세요'] : []),
+        ...(otherFailureWithoutId ? ['실패·차단 이유를 확인한 뒤 해당 골을 다시 요청'] : []),
+      ].join('\n') || '골 결과가 0건이라 상태를 확인한 뒤 다시 요청';
+      const reason = goalResults.length === 0
+        ? '골 결과가 0건이라 상태 미관측'
+        : [...failedGoals, ...blockedGoals].map(result => `${result.goal}: ${result.reason ?? '이유 미관측'}`).join('; ');
       return {
-        output: formatOrchestrationResults(results),
-        ok: failed === 0,
+        output: formatOrchestrationResults(results, goalResults)
+          + (kind === 'failed' ? `\n실패/차단: ${reason} · 다음: ${next}` : `\n다음 조회: ${next}`)
+          + '\n이 턴에서 파일을 직접 편집하지 마세요',
+        ok: kind !== 'failed',
+        kind,
+        next,
+        missing: [ ...(goalResults.length === 0 || goalResults.some(result => !result.runId) ? ['runId'] : []), 'node' ],
+        goalResults,
+        ...(kind === 'failed' ? { reason } : {}),
         ...(fabricDecomposition ? { fabricDecomposition } : {}),
       };
     }
@@ -751,12 +828,12 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
       ...(runId ? { runId } : {}),
     }, { pipelineDeps });
     if (!outcome.ok) {
-      return { output: withGoalAuthorFailure(`[self-implement] failed: ${outcome.message}`), ok: false };
+      return { output: withGoalAuthorFailure(`하니스가 발사되지 않았거나 실패했습니다: ${outcome.message} · 다음: 실패 이유를 확인한 뒤 다시 요청하세요 · 이 턴에서 파일을 직접 편집하지 마세요`), ok: false, kind: 'failed', reason: outcome.message, next: '실패 이유를 확인한 뒤 다시 요청', missing: ['runId', 'node'] };
     }
     if (outcome.kind !== 'self') {
       return {
-        output: withGoalAuthorFailure('[self-implement] observed by central CLI'),
-        ok: true,
+        output: withGoalAuthorFailure('관측 전용이라 런을 발사하지 않았습니다 · 코드도 안 바꿨습니다 · 이 결과를 구현 실패로 읽고 직접 Write/Edit 하지 마세요'),
+        ok: true, kind: 'observed-only', observed: true, missing: ['runId', 'node'], next: '관측 전용 모드를 끈 뒤 다시 요청',
       };
     }
 
@@ -764,6 +841,11 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
     return {
       output: withGoalAuthorFailure(formatResult(feature, result, documentReferences)),
       ok: result.ok,
+      kind: result.ok ? (result.runId ? 'launched' : 'pending') : 'failed',
+      next: result.runId ? `eln self run ${result.runId}` : result.ok ? 'eln self running-runs' : '실패 이유를 확인한 뒤 다시 요청',
+      missing: [...(result.runId ? [] : ['runId']), ...(result.node ? [] : ['node'])],
+      ...(!result.ok ? { reason: result.detail ?? result.stage } : {}),
+      runId: result.runId,
       stage: result.stage,
       node: result.node,
       ...(result.prUrl ? { prUrl: result.prUrl } : {}),
@@ -775,28 +857,51 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
 
     if (nonBlocking) {
       const runId = allocatedRunId ?? mintRunId();
+      const requestId = runId;
+      const lookup = `eln logs --category self-implement --event runtime.non-blocking-completed,runtime.non-blocking-failed --grep ${requestId} --since 3h --all --include-test`;
       void drive(runId).then(
         (result) => {
-          debug.log('self-implement', 'runtime.non-blocking-completed', {
-            runId,
+          debug.log('self-implement', result.kind === 'failed' ? 'runtime.non-blocking-failed' : 'runtime.non-blocking-completed', {
+            requestId,
+            kind: result.kind,
+            ...(result.runId ? { runId: result.runId } : {}),
+            ...(result.reason ? { reason: result.reason } : {}),
+            next: result.next ?? '요청 결과를 확인한 뒤 다시 요청',
             ok: result.ok,
             ...(result.stage === undefined ? {} : { stage: result.stage }),
-          });
+          }, result.kind === 'failed' ? { level: 'warn' } : undefined);
         },
         (error) => {
+          const reason = error instanceof Error ? error.message : String(error);
           debug.log('self-implement', 'runtime.non-blocking-failed', {
-            runId,
-            error: error instanceof Error ? error.message : String(error),
+            requestId,
+            kind: 'failed',
+            reason,
+            next: '요청과 실패 이유를 확인한 뒤 다시 요청',
           }, { level: 'warn' });
         },
       );
       return {
         ok: true,
-        runId,
+        kind: 'pending',
         invocationMode: 'non-blocking',
-        output: `[self-implement] non-blocking accepted\nrunId: ${runId}`,
+        requestId,
+        next: lookup,
+        missing: ['runId', 'node'],
+        output: `하니스 요청을 접수했습니다 · 런과 노드는 아직 미관측 · 요청 ID ${requestId}(발사 증거 아님) · 다음 조회: ${lookup} · 이 턴에서 파일을 직접 편집하지 마세요\n[self-implement] non-blocking pending`,
+      };
+    }
+    return await drive();
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      return {
+        ok: false,
+        kind: 'failed',
+        reason,
+        next: '요청과 실패 이유를 확인한 뒤 다시 요청',
+        missing: ['runId', 'node'],
+        output: `SelfImplement 실패: ${reason} · 다음: 요청과 실패 이유를 확인한 뒤 다시 요청 · 이 턴에서 파일을 직접 편집하지 마세요`,
       };
     }
-    return drive();
   },
 };

package/src/session/index.ts

@@ -142,10 +142,20 @@ function migrateLegacySessions(): void {
 }
 
 function stateRoot(): string {
-  const base = process.env.XDG_STATE_HOME && process.env.XDG_STATE_HOME.trim()
-    ? process.env.XDG_STATE_HOME
-    : join(homedir(), '.local', 'state');
-  return join(base, 'elanous');
+  const universe = process.env.ELANOUS_STATE_DIR?.trim();
+  const root = universe
+    ? join(universe, 'elanous')
+    : join(
+      process.env.XDG_STATE_HOME && process.env.XDG_STATE_HOME.trim()
+        ? process.env.XDG_STATE_HOME
+        : join(homedir(), '.local', 'state'),
+      'elanous',
+    );
+  try {
+    const { debug } = require('../debug/log.js') as typeof import('../debug/log.js');
+    debug.log('session.active', 'pointer-root', { root, universe });
+  } catch { /* 관측 실패가 포인터 경로 결정을 막지 않는다 */ }
+  return root;
 }
 
 function indexPath(root: string = sessionRoot()): string { return join(root, 'index.json'); }