elanous 0.2.25 → 0.2.28

package/src/self-implement/rework-policy.ts

@@ -628,17 +628,74 @@ function sameProviderStep(child: ExplicitChildForEscalation): EscalateTarget | n
   return null;
 }
 
+/** escalateChild 매핑 해석 근원 — `env` 가 `config` 를 이기고, 둘 다 없으면 같은 provider 사다리(`ladder`). */
+export type EscalateTargetSource = 'config' | 'env' | 'ladder';
+
+/** `self-dev.rework`/`escalate-target` 관측 한 건. 관측 전용 — 판정·분기는 이 값을 읽지 않는다. */
+export interface EscalateTargetObservation {
+  readonly category: 'self-dev.rework';
+  readonly event: 'escalate-target';
+  readonly data: {
+    readonly source: EscalateTargetSource;
+    readonly from: string;
+    readonly to: string;
+    readonly applied: boolean;
+    /** `applied=false` 의 이유 — provider 경계 또는 불완전한 모델 ID. */
+    readonly reason?: 'cross-provider' | 'invalid-target';
+  };
+}
+
+/** 명시 자식 승급 해석 옵션. `escalateChild`(`tools.selfImplement.escalateChild` from→to 맵)는 호출부가
+ *  config 에서 읽어 전달한다 — ⚠️ Pod 안엔 운영 config 가 없다(POD-CONFIG-SNAPSHOT 전) → Pod 자식은
+ *  `ELANOUS_SELFDEV_ESCALATE_CHILD` env 로만 받는다. 관측 싱크도 호출부가 주입한다(정책은 순수 유지). */
+export interface ExplicitChildEscalateOptions {
+  readonly escalateChild?: Readonly<Record<string, string>>;
+  readonly observe?: (observation: EscalateTargetObservation) => void;
+}
+
+/** 모델 id(`openrouter/z-ai/glm-5.3` 등)의 provider 세그먼트 — 첫 `/` 앞. */
+function escalateModelProvider(model: string): string {
+  return (model.split('/')[0] ?? '').trim();
+}
+
+/** 명시 매핑은 provider/model, OpenRouter 는 openrouter/vendor/model 형태의 완전한 ID 여야 한다. */
+function validEscalateModelId(model: string): boolean {
+  const segments = model.split('/');
+  const required = segments[0] === 'openrouter' ? 3 : 2;
+  return segments.length === required && segments.every((segment) => segment.length > 0 && !/\s/.test(segment));
+}
+
+/** `ELANOUS_SELFDEV_ESCALATE_CHILD=<from>=<to>` 해석 — 첫 `=` 기준. 빈 조각·구문 파손은 매핑 없음. */
+function parseEscalateChildEnv(raw: string | undefined): { from: string; to: string } | undefined {
+  const value = raw?.trim();
+  if (!value) return undefined;
+  const separator = value.indexOf('=');
+  if (separator <= 0) return undefined;
+  const from = value.slice(0, separator).trim();
+  const to = value.slice(separator + 1).trim();
+  return from && to ? { from, to } : undefined;
+}
+
 /** 명시 자식의 승급 타깃 — 같은 provider 안에서만(위 규칙). `ELANOUS_SELFDEV_SOL_*` 는 운영자의 명시
  *  덮어쓰기라 그대로 우선한다. ⛔ `effort` 가 빈 문자열이면 «안 보낸다»는 뜻이다(OpenRouter 는 노력을
- *  보내면 덜 생각했다 — 2026-09-23 실측). */
+ *  보내면 덜 생각했다 — 2026-09-23 실측).
+ *  escalateChild 짝지기(env 가 config 를 이긴다)는 사다리(`sameProviderStep`)보다 «먼저» —
+ *  같은 provider 타깃이면 그 타깃으로, provider 가 다르면 무시 ⊕ 관측하고 사다리로 돌아간다.
+ *  둘 다 없으면 종전 그대로(바이트 불변). */
 export function resolveExplicitChildEscalateTarget(
   tier: EscalateTier,
   env: Record<string, string | undefined> = process.env,
   child?: ExplicitChildForEscalation,
+  options?: ExplicitChildEscalateOptions,
 ): EscalateTarget | null {
   if (tier === 'none') return null;
+  const sink = options?.observe;
+  const emit = sink
+    ? (data: EscalateTargetObservation['data']): void => sink({ category: 'self-dev.rework', event: 'escalate-target', data })
+    : undefined;
   const overrideModel = env.ELANOUS_SELFDEV_SOL_MODEL?.trim();
   if (overrideModel) {
+    if (child) emit?.({ source: 'env', from: child.model, to: overrideModel, applied: true });
     return {
       model: overrideModel,
       provider: env.ELANOUS_SELFDEV_SOL_PROVIDER?.trim() || child?.provider || 'openai-codex',
@@ -646,9 +703,30 @@ export function resolveExplicitChildEscalateTarget(
     };
   }
   if (child === undefined) return null;
+  const effortOverride = env.ELANOUS_SELFDEV_SOL_EFFORT?.trim();
+  // env → config 순서로 이 자식 모델에 대한 매핑을 모은다(없는 층은 건너뛴다).
+  const pairings: Array<{ source: 'env' | 'config'; to: string }> = [];
+  const envPairing = parseEscalateChildEnv(env.ELANOUS_SELFDEV_ESCALATE_CHILD);
+  if (envPairing && envPairing.from === child.model) pairings.push({ source: 'env', to: envPairing.to });
+  const configMap = options?.escalateChild;
+  const configTo = configMap && Object.hasOwn(configMap, child.model) ? configMap[child.model]?.trim() : undefined;
+  if (configTo) pairings.push({ source: 'config', to: configTo });
+  for (const pairing of pairings) {
+    if (!validEscalateModelId(pairing.to)) {
+      emit?.({ source: pairing.source, from: child.model, to: pairing.to, applied: false, reason: 'invalid-target' });
+      continue;
+    }
+    if (escalateModelProvider(pairing.to) === child.provider) {
+      emit?.({ source: pairing.source, from: child.model, to: pairing.to, applied: true });
+      return effortOverride
+        ? { model: pairing.to, provider: child.provider, effort: effortOverride }
+        : { model: pairing.to, provider: child.provider, effort: '' };
+    }
+    emit?.({ source: pairing.source, from: child.model, to: pairing.to, applied: false, reason: 'cross-provider' });
+  }
   const step = sameProviderStep(child);
   if (step === null) return null;
-  const effortOverride = env.ELANOUS_SELFDEV_SOL_EFFORT?.trim();
+  emit?.({ source: 'ladder', from: child.model, to: step.model, applied: true });
   return effortOverride ? { ...step, effort: effortOverride } : step;
 }
 

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/self-implement/speed-claims.ts

@@ -2,7 +2,7 @@ import { spawnSync } from 'node:child_process';
 import { readFileSync, readdirSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { prodInstanceRoot } from '../instance/resolve.js';
+import { prodInstanceRoot, releaseLedgerRoot } from '../instance/resolve.js';
 import { seatOfTree } from '../loops/orchestrator/traffic.js';
 import { getUserConfig, ORCHESTRATOR_DEFAULTS } from '../user-config.js';
 import { isRunStatus } from './run-status-mapping.js';
@@ -30,6 +30,7 @@ export interface SpeedClaimsMeasurement {
   rows: SpeedClaimsRow[];
   note: string;
   parent: ParentSpeedClaimsMeasurement;
+  daily: SpeedClaimsDailyMeasurement;
 }
 export interface ParentSpeedClaimsEvent {
   ts: string;
@@ -58,6 +59,32 @@ export interface ParentSpeedClaimsMeasurement {
   note: string;
 }
 
+export interface SpeedClaimsReleaseEvent {
+  ts: string;
+  version: string;
+}
+
+export interface SpeedClaimsDailyRow {
+  date: string;
+  landedPrCount: number | null;
+  releasedCount: number | null;
+}
+
+export interface SpeedClaimsDailySourceStatus {
+  status: 'measured' | 'unmeasured';
+  undatedCount: number;
+}
+
+export interface SpeedClaimsDailyMeasurement {
+  scope: 'last-30-days';
+  windowStart: string;
+  windowEnd: string;
+  landedPrs: SpeedClaimsDailySourceStatus;
+  releases: SpeedClaimsDailySourceStatus;
+  rows: SpeedClaimsDailyRow[];
+  note: string;
+}
+
 export interface SpeedClaimsOptions {
   dir?: string;
   list?: (path: string) => string[];
@@ -65,6 +92,8 @@ export interface SpeedClaimsOptions {
   readSeat?: (runId: string, ledgerDirectory: string, entries: readonly RunLedgerEntry[]) => SpeedClaimsSeat;
   readParentEvents?: () => readonly ParentSpeedClaimsEvent[];
   readParentQueue?: () => unknown;
+  now?: number;
+  readReleaseEvents?: () => readonly SpeedClaimsReleaseEvent[];
 }
 
 const NOTE = 'Child-ledger elapsed minutes from the first child event (or checkpoint creation when unavailable) to the recorded child end, including retries and resumes; this is not the parent launch-to-done interval. Only finished runs enter quartiles (linear interpolation at ranks (n-1)*p). In-progress runs (including parked) and missing, unreadable or invalid timestamps are excluded, not assigned zero. Seats come from the same state root checkpoint, launch queue or recorded launch tree; unresolved seats are counted separately. A completed run without a recorded merge is not a merge.';
@@ -192,6 +221,98 @@ function readParentQueueFromState(): unknown {
   return JSON.parse(readFileSync(join(prodInstanceRoot(), 'harness', 'queue.json'), 'utf8')) as unknown;
 }
 
+const DAILY_WINDOW_DAYS = 30;
+const DAY_MS = 86_400_000;
+const DAILY_NOTE = 'Daily rows cover the last 30 UTC calendar days ending on the measurement day. Landed PRs are child run-ledger merged events (merged=true), identified by PR number with the run id as fallback when no number is recorded, de-duplicated across runs, retries and resumes, and attributed to the earliest recorded landing timestamp. Issued releases use the release ledger publishedAt, never a tag target commit date, and are de-duplicated by version. Identities without any valid timestamp are counted as undated, never as a day. A count of zero means the day was queried and had no events; unmeasured means the source could not be queried, and the JSON value is null. Start-to-land and external-change-to-reflection timings stay with the parent and child measurements above.';
+const VERSION_TAG = /^v?\d+(?:\.\d+)+(?:-[\w.]+)?$/;
+
+interface DailyObservation {
+  key: string;
+  ts: number | null;
+}
+
+function utcDayOf(ts: number): string {
+  return new Date(ts).toISOString().slice(0, 10);
+}
+
+/** Landed-PR identity: the recorded PR number, else the run id (one run lands at most one PR). */
+function landedPrIdentity(data: unknown, runId: string): string {
+  const number = object(data)?.number;
+  if (typeof number === 'number' && Number.isInteger(number) && number > 0) return `pr-${number}`;
+  if (typeof number === 'string' && /^\d+$/.test(number.trim()) && Number(number.trim()) > 0) return `pr-${Number(number.trim())}`;
+  return runId;
+}
+
+/** De-duplicate repeated identities by their earliest valid timestamp; identities without any valid timestamp are reported as undated, never dropped silently. */
+function dailyBuckets(observations: readonly DailyObservation[]): { counts: Map<string, number>; undated: number } {
+  const earliest = new Map<string, number>();
+  const undated = new Set<string>();
+  for (const { key, ts } of observations) {
+    if (key.length === 0) continue;
+    if (ts === null) { undated.add(key); continue; }
+    const known = earliest.get(key);
+    if (known === undefined || ts < known) earliest.set(key, ts);
+  }
+  const counts = new Map<string, number>();
+  for (const ts of earliest.values()) {
+    const day = utcDayOf(ts);
+    counts.set(day, (counts.get(day) ?? 0) + 1);
+  }
+  let undatedCount = 0;
+  for (const key of undated) if (!earliest.has(key)) undatedCount++;
+  return { counts, undated: undatedCount };
+}
+
+/** Read-only daily census of landed PRs and issued releases over the last 30 UTC days. */
+function measureDailySpeedClaims(
+  landed: readonly DailyObservation[],
+  landedMeasured: boolean,
+  releases: readonly SpeedClaimsReleaseEvent[] | null,
+  now: number,
+): SpeedClaimsDailyMeasurement {
+  const windowEnd = utcDayOf(now);
+  const startMs = Date.parse(`${windowEnd}T00:00:00.000Z`) - (DAILY_WINDOW_DAYS - 1) * DAY_MS;
+  const landedBuckets = dailyBuckets(landed);
+  const releaseBuckets = releases === null
+    ? null
+    : dailyBuckets(releases.map((event) => ({ key: event.version.trim().replace(/^v(?=\d)/, ''), ts: parseTime(event.ts) })));
+  const landedComplete = landedMeasured && landedBuckets.undated === 0;
+  const releasesComplete = releaseBuckets !== null && releaseBuckets.undated === 0;
+  return {
+    scope: 'last-30-days', windowStart: utcDayOf(startMs), windowEnd,
+    landedPrs: { status: landedComplete ? 'measured' : 'unmeasured', undatedCount: landedBuckets.undated },
+    releases: { status: releasesComplete ? 'measured' : 'unmeasured', undatedCount: releaseBuckets?.undated ?? 0 },
+    rows: Array.from({ length: DAILY_WINDOW_DAYS }, (_, index) => {
+      const date = utcDayOf(startMs + index * DAY_MS);
+      return {
+        date,
+        landedPrCount: landedComplete ? (landedBuckets.counts.get(date) ?? 0) : null,
+        releasedCount: releasesComplete ? (releaseBuckets!.counts.get(date) ?? 0) : null,
+      };
+    }),
+    note: DAILY_NOTE,
+  };
+}
+
+/** Release manifests record the actual publication time; lightweight tags have no creation timestamp. */
+function readReleaseEventsFromLedger(): SpeedClaimsReleaseEvent[] {
+  const root = join(releaseLedgerRoot(), 'release');
+  const versions = readdirSync(root).filter((version) => VERSION_TAG.test(version));
+  const events: SpeedClaimsReleaseEvent[] = [];
+  for (const version of versions) {
+    // Absence and corruption are both unmeasured; only a readable manifest proves preparation.
+    const value: unknown = JSON.parse(readFileSync(join(root, version, 'release.json'), 'utf8')) as unknown;
+    const record = object(value);
+    if (record?.version !== version) throw new Error(`release manifest version mismatch: ${version}`);
+    if (!Object.hasOwn(record, 'publishedAt')) continue; // Prepared, not yet published.
+    if (typeof record.publishedAt !== 'string' || parseTime(record.publishedAt) === null) throw new Error(`invalid release publication time: ${version}`);
+    events.push({ version, ts: record.publishedAt });
+  }
+  // A checkout without tags or a release history cannot establish a queried zero.
+  if (versions.length === 0) throw new Error('release publication history unavailable');
+  return events;
+}
+
 /** Parent launch-to-done census; no child ledger id is used as a join key. */
 export function measureParentSpeedClaims(
   events: readonly ParentSpeedClaimsEvent[], queue?: unknown,
@@ -262,7 +383,13 @@ export function measureParentSpeedClaims(
 
 /** Read-only elapsed-time census of canonical local run ledgers, including unsuccessful runs. */
 export function measureSpeedClaims(options: SpeedClaimsOptions = {}): SpeedClaimsMeasurement {
+  const now = options.now ?? Date.now();
   const ledgerDirectory = resolve(options.dir ?? runLedgerDir());
+  let releaseEvents: readonly SpeedClaimsReleaseEvent[] | null = null;
+  try {
+    const events = (options.readReleaseEvents ?? readReleaseEventsFromLedger)();
+    releaseEvents = Array.isArray(events) ? events : null;
+  } catch { /* An unreadable release source marks releases unmeasured; it does not erase landed-PR observations. */ }
   let parent: ParentSpeedClaimsMeasurement;
   try {
     const events = (options.readParentEvents ?? readParentEventsFromLogs)();
@@ -272,21 +399,27 @@ export function measureSpeedClaims(options: SpeedClaimsOptions = {}): SpeedClaim
   } catch {
     parent = { ...measureParentSpeedClaims([]), status: 'cannot-measure' };
   }
-  const result: SpeedClaimsMeasurement = {
+  const result: Omit<SpeedClaimsMeasurement, 'daily'> = {
     scope: 'self-implement-run-ledger', ledgerDirectory, status: 'measured',
     completedCount: 0, inProgressCount: 0, cannotMeasureCount: 0, unknownSeatCount: 0, rows: [], note: NOTE, parent,
   };
   let files: string[];
   try { files = (options.list ?? readdirSync)(ledgerDirectory); }
-  catch { return { ...result, status: 'cannot-measure' }; }
+  catch { return { ...result, status: 'cannot-measure', daily: measureDailySpeedClaims([], false, releaseEvents, now) }; }
 
+  const landed: DailyObservation[] = [];
+  let ledgerUnreadable = false;
   const groups = new Map<string, { seat: SpeedClaimsSeat; outcome: SpeedClaimsOutcome; values: number[] }>();
   for (const file of files.sort()) {
     const runId = file.endsWith('.jsonl') ? file.slice(0, -'.jsonl'.length) : '';
     if (!CANONICAL_RUN_ID.test(runId)) continue;
     try {
       const entries = loadRunLedger(runId, ledgerDirectory, options.read);
-      if (!entries || entries.length === 0) { result.cannotMeasureCount++; continue; }
+      if (!entries || entries.length === 0) { ledgerUnreadable = true; result.cannotMeasureCount++; continue; }
+      const merges = entries.filter((entry) => entry.event === 'merged' && entry.data.merged === true);
+      const numbered = new Set(merges.map((entry) => landedPrIdentity(entry.data, runId)).filter((key) => key !== runId));
+      if (numbered.size > 1) ledgerUnreadable = true; // Conflicting PR identities cannot establish a daily count.
+      else for (const entry of merges) landed.push({ key: numbered.size === 1 ? [...numbered][0]! : runId, ts: parseTime(entry.timestamp) });
       const end = endOfRun(entries);
       const first = time(entries[0]);
       const createdAt = checkpointFor(runId, ledgerDirectory)?.createdAt;
@@ -306,14 +439,14 @@ export function measureSpeedClaims(options: SpeedClaimsOptions = {}): SpeedClaim
       group.values.push((endTime! - start) / 60_000);
       groups.set(key, group);
       result.completedCount++;
-    } catch { result.cannotMeasureCount++; }
+    } catch { result.cannotMeasureCount++; ledgerUnreadable = true; }
   }
   result.rows = [...groups.values()].map(({ seat, outcome, values }) => {
     values.sort((a, b) => a - b);
     return { seat, outcome, count: values.length, underOneMinuteCount: values.filter((minutes) => minutes < 1).length, medianMinutes: percentile(values, 0.5), q1Minutes: percentile(values, 0.25), q3Minutes: percentile(values, 0.75) };
   }).sort((a, b) => SEATS.indexOf(a.seat) - SEATS.indexOf(b.seat) || a.outcome.localeCompare(b.outcome));
   if (result.cannotMeasureCount > 0) result.status = 'cannot-measure';
-  return result;
+  return { ...result, daily: measureDailySpeedClaims(landed, !ledgerUnreadable, releaseEvents, now) };
 }
 
 export function renderSpeedClaims(result: SpeedClaimsMeasurement): string {
@@ -334,5 +467,11 @@ export function renderSpeedClaims(result: SpeedClaimsMeasurement): string {
     `parent cannot measure (excluded): ${result.parent.cannotMeasureCount}`,
     ...result.parent.rows.map((row) => `seat=${row.seat} stage=${row.stage} merged=${row.merged} count=${row.count} median=${row.medianMinutes}m q1=${row.q1Minutes}m q3=${row.q3Minutes}m`),
     `parent note: ${result.parent.note}`,
+    'daily landed PRs / issued releases (last 30 days, UTC):',
+    `daily window: ${result.daily.windowStart}..${result.daily.windowEnd}`,
+    `landed PRs status: ${result.daily.landedPrs.status} (undated: ${result.daily.landedPrs.undatedCount})`,
+    `issued releases status: ${result.daily.releases.status} (undated: ${result.daily.releases.undatedCount})`,
+    ...result.daily.rows.map((row) => `date=${row.date} landed=${row.landedPrCount ?? 'unmeasured'} released=${row.releasedCount ?? 'unmeasured'}`),
+    `daily note: ${result.daily.note}`,
   ].join('\n');
 }

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'); }