elanous 0.2.43 → 0.2.44

package/src/self-implement/graph-overlay-yaml.ts

@@ -43,6 +43,157 @@ export interface OverlayParseResult {
   readonly errors: readonly GraphParseIssue[];
 }
 
+/** Injected ARG promotion evidence used by the graph-promote rehearsal.
+ * This input is deliberately separate from the production run ledger: a fixture
+ * can exercise the decision path, but its output is always labelled mock-only. */
+export interface ArgPromotionEvidenceEvent {
+  readonly runId: string;
+  readonly timestamp: string;
+  readonly trigger: string;
+  readonly phase: 'adaptation' | 'baseline' | 'shadow';
+  readonly landed?: boolean;
+  readonly shadowAccepted?: boolean;
+}
+
+export interface ArgPromotionCandidate {
+  readonly overlayId: string;
+  readonly target: string;
+  readonly appliesWhen: string;
+  readonly patch: readonly OverlayPatchOp[];
+}
+
+export interface ArgPromotionEvaluation {
+  readonly mockOnly: true;
+  readonly verdict: 'eligible-for-human-pr' | 'held';
+  readonly blockers: readonly string[];
+  readonly metrics: {
+    readonly trigger: string;
+    readonly adaptationRuns: number;
+    readonly adaptationLandingRate: number | null;
+    readonly baselineRuns: number;
+    readonly baselineLandingRate: number | null;
+    readonly landingDelta: number | null;
+    readonly adaptationWindowDays: number | null;
+    readonly shadowObservations: number;
+    readonly shadowWindowDays: number | null;
+  };
+  readonly proposal?: {
+    readonly action: 'proposal-only';
+    readonly promoted_from: readonly string[];
+    readonly evidence: Readonly<Record<string, unknown>>;
+    readonly overlay: {
+      readonly overlay_id: string;
+      readonly target: string;
+      readonly stage: 'launch';
+      readonly applies_when: string;
+      readonly patch: readonly OverlayPatchOp[];
+    };
+    readonly rollback: 'open a human-reviewed demotion PR if the 7-day landing rate declines';
+    readonly patentReview: 'ELA-53 human review pending';
+  };
+}
+
+const PROMOTION_DAY_MS = 24 * 60 * 60 * 1000;
+
+function promotionSpanDays(events: readonly ArgPromotionEvidenceEvent[]): number | null {
+  if (events.length < 2) return null;
+  const times = events.map((event) => Date.parse(event.timestamp));
+  if (times.some((time) => !Number.isFinite(time))) return null;
+  return (Math.max(...times) - Math.min(...times)) / PROMOTION_DAY_MS;
+}
+
+/** Evaluate injected evidence without reading a production ledger, writing an overlay, or opening a PR. */
+export function evaluateArgPromotionFixture(input: {
+  readonly trigger: string;
+  readonly candidate: ArgPromotionCandidate;
+  readonly events: readonly ArgPromotionEvidenceEvent[];
+}): ArgPromotionEvaluation {
+  if (input === null || typeof input !== 'object' || Array.isArray(input)) throw new Error('ARG promotion fixture root must be an object');
+  const { trigger, candidate, events } = input;
+  if (typeof trigger !== 'string' || typeof candidate !== 'object' || candidate === null || Array.isArray(candidate)
+    || typeof candidate.overlayId !== 'string' || typeof candidate.target !== 'string' || typeof candidate.appliesWhen !== 'string'
+    || !Array.isArray(candidate.patch) || !Array.isArray(events)) {
+    throw new Error('ARG promotion fixture requires trigger, candidate object, patch array and events array');
+  }
+  if (!trigger.trim() || !candidate.overlayId.trim() || !candidate.target.trim() || !candidate.appliesWhen.trim()) {
+    throw new Error('ARG promotion fixture requires trigger, overlayId, target and appliesWhen');
+  }
+  if (candidate.patch.length === 0) throw new Error('ARG promotion candidate patch must not be empty');
+  for (const operation of candidate.patch) {
+    if (operation === null || typeof operation !== 'object' || !['add', 'replace', 'remove'].includes(operation.op)
+      || typeof operation.path !== 'string' || !operation.path.startsWith('/')
+      || (operation.op !== 'remove' && !('value' in operation))) {
+      throw new Error('ARG promotion candidate contains an invalid JSON Patch operation');
+    }
+  }
+  const runIds = new Set<string>();
+  for (const rawEvent of events) {
+    if (rawEvent === null || typeof rawEvent !== 'object' || Array.isArray(rawEvent)) throw new Error('ARG promotion fixture contains a non-object event');
+    const event = rawEvent as ArgPromotionEvidenceEvent;
+    if (typeof event.runId !== 'string' || !event.runId.trim() || typeof event.timestamp !== 'string'
+      || !Number.isFinite(Date.parse(event.timestamp)) || typeof event.trigger !== 'string' || !event.trigger.trim()
+      || !['adaptation', 'baseline', 'shadow'].includes(event.phase)) {
+      throw new Error('ARG promotion fixture contains an invalid event');
+    }
+    if (runIds.has(event.runId)) throw new Error(`ARG promotion fixture repeats runId ${event.runId}`);
+    runIds.add(event.runId);
+    if ((event.phase === 'adaptation' || event.phase === 'baseline') && typeof event.landed !== 'boolean') {
+      throw new Error(`ARG promotion ${event.phase} event requires landed`);
+    }
+    if (event.phase === 'shadow' && typeof event.shadowAccepted !== 'boolean') {
+      throw new Error('ARG promotion shadow event requires shadowAccepted');
+    }
+  }
+
+  const matching = events.filter((event) => event.trigger === trigger);
+  const adaptations = matching.filter((event) => event.phase === 'adaptation');
+  const baseline = matching.filter((event) => event.phase === 'baseline');
+  const shadow = matching.filter((event) => event.phase === 'shadow');
+  const rate = (rows: readonly ArgPromotionEvidenceEvent[]): number | null => rows.length === 0
+    ? null : rows.filter((event) => event.landed === true).length / rows.length;
+  const adaptationLandingRate = rate(adaptations);
+  const baselineLandingRate = rate(baseline);
+  const landingDelta = adaptationLandingRate === null || baselineLandingRate === null
+    ? null : adaptationLandingRate - baselineLandingRate;
+  const adaptationSpanDays = promotionSpanDays(adaptations);
+  const baselineSpanDays = promotionSpanDays(baseline);
+  const adaptationWindowDays = adaptationSpanDays === null || baselineSpanDays === null
+    ? null : Math.min(adaptationSpanDays, baselineSpanDays);
+  const shadowWindowDays = promotionSpanDays(shadow);
+  const evidenceEnd = Math.max(...[...adaptations, ...baseline].map((event) => Date.parse(event.timestamp)));
+  const shadowStart = Math.min(...shadow.map((event) => Date.parse(event.timestamp)));
+  const blockers: string[] = [];
+  if (adaptations.length < 5) blockers.push('same-trigger-adaptations-below-5');
+  if (baseline.length === 0) blockers.push('same-trigger-baseline-missing');
+  if (landingDelta === null || landingDelta < 0.2 - Number.EPSILON) blockers.push('landing-improvement-below-20pp');
+  if (adaptationWindowDays === null || adaptationWindowDays < 7) blockers.push('adaptation-evidence-window-under-7-days');
+  if (shadow.length < 2 || shadowWindowDays === null || shadowWindowDays < 7) blockers.push('shadow-window-under-7-days');
+  if (!Number.isFinite(evidenceEnd) || !Number.isFinite(shadowStart) || shadowStart < evidenceEnd) blockers.push('shadow-starts-before-evidence-window');
+  if (shadow.some((event) => event.shadowAccepted !== true)) blockers.push('shadow-evaluation-declined');
+
+  const metrics = { trigger, adaptationRuns: adaptations.length, adaptationLandingRate,
+    baselineRuns: baseline.length, baselineLandingRate, landingDelta, adaptationWindowDays,
+    shadowObservations: shadow.length, shadowWindowDays };
+  if (blockers.length > 0) return { mockOnly: true, verdict: 'held', blockers, metrics };
+  const promotedFrom = adaptations.map((event) => event.runId).sort();
+  return {
+    mockOnly: true, verdict: 'eligible-for-human-pr', blockers, metrics,
+    proposal: {
+      action: 'proposal-only', promoted_from: promotedFrom,
+      evidence: {
+        source: 'injected-mock-fixture', trigger, adaptationRuns: promotedFrom,
+        baselineRuns: baseline.map((event) => event.runId).sort(),
+        adaptationLandingRate, baselineLandingRate, landingDelta,
+        adaptationWindowDays, shadowRunIds: shadow.map((event) => event.runId).sort(), shadowWindowDays,
+      },
+      overlay: { overlay_id: candidate.overlayId, target: candidate.target, stage: 'launch',
+        applies_when: candidate.appliesWhen, patch: candidate.patch },
+      rollback: 'open a human-reviewed demotion PR if the 7-day landing rate declines',
+      patentReview: 'ELA-53 human review pending',
+    },
+  };
+}
+
 const STAGES = new Set<OverlayStage>(['launch', 'runtime', 'heal']);
 const OPS = new Set(['add', 'replace', 'remove']);
 

package/src/self-implement/graph-yaml.ts

@@ -50,6 +50,11 @@ export interface GraphEdgeSpec {
   /** 조건부 엣지 — 라우터가 읽는 «상태 키». ⛔ 값은 코드가 낸다(RFC §4.3 ⑵). */
   readonly on?: string;
   readonly map?: Readonly<Record<string, string>>;
+  /** Explicit fan-out destinations keyed by outcome. Each selected branch runs concurrently and joins at `join`. */
+  readonly branches?: Readonly<Record<string, readonly string[]>>;
+  readonly join?: string;
+  /** Failed warning branches remain visible in the join output but do not fail the barrier. */
+  readonly warningBranches?: readonly string[];
   /** 심이 «주입 안 됐을 때» 내려가는 순서. `requires` 는 그 심 이름들. */
   readonly fallback?: readonly { readonly node: string; readonly requires: readonly string[]; readonly observed?: number }[];
   readonly observed?: number;
@@ -273,14 +278,19 @@ export function parseGraphTemplateYaml(source: string, label = '<inline>'): Grap
     if (!known.has(from)) { errors.push({ path: `${at}/from`, message: `'${from}' 은 선언된 노드가 아니다` }); continue; }
     const hasTo = typeof e.to === 'string';
     const hasMap = e.map !== null && typeof e.map === 'object';
+    const hasBranches = e.branches !== null && typeof e.branches === 'object' && !Array.isArray(e.branches);
     if (e.when !== undefined && (typeof e.when !== 'string' || !parseOverlayCondition(e.when).ok))
       errors.push({ path: `${at}/when`, message: 'when 은 오버레이 조건 한 개(key op literal)여야 한다' });
     if (e.when !== undefined && (L1_PROTECTED_ROUTE_NODES.has(from) || nodes.some(node => node.nodeId === from && node.kind === 'gate') || terminalNodes.includes(from)))
       errors.push({ path: `${at}/when`, message: `'${from}' 의 필수 검증·착지 결과는 when 간선으로 덮을 수 없다` });
     if (e.when !== undefined && (!hasTo || hasMap || e.on !== undefined))
       errors.push({ path: `${at}/when`, message: 'when 은 to 간선에서만 쓴다' });
-    if (hasTo === hasMap) {
-      errors.push({ path: at, message: 'to 와 map 중 «정확히 하나»를 써야 한다' });
+    if (!hasTo && !hasMap && !hasBranches) {
+      errors.push({ path: at, message: 'to 또는 map/branches 조합을 써야 한다' });
+      continue;
+    }
+    if (hasTo && (hasMap || hasBranches)) {
+      errors.push({ path: at, message: 'to 는 map·branches 와 함께 쓸 수 없다' });
       continue;
     }
     const map: Record<string, string> = {};
@@ -292,6 +302,35 @@ export function parseGraphTemplateYaml(source: string, label = '<inline>'): Grap
       }
       if (typeof e.on !== 'string') errors.push({ path: `${at}/on`, message: 'map 을 쓰면 on(라우터가 읽는 상태 키)이 필요하다' });
     }
+    let branches: Record<string, readonly string[]> | undefined;
+    let warningBranches: readonly string[] | undefined;
+    if (hasBranches) {
+      branches = {};
+      for (const [outcome, destinations] of Object.entries(e.branches as Record<string, unknown>)) {
+        if (!Array.isArray(destinations) || destinations.length < 2 || !destinations.every((value) => typeof value === 'string')) {
+          errors.push({ path: `${at}/branches/${outcome}`, message: 'branches 목적지는 두 개 이상의 노드 id 목록이어야 한다' });
+          continue;
+        }
+        if (new Set(destinations).size !== destinations.length)
+          errors.push({ path: `${at}/branches/${outcome}`, message: 'branches 목적지는 중복될 수 없다' });
+        for (const [index, destination] of destinations.entries()) {
+          if (!known.has(destination)) errors.push({ path: `${at}/branches/${outcome}/${index}`, message: `'${destination}' 는 선언된 노드가 아니다` });
+        }
+        branches[outcome] = destinations as string[];
+      }
+      if (typeof e.on !== 'string' || typeof e.join !== 'string' || !known.has(e.join))
+        errors.push({ path: at, message: 'branches 에는 on 과 선언된 join 노드가 필요하다' });
+      if (e.fallback !== undefined || e.when !== undefined) errors.push({ path: at, message: 'branches 는 fallback·when 과 함께 쓸 수 없다' });
+      if (hasMap && Object.keys(map).some((outcome) => Object.hasOwn(e.branches as object, outcome)))
+        errors.push({ path: `${at}/branches`, message: 'map 과 branches 의 outcome 키는 겹칠 수 없다' });
+      if (e.warning_branches !== undefined) {
+        if (!Array.isArray(e.warning_branches) || e.warning_branches.some((branch) => typeof branch !== 'string' || !branch.trim()) ||
+            new Set(e.warning_branches).size !== e.warning_branches.length ||
+            e.warning_branches.some((branch) => !Object.values(branches!).some((destinations) => destinations.includes(branch as string)))) {
+          errors.push({ path: `${at}/warning_branches`, message: 'warning_branches 는 중복 없는 branches 목적지 목록이어야 한다' });
+        } else warningBranches = e.warning_branches as string[];
+      }
+    }
     if (hasTo && !known.has(e.to as string)) { errors.push({ path: `${at}/to`, message: `'${String(e.to)}' 는 선언된 노드가 아니다` }); continue; }
 
     const fallback = asArray(e.fallback).flatMap((f, fi) => {
@@ -309,6 +348,7 @@ export function parseGraphTemplateYaml(source: string, label = '<inline>'): Grap
       from,
       ...(hasTo ? { to: e.to as string } : {}),
       ...(hasMap ? { on: String(e.on), map } : {}),
+      ...(branches ? { on: String(e.on), branches, join: String(e.join), ...(warningBranches ? { warningBranches } : {}) } : {}),
       ...(fallback.length > 0 ? { fallback } : {}),
       ...(typeof e.observed === 'number' ? { observed: e.observed } : {}),
       ...(typeof e.when === 'string' ? { when: e.when } : {}),
@@ -326,6 +366,25 @@ export function parseGraphTemplateYaml(source: string, label = '<inline>'): Grap
     if (!edges.some(candidate => candidate.from === edge.from && candidate.when === undefined))
       errors.push({ path: `${label}/edges/${edge.from}/when`, message: 'when 간선에는 모호·미관측 때 탈 무조건 기본 간선이 필요하다' });
   }
+  const fanOutDestinations = new Map<string, string>();
+  const fanOutJoins = new Map<string, string>();
+  for (const edge of edges) {
+    if (!edge.branches || !edge.join) continue;
+    const sourceNode = nodes.find(node => node.nodeId === edge.from);
+    if (sourceNode && sourceNode.maxVisits !== 1) errors.push({ path: `${label}/edges/${edge.from}/branches`, message: 'fan-out 출발 노드는 재방문할 수 없어 max_visits: 1 이어야 한다' });
+    if (fanOutJoins.has(edge.join) && fanOutJoins.get(edge.join) !== edge.from) errors.push({ path: `${label}/edges/${edge.from}/join`, message: 'join 노드는 하나의 fan-out barrier만 소유할 수 있다' });
+    fanOutJoins.set(edge.join, edge.from);
+    if (edge.join === edge.from || Object.values(edge.branches).some((branches) => branches.includes(edge.join!)))
+      errors.push({ path: `${label}/edges/${edge.from}/join`, message: 'join 노드는 fan-out source나 branch 목적지일 수 없다' });
+    for (const branch of new Set(Object.values(edge.branches).flat())) {
+      if (fanOutDestinations.has(branch) && fanOutDestinations.get(branch) !== edge.from) errors.push({ path: `${label}/edges/${edge.from}/branches`, message: `branch '${branch}' 는 하나의 fan-out source 에서만 실행할 수 있다` });
+      fanOutDestinations.set(branch, edge.from);
+      if (edges.some(candidate => candidate.from === branch)) errors.push({ path: `${label}/edges/${edge.from}/branches`, message: `branch '${branch}' 는 단일 노드만 지원하며 후속 간선은 허용되지 않는다` });
+    }
+    const joinEdge = edges.find((candidate) => candidate.from === edge.join && candidate.on === 'outcome');
+    if (!joinEdge?.map || !Object.hasOwn(joinEdge.map, 'ok') || !Object.hasOwn(joinEdge.map, 'fail'))
+      errors.push({ path: `${label}/edges/${edge.join}`, message: 'fan-out join 은 ok·fail 출구를 모두 선언해야 한다' });
+  }
 
   if (entryNode !== undefined && !known.has(entryNode)) errors.push({ path: `${label}/entry_node`, message: `'${entryNode}' 는 선언된 노드가 아니다` });
   for (const t of terminalNodes) if (!known.has(t)) errors.push({ path: `${label}/terminal_nodes`, message: `'${t}' 는 선언된 노드가 아니다` });
@@ -535,6 +594,13 @@ export function edgeMapOf(template: GraphTemplateSpec): Record<string, string[]>
     const push = (t: string) => { if (!targets.includes(t)) targets.push(t); };
     if (edge.to) push(edge.to);
     for (const t of Object.values(edge.map ?? {})) push(t);
+    for (const destinations of Object.values(edge.branches ?? {})) for (const destination of destinations) {
+      push(destination);
+      if (edge.join) {
+        const branchTargets = edges[destination] ?? (edges[destination] = []);
+        if (!branchTargets.includes(edge.join)) branchTargets.push(edge.join);
+      }
+    }
     for (const fb of edge.fallback ?? []) push(fb.node);
   }
   return edges;

package/src/self-implement/orchestrator.ts

@@ -117,7 +117,7 @@ import { decideLineageSupersede, lineageSupersedeCloseComment, type LineageSuper
 import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { homedir } from 'node:os';
 import { enqueueControlMemo, readSoftStopRequestStatus, type SoftStopRequestRead } from '../harness/control-inbox.js';
-import { debug } from '../debug/log.js';
+import { debug, redactSecretText } from '../debug/log.js';
 import { enterJourneyNode, exitJourneyNode, journeyJoinFields, withJourneyNode } from '../self-dev/graph-journey-nodes.js';
 import { classifyGateEnvDeficit, DEFAULT_GATE_ENV_RETRY, GATE_ENV_DEFICIT_HARVESTABLE_MARK, type GateEnvDeficitKind } from './gate-env-retry.js';
 import { recordFailureEvent } from './heal-intake.js';
@@ -2412,7 +2412,9 @@ export interface SelfImplementResult {
   /** Additive hard-cap disposition; outcome remains the stable public terminal contract. */
   salvage?: 'launched' | 'parked';
   /** Rework stopped on exclusively baseline/flaky/precondition failures; do not retry this goal against the same base. */
-  terminationReason?: 'blocked-by-baseline' | 'goal-only-rework-exhausted' | 'tdd-evidence-missing';
+  terminationReason?: string;
+  /** Child's concrete stop summary when implementation did not converge before TDD evidence adjudication. */
+  terminationDetail?: string;
   /** Structured TDD failure survives child JSON/result truncation and parent-ledger mapping. */
   tddEvidenceFailure?: { reason: 'tdd-evidence-missing'; round: number; missing: readonly TddRecordTag[] };
   sessionId?: string;
@@ -3035,6 +3037,15 @@ type PreparedPrBody = {
 const PR_BODY_TRUNCATION_MARKER_MAX_CHARS = 1_024;
 
 type ChildProviderErrorQueryResult = Exclude<Awaited<ReturnType<NonNullable<SelfImplementSeams['queryChildProviderErrors']>>>, undefined>;
+type ChildProviderErrorDetail = {
+  provider?: string;
+  model?: string;
+  message?: string;
+  observedAt?: string;
+  httpStatus?: number;
+  providerErrorCode?: string;
+  providerErrorType?: string;
+};
 
 /** Aggregates only router-produced structured records; provider messages are never reparsed. */
 export function queryStructuredChildProviderErrors(
@@ -3054,8 +3065,8 @@ export function queryStructuredChildProviderErrors(
     });
     if (rows.length === 0) return { status: 'none' };
     let credentialFailureCount = 0;
-    let lastProviderError: { provider?: string; model?: string; message?: string; observedAt?: string } | undefined;
-    let lastCredentialFailure: { provider?: string; model?: string; message?: string; observedAt?: string } | undefined;
+    let lastProviderError: ChildProviderErrorDetail | undefined;
+    let lastCredentialFailure: ChildProviderErrorDetail | undefined;
     for (const row of rows) {
       let data: Record<string, unknown> | undefined;
       try {
@@ -3067,6 +3078,9 @@ export function queryStructuredChildProviderErrors(
         ...(typeof data?.model === 'string' ? { model: data.model } : {}),
         ...(typeof data?.message === 'string' ? { message: data.message } : {}),
         ...(typeof row.ts === 'string' ? { observedAt: row.ts } : {}),
+        ...(typeof data?.httpStatus === 'number' ? { httpStatus: data.httpStatus } : {}),
+        ...(typeof data?.providerErrorCode === 'string' ? { providerErrorCode: data.providerErrorCode } : {}),
+        ...(typeof data?.providerErrorType === 'string' ? { providerErrorType: data.providerErrorType } : {}),
       };
       lastProviderError = detail;
       if (data?.authRejected === true) {
@@ -3878,8 +3892,8 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
   const latestVerdictSeq = (): number => Math.max(lastFailedGateSeq, lastMustFixReviewSeq);
   const hasCurrentProviderError = (): boolean => providerErrorCount > 0 && lastProviderErrorSeq > latestVerdictSeq();
   const hasCurrentCredentialFailure = (): boolean => credentialFailureCount > 0 && lastCredentialFailureSeq > latestVerdictSeq();
-  let lastProviderError: { provider?: string; model?: string; message?: string; observedAt?: string } | undefined;
-  let lastCredentialFailure: { provider?: string; model?: string; message?: string; observedAt?: string } | undefined;
+  let lastProviderError: ChildProviderErrorDetail | undefined;
+  let lastCredentialFailure: ChildProviderErrorDetail | undefined;
   let childProviderErrorQueryStatus: 'found' | 'none' | 'unavailable' | 'not-configured' = 'not-configured';
   let queriedProviderErrorCount = 0;
   let queriedCredentialFailureCount = 0;
@@ -3929,8 +3943,22 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
       credentialFailureCount,
       queriedProviderErrorCount,
       queriedCredentialFailureCount,
-      lastProviderError: lastProviderError ? { provider: lastProviderError.provider ?? null, model: lastProviderError.model ?? null, observedAt: lastProviderError.observedAt ?? null } : null,
-      lastCredentialFailure: lastCredentialFailure ? { provider: lastCredentialFailure.provider ?? null, model: lastCredentialFailure.model ?? null, observedAt: lastCredentialFailure.observedAt ?? null } : null,
+      lastProviderError: lastProviderError ? {
+        provider: lastProviderError.provider ?? null,
+        model: lastProviderError.model ?? null,
+        observedAt: lastProviderError.observedAt ?? null,
+        ...(typeof lastProviderError.httpStatus === 'number' ? { httpStatus: lastProviderError.httpStatus } : {}),
+        ...(typeof lastProviderError.providerErrorCode === 'string' ? { providerErrorCode: lastProviderError.providerErrorCode } : {}),
+        ...(typeof lastProviderError.providerErrorType === 'string' ? { providerErrorType: lastProviderError.providerErrorType } : {}),
+      } : null,
+      lastCredentialFailure: lastCredentialFailure ? {
+        provider: lastCredentialFailure.provider ?? null,
+        model: lastCredentialFailure.model ?? null,
+        observedAt: lastCredentialFailure.observedAt ?? null,
+        ...(typeof lastCredentialFailure.httpStatus === 'number' ? { httpStatus: lastCredentialFailure.httpStatus } : {}),
+        ...(typeof lastCredentialFailure.providerErrorCode === 'string' ? { providerErrorCode: lastCredentialFailure.providerErrorCode } : {}),
+        ...(typeof lastCredentialFailure.providerErrorType === 'string' ? { providerErrorType: lastCredentialFailure.providerErrorType } : {}),
+      } : null,
       lastProviderErrorSeq,
       lastCredentialFailureSeq,
       lastFailedGateSeq,
@@ -3945,7 +3973,7 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
       if (record.category !== 'llm.router.error') return;
       const data = record.data;
       if (!data || typeof data !== 'object') return;
-      const { provider, model, message } = data as Record<string, unknown>;
+      const { provider, model, message, httpStatus, providerErrorCode, providerErrorType } = data as Record<string, unknown>;
       providerErrorCount++;
       lastProviderErrorSeq = ++failureSequence;
       lastProviderError = {
@@ -3953,6 +3981,9 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
         ...(typeof model === 'string' ? { model } : {}),
         ...(typeof message === 'string' ? { message } : {}),
         ...(typeof record.ts === 'string' ? { observedAt: record.ts } : {}),
+        ...(typeof httpStatus === 'number' ? { httpStatus } : {}),
+        ...(typeof providerErrorCode === 'string' ? { providerErrorCode } : {}),
+        ...(typeof providerErrorType === 'string' ? { providerErrorType } : {}),
       };
       // ⛔⭐⭐⭐ 자격 거부는 「프로바이더 오류」의 부분집합이지만 ***사람이 할 다음 행동이 다르다***
       //   (2026-08-14 실측 · `[T]` 83차): grok 자식 «둘»이 401 로 죽었는데 부모가 남긴 것은
@@ -4798,6 +4829,14 @@ function safeErrorDescription(error: unknown): string {
   }
 }
 
+function safePreservationFailure(error: unknown): string {
+  const detail = redactSecretText(safeErrorDescription(error))
+    .replace(/[\r\n\t\x00-\x1f\x7f]+/g, ' ')
+    .trim()
+    .slice(0, 400);
+  return detail || '[empty preservation error]';
+}
+
 
 /** ⛔ 회전 스냅샷이 «이미 갖고 있는» 값을 증거 칸으로 옮기는 순수 사상.
  *
@@ -6489,7 +6528,7 @@ async function runSelfImplementInner(
             }
           }
         } catch (error) {
-          pushError = error instanceof Error ? error : new Error(String(error));
+          pushError = new Error(safePreservationFailure(error));
         }
       }
       observe('rework-blocked-draft-pr', {
@@ -6503,9 +6542,10 @@ async function runSelfImplementInner(
       }, pushError ? { level: 'warn' } : undefined);
       if (pushError) {
         const failure = preservationErrorStep === 'worktree' ? '워크트리 부재로 보존 실패' : preservationErrorStep === 'commit' ? '로컬 브랜치 커밋 실패' : '원격 브랜치 보존 실패';
-        progress('aborted', `환경 탓 중단 — ${failure}: ${wt.branch} (${pushError.message}; worktree: ${wt.path})`);
+        const failedStep = preservationErrorStep ?? 'push';
+        progress('aborted', `환경 탓 중단 — ${failure}: ${wt.branch} (stage=${failedStep}; error=${pushError.message}; worktree: ${wt.path})`);
         if (preservationErrorStep === 'worktree') return undefined;
-        throw new Error(`환경 탓 중단 — ${failure}: ${wt.branch} (worktree: ${wt.path})`, { cause: pushError });
+        throw new Error(`환경 탓 중단 — ${failure}: ${wt.branch} (stage=${failedStep}; error=${pushError.message}; worktree: ${wt.path})`, { cause: pushError });
       }
       if (worktreeOnly) {
         progress(stage, artifactPath
@@ -7931,8 +7971,13 @@ async function runSelfImplementInner(
       readonly judgment: ReturnType<typeof judgeTddEvidence>;
       readonly implementation: typeof impl;
     }): { readonly transcript: string; readonly judgment: ReturnType<typeof judgeTddEvidence> } => {
-      if (!input.judgment.planned || input.judgment.red.observed || !input.implementation.ok
-        || input.implementation.terminalStatus?.reached !== true) {
+      const skippedReason = !input.judgment.planned ? 'not-planned'
+        : input.judgment.red.observed ? 'child-red-present'
+          : !input.implementation.ok ? 'impl-not-ok'
+            : input.implementation.terminalStatus?.reached !== true ? 'terminal-not-reached' : undefined;
+      if (skippedReason) {
+        observe('tdd-base-test', { round: input.round, status: 'skipped', reason: skippedReason,
+          ...(skippedReason === 'impl-not-ok' ? { implementationFailure: input.implementation.summary.slice(0, 240) } : {}) }, { level: 'warn' });
         return { transcript: input.transcript, judgment: input.judgment };
       }
       if (!wt.resolvedBase) {
@@ -8272,9 +8317,11 @@ async function runSelfImplementInner(
         salvageStatusExpected: false,
         ...(abort.terminalStatus ? { terminalStatus: abort.terminalStatus } : {}),
       });
+      const implementationStop = impl.summary.split(/\r?\n/u, 1)[0]?.trim().slice(0, 240);
       return { ok: false, stage: 'aborted', node: 'implement', ...resolveRunOutcome({ termination: 'abandoned' }),
         ...(tddEvidenceFailure ? { terminationReason: tddEvidenceFailure.reason, tddEvidenceFailure }
-          : goalOnlyReworkExhausted ? { terminationReason: 'goal-only-rework-exhausted' as const } : {}),
+          : goalOnlyReworkExhausted ? { terminationReason: 'goal-only-rework-exhausted' as const }
+            : { terminationReason: implementationStop || 'implementation-did-not-converge', terminationDetail: implementationStop || 'implementation did not converge' }),
         sessionId, worktreePath: wt.path, branch: wt.branch, quotaExhaustionAssessment: quotaExhaustionAssessmentForRun(), ...(impl.completionDisposition ? { completionDisposition: impl.completionDisposition } : {}), ...(pr ? { prUrl: pr.url, prNumber: pr.number } : {}), detail: blockedDraftPrFailure ?? impl.summary,
         ...(blockedDraftPrFailureKind ? { detailKind: blockedDraftPrFailureKind } : {}) };
     }

package/src/self-implement/test-scenario-request.ts

@@ -28,6 +28,8 @@ export interface TestScenarioRequestInput {
   readonly registeredMethodologies: readonly string[];
   /** 라이브 명령의 «출처» — 보통 저작 중인 골 문서의 경로. 없으면 measured 로 못 간다. */
   readonly commandSource?: string;
+  /** Multiple authoritative source candidates are retained for review, never chosen by priority. */
+  readonly commandSourceCandidates?: readonly string[];
 }
 
 export type TestScenarioLiveStatus = 'measured' | 'unmeasured';
@@ -61,7 +63,25 @@ export function requestTestScenario(input: TestScenarioRequestInput): TestScenar
   const canLaunch = input.launch !== null
     && (input.launch.port !== undefined || (input.launch.entrypoint ?? '').trim() !== '');
   const methodologyAvailable = input.registeredMethodologies.includes(LAUNCH_METHODOLOGY);
-  const commandSource = input.commandSource?.trim();
+  const commandSourceCandidates = [...new Set((input.commandSourceCandidates ?? [])
+    .map((candidate) => candidate.trim())
+    .filter((candidate) => /^[^:\s]+:[^:\s]+$/u.test(candidate)))];
+  const explicitCommandSource = input.commandSource?.trim() || undefined;
+  const candidateConflict = commandSourceCandidates.length > 1
+    || (commandSourceCandidates.length === 1 && explicitCommandSource !== undefined && commandSourceCandidates[0] !== explicitCommandSource);
+  const commandSource = candidateConflict
+    ? undefined
+    : explicitCommandSource || commandSourceCandidates[0];
+  // Ambiguous declarations must use file:key tokens. Preserve a legacy explicit
+  // document path as a labeled source token rather than emitting a malformed item.
+  const explicitAmbiguityCandidate = explicitCommandSource
+    ? (/^[^:\s]+:[^:\s]+$/u.test(explicitCommandSource) ? explicitCommandSource : `${explicitCommandSource}:explicit-command-source`)
+    : undefined;
+  const ambiguityCandidates = [...new Set([
+    ...commandSourceCandidates,
+    ...(candidateConflict && explicitAmbiguityCandidate ? [explicitAmbiguityCandidate] : []),
+  ])];
+  const commandSourceAmbiguous = candidateConflict || (!commandSource && commandSourceCandidates.length > 1);
 
   if (canLaunch && methodologyAvailable && commandSource) {
     return {
@@ -76,15 +96,17 @@ export function requestTestScenario(input: TestScenarioRequestInput): TestScenar
   }
 
   // ⛔ 사유를 «가장 바깥 원인»으로 고른다 — 선언이 없으면 방법론·명령출처를 따질 자리가 아니다.
-  const reason = !canLaunch
-    ? 'no-launch-declaration'
+  const reason = commandSourceAmbiguous
+    ? 'ambiguous-command-source'
+    : !canLaunch
+      ? 'no-launch-declaration'
     : !methodologyAvailable
       ? 'no-methodology'
       : 'no-command-source';
   return {
     sections: [
       scenarioSection(UNKNOWN_DELIVERABLE, input.acceptanceCriteria),
-      unmeasuredLiveSection(reason),
+      unmeasuredLiveSection(reason, reason === 'ambiguous-command-source' ? ambiguityCandidates : [], reason === 'ambiguous-command-source' && candidateConflict ? explicitCommandSource : undefined),
       resultReportSection(),
     ],
     deliverableType: UNKNOWN_DELIVERABLE,
@@ -138,13 +160,22 @@ function measuredLiveSection(methodology: string, commandSource: string, launch:
 }
 
 /** L 층(측정 불가) — ⛔ 방법론·명령출처·기동·눈·기대를 «싣지 않는다»(파서가 금지한다). */
-function unmeasuredLiveSection(reason: string): string {
+function unmeasuredLiveSection(reason: string, candidates: readonly string[] = [], explicitSource?: string): string {
+  const prerequisite = reason === 'no-launch-declaration'
+    ? '골이 `## 산출물을 어떻게 켜나` 절에 `Port:` 또는 `Entrypoint:` 를 선언했으면 됐다'
+    : reason === 'ambiguous-command-source'
+      ? '골이 후보 중 하나를 권위 있는 명령 출처로 확정했으면 됐다'
+      : reason === 'no-methodology'
+        ? '호출자가 등록 방법론 레지스트리에 `deliverable-verify` 를 등록했으면 됐다'
+        : '골이 권위 있는 명령 출처를 선언했으면 됐다';
   return [
     '## L. 라이브',
     '',
     '### 상태 `unmeasured`',
     `- 사유: \`${reason}\``,
-    '- 무엇이 있었으면 됐나: 골이 `## 산출물을 어떻게 켜나` 절에 `Port:` 또는 `Entrypoint:` 를 선언했으면 됐다',
+    ...(reason.startsWith('ambiguous-') ? [`- 후보 목록: ${candidates.join(', ')}`] : []),
+    ...(explicitSource ? [`- 원래 명시 출처(후보와 별도): \`${explicitSource}\``] : []),
+    `- 무엇이 있었으면 됐나: ${prerequisite}`,
     '',
     '> ⚠️ ⛔ 「측정 불가」는 「결함 없음」이 «아니다». 이 골은 라이브 층을 «안 본 채» 끝난다.',
   ].join('\n');

package/src/session/chat.ts

@@ -20,7 +20,7 @@ import { debug } from '../debug/log.js';
 import { createRequestSizeGuard, formatRequestSizeStatus, type RequestSizeGuard } from './request-size-guard.js';
 import type { InputSourceKind } from '../input/input-source-kind.js';
 import {
-  getProviderForConfig, streamLLMWithTools, type LLMMessage, type LLMOpts, type LLMProvider,
+  getProviderForConfigAsync, streamLLMWithTools, type LLMMessage, type LLMOpts, type LLMProvider,
   type LLMToolSpec, type ContentBlock,
 } from '../llm.js';
 import type { UserConfig } from '../user-config.js';
@@ -407,7 +407,7 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
       reasoningEffort: llmOpts?.reasoningEffort ?? null,
     });
   }
-  const provider = opts.provider ?? getProviderForConfig(opts.userConfig, llmOpts?.model);
+  const provider = opts.provider ?? await getProviderForConfigAsync(opts.userConfig, llmOpts?.model);
 
   // 2) Assemble, trim, call. When images are attached for THIS turn,
   //    swap the string content of the latest user message for

package/src/session-runtime/index.ts

@@ -1,4 +1,5 @@
 import { buildGitSnapshot } from '../git-fs/index.js';
+import { classifyTuiChatIntent } from '../core-turn/short-question.js';
 import { debug } from '../debug/log.js';
 import { isResearchAgentIntent } from '../tool-hints/signals.js';
 import { resolve } from 'node:path';
@@ -225,6 +226,16 @@ interface SessionToolFamilyRule {
   isAvailable?(toolName: string): boolean;
 }
 
+// Keep generic approvals (for example, Herdr session approvals) out of the decision-ledger lookup.
+const DECISION_PENDING_LOOKUP_TERMS = [
+  '결정 카드', '결정카드', '미결 결정', '열린 결정', '대기 결정', '결정 대기', '결정 승인 대기',
+  'pending decision', 'open decision', 'decision inbox',
+] as const;
+const OPS_SEATS_LOOKUP_TERMS = [
+  '자리 현황', '자리별 현황', '자리 상태', '자리별 상태', '좌석 현황',
+  'seat status', 'seat overview',
+] as const;
+
 const SESSION_TOOL_FAMILY_RULES: SessionToolFamilyRule[] = [
   {
     id: 'structural-search',
@@ -1871,13 +1882,34 @@ export function buildSessionRuntimeToolSpecs(opts: {
     optionalTools: opts.optionalTools ?? [],
     toolAvailability: opts.toolAvailability,
   });
+  // These owner-read facts tools are valid ACP lookup targets, but are too
+  // specific to carry on every dashboard turn. Keep the advertised catalog
+  // aligned with the current question so a routed lookup can actually call it.
+  const lookupRoute = classifyTuiChatIntent(opts.userText).route === '조회';
+  const normalizedIntentText = opts.userText.toLowerCase();
+  const intentHostNames = lookupRoute ? [
+    ...(hasAny(normalizedIntentText, DECISION_PENDING_LOOKUP_TERMS) ? ['decisions_pending'] : []),
+    ...(hasAny(normalizedIntentText, OPS_SEATS_LOOKUP_TERMS) ? ['ops_seats'] : []),
+  ] : [];
+  const hostByName = new Map(opts.hostTools.map(tool => [tool.name, tool] as const));
+  const intentHostSpecs = intentHostNames
+    .filter(name => isToolAvailable(name, opts.toolAvailability))
+    .map(name => hostByName.get(name))
+    .filter((tool): tool is LLMToolDef => !!tool)
+    .map(toSpec);
   const droppedNames = new Set(['Edit', 'Write']);
-  const finalSpecs: LLMToolSpec[] = hasDevHarnessIntent(opts.userText)
-    ? essentialSpecs.filter(spec => !droppedNames.has(spec.name))
-    : essentialSpecs;
-  if (finalSpecs.length !== essentialSpecs.length) {
+  const dropWriteTools = hasDevHarnessIntent(opts.userText);
+  const droppedWriteSpecs = dropWriteTools
+    ? essentialSpecs.filter(spec => droppedNames.has(spec.name))
+    : [];
+  const finalSpecs: LLMToolSpec[] = [...new Map(
+    [...essentialSpecs, ...intentHostSpecs]
+      .filter(spec => !dropWriteTools || !droppedNames.has(spec.name))
+      .map(spec => [spec.name, spec] as const),
+  ).values()];
+  if (droppedWriteSpecs.length > 0) {
     debug.log('session-runtime.tools', 'harness-phrase-write-tools-dropped', {
-      dropped: ['Edit', 'Write'],
+      dropped: droppedWriteSpecs.map(spec => spec.name),
     });
   }
   // Forensic — final tool list returned to streamLLMWithTools. Lets