elanous 0.2.36 → 0.2.37

package/src/self-dev/ask-launch-flow.ts

@@ -10,7 +10,7 @@
 //   (바꾸면 이 추출이 회귀인지 개선인지 사후에 못 가른다.)
 // ⛔ 종료(`process.exit`)는 여기가 «안» 한다 — 호출자가 자기 표면에 맞게 끝낸다.
 //   그래서 결과를 «세 값»으로 낸다: 발사 / 저작 전 중단 / 전제 검사 중단.
-import { linesOutsideFencedCode } from '../self-implement/goal-author.js';
+import { linesOutsideFencedCode, readGoalAuthorGroundingTimebox, type GoalAuthorGroundingTimebox } from '../self-implement/goal-author.js';
 import { existsSync } from 'node:fs';
 import { debug } from '../debug/log.js';
 import { appendRunLedgerEntry, runLedgerDir } from '../self-implement/run-ledger.js';
@@ -69,6 +69,23 @@ export interface AskAuthoredGoal {
   readonly authored?: { readonly document?: string; readonly grounded?: boolean | null; readonly authorRunId?: string } | null;
 }
 
+/**
+ * ⭐ AUTHOR-TIMEBOX 결과 줄 — `formatOrchestrateResultLine`
+ * (`  ${icon} ${status} · ${feature}${disp}${error}`)과 **같은 모양**을 쓴다.
+ *
+ * ⛔ `src/self-dev/orchestrate-summary-line.ts` 는 «안 고친다» — 다른 명령·화면의 기본 동작과
+ *   원장 형식은 보존 계약이다. 그래서 같은 모양을 이 자리에서 «쓴다».
+ * ⛔ 접지가 예산 초과로 끊긴 저작이 «조용히» 지나가면 상위 디스패처는 그 런을 성공으로도
+ *   실패로도 판정하지 못한다(80분 런 사망의 실제 모양).
+ */
+export function formatGoalAuthorTimeboxResultLine(
+  goalFile: string,
+  timebox: GoalAuthorGroundingTimebox,
+): string {
+  const feature = (goalFile.split('/').at(-1) ?? goalFile).slice(0, 56);
+  return `  ❌ NOT-GROUNDED · ${feature} [author-timebox] — grounding-timebox: exceeded ${timebox.budgetMs}ms budget after ${timebox.elapsedMs}ms; authoring stopped before launch`;
+}
+
 export type LaunchingTreeProbe =
   | { readonly kind: 'measured'; readonly ahead: number; readonly behind: number; readonly reference: string }
   | { readonly kind: 'unmeasurable'; readonly error: string };
@@ -240,7 +257,12 @@ export type AskLaunchFlowResult =
   /** ⓪ 저작 «전»에 막혔다 — 100초를 안 썼다. */
   | { readonly kind: 'stopped-before-authoring'; readonly goalFile?: undefined }
   /** ⑵⑶⑷ 에서 막혔다 — 골은 «있다»(사람이 열어볼 수 있게 돌려준다). */
-  | { readonly kind: 'stopped-by-preflight'; readonly goalFile: string; readonly blockers: LaunchPreflightResult['blockers'] };
+  | { readonly kind: 'stopped-by-preflight'; readonly goalFile: string; readonly blockers: LaunchPreflightResult['blockers'] }
+  /** ⑴ 저작에서 접지 예산(AUTHOR-TIMEBOX)을 넘겨 NOT-GROUNDED 로 끝났다 — 발사하지 «않는다». */
+  | { readonly kind: 'stopped-by-timebox'; readonly goalFile: string };
+
+/** ⑴ AUTHOR-TIMEBOX NOT-GROUNDED — 결과 줄을 쓰고 흐름을 끊는 값. */
+export type AskLaunchFlowTimeboxStop = Extract<AskLaunchFlowResult, { kind: 'stopped-by-timebox' }>;
 
 /** 런 식별자가 흐름 뒤에 확정된 호출자는 이 관측으로 입구와 런을 조인한다. */
 export function observeAskLaunchRunIdentity(
@@ -738,7 +760,7 @@ async function intakeClarifications(
   input: AskLaunchFlowInput,
   deps: AskLaunchFlowDeps,
   selfResolveClarifications: ResolvedSelfResolveClarifications,
-): Promise<string> {
+): Promise<string | AskLaunchFlowTimeboxStop> {
   let effectiveGoalFile = authored.path;
   let document = deps.readFile(effectiveGoalFile);
   const { pending, mode } = planClarificationIntake(document, deps.isInteractive());
@@ -824,6 +846,28 @@ async function intakeClarifications(
   const parentDocument = document;
   effectiveGoalFile = isAbsolutePath(reauthored.path) ? reauthored.path : resolvePath(deps.cwd(), reauthored.path);
   deps.print(`[ask] ⑴b 재저작됨: ${reauthored.path}`);
+  // 재저작도 «같은 저작 진입점»이다 — 접지가 예산 초과로 끊기면 같은 결과 줄을 쓴다(조용히 넘기지 않는다).
+  const reauthoredTimebox = reauthored.authored?.document === undefined
+    ? null
+    : readGoalAuthorGroundingTimebox(reauthored.authored.document);
+  if (reauthoredTimebox !== null) {
+    deps.print(formatGoalAuthorTimeboxResultLine(reauthored.path, reauthoredTimebox));
+    deps.log('ask-author-timebox', {
+      goalFile: reauthored.path,
+      provenance: 'reauthor',
+      outcome: 'NOT-GROUNDED',
+      budgetMs: reauthoredTimebox.budgetMs,
+      elapsedMs: reauthoredTimebox.elapsedMs,
+      grounded: reauthored.authored?.grounded ?? null,
+    }, 'warn');
+    // ⛔⭐⭐ 재저작 NOT-GROUNDED 도 «끝»이다 — 결과 줄을 쓰고 되묻기 이후 단계로 지나가지 않는다.
+    observeFrontNodeExit({ node: 'author', outcome: 'not-grounded' }, {
+      ...(input.runId === undefined ? {} : { runId: input.runId }),
+      attempt: 1, goalFile: effectiveGoalFile,
+      reason: `grounding-timebox-exhausted (budget ${reauthoredTimebox.budgetMs}ms, elapsed ${reauthoredTimebox.elapsedMs}ms)`,
+    });
+    return { kind: 'stopped-by-timebox', goalFile: effectiveGoalFile };
+  }
   // ⛔ 「재저작이 «났다»」와 「재저작이 «옳았다»」는 다른 물음이다(JDG-T35 3단 ⑶).
   const childDocument = reauthored.authored?.document ?? deps.readFile(effectiveGoalFile);
   const askFidelity = classifyReauthoredAsk(parentDocument, childDocument);
@@ -886,10 +930,10 @@ export async function runAskLaunchFlow(
   if (launchPreflight === false) return { kind: 'stopped-before-authoring' };
 
   await deps.beforeAuthoring?.();
-  const authorAndPreflight = async (authorAskText: string = input.askText, machineSuggestedTargetPaths: readonly string[] = [], attempt = 1): Promise<{
-    readonly goalFile: string;
-    readonly decision: ReturnType<typeof decideAskPreflight>;
-  }> => {
+  const authorAndPreflight = async (authorAskText: string = input.askText, machineSuggestedTargetPaths: readonly string[] = [], attempt = 1): Promise<
+    | { readonly goalFile: string; readonly decision: ReturnType<typeof decideAskPreflight> }
+    | AskLaunchFlowTimeboxStop
+  > => {
     // ⛔ 수를 박지 않는다 — 「100~110초」가 박혀 있었고 2026-08-23 prod 실측은 «206초»(2배)였다.
     //    재는 명령: elanous logs --category goal-author --event phase-end --json --json-data
     deps.print('[ask] ⑴ 저작 — self author (수 분 걸린다 · 페이즈별 실측은 goal-author/phase-end)');
@@ -926,6 +970,29 @@ export async function runAskLaunchFlow(
       throw error;
     });
     deps.print(`[ask] 저작됨: ${authored.path}`);
+    // ⛔⭐⭐ AUTHOR-TIMEBOX — 접지가 예산을 넘겨 끊긴 저작은 «결과 줄» 없이 지나가면 안 된다.
+    //   이 자리가 ask → Pod 발사를 쥔 곳이므로(이 흐름이 발사 여부를 정한다), 여기서 한 줄을 쓴다.
+    const groundingTimebox = authored.authored?.document === undefined
+      ? null
+      : readGoalAuthorGroundingTimebox(authored.authored.document);
+    if (groundingTimebox !== null) {
+      deps.print(formatGoalAuthorTimeboxResultLine(authored.path, groundingTimebox));
+      deps.log('ask-author-timebox', {
+        goalFile: authored.path,
+        provenance: 'author',
+        outcome: 'NOT-GROUNDED',
+        budgetMs: groundingTimebox.budgetMs,
+        elapsedMs: groundingTimebox.elapsedMs,
+        grounded: authored.authored?.grounded ?? null,
+      }, 'warn');
+      // ⛔⭐⭐ NOT-GROUNDED 는 «끝»이다 — 이 흐름이 발사 여부를 정하므로, 결과 줄을 쓰고 나서
+      //   되묻기·전제 검사·발사로 «지나가지 않는다». 저작 종료 출구를 그래프에 남기고 흐름을 끊는다.
+      observeFrontNodeExit({ node: 'author', outcome: 'not-grounded' }, {
+        ...frontObservation, attempt, goalFile: authored.path,
+        reason: `grounding-timebox-exhausted (budget ${groundingTimebox.budgetMs}ms, elapsed ${groundingTimebox.elapsedMs}ms)`,
+      });
+      return { kind: 'stopped-by-timebox', goalFile: authored.path };
+    }
     // AUTHOR-TRACE: the authored goal file can be cleaned up later — keep path ⊕ sha256 ⊕ size in the run ledger and
     // archive the body, so authoring length is measurable after the fact (GOAL-BENCH · AUTHOR-LITE).
     const traceIds = {
@@ -979,10 +1046,13 @@ export async function runAskLaunchFlow(
     }, markerCounts !== null && markerCounts.missingMarkers > 0 ? 'warn' : 'info');
 
     // ⛔ 되묻기에 답하면 «새 골»이 나온다 — 아래 전제 검사·발사는 그 «최종» 골을 써야 한다.
-    const goalFile = await intakeClarifications({
+    const clarifiedGoalFile = await intakeClarifications({
       ...authored,
       path: isAbsolutePath(authored.path) ? authored.path : resolvePath(deps.cwd(), authored.path),
     }, input, deps, selfResolveClarifications);
+    // 재저작이 AUTHOR-TIMEBOX 로 끊겼으면 이 흐름도 그대로 끊는다 — 전제 검사·발사로 지나가지 않는다.
+    if (typeof clarifiedGoalFile !== 'string') return clarifiedGoalFile;
+    const goalFile = clarifiedGoalFile;
     // The child reads this file again. Filtering only preflight.paths would leave the same bogus
     // TRACED PATHS prose in the child and repeat its missing-file failure.
     let sanitizeFailed = false;
@@ -1090,7 +1160,10 @@ export async function runAskLaunchFlow(
     });
   };
 
-  let authored = await authorAndPreflight();
+  let firstAuthored = await authorAndPreflight();
+  // 저작 단계가 AUTHOR-TIMEBOX NOT-GROUNDED 로 끝났으면 이 흐름도 그대로 끊는다.
+  if ('kind' in firstAuthored) return firstAuthored;
+  let authored = firstAuthored;
   let reauthored = false;
   const retryableNoTargetPaths = !input.forceRequested
     && !authored.decision.shouldLaunch
@@ -1142,9 +1215,12 @@ export async function runAskLaunchFlow(
       deps.print('[ask] ⑴ ⚠️ 자동 재저작에 넣을 대상 경로 후보가 없다. 대상 경로를 확인해야 한다');
     }
     recordPodAuthoring('ask-auto-reauthor', { candidatePathCount: candidates.paths.length, firstPathCount: first.decision.result.paths.length, outcome: 'started' });
-    authored = await authorAndPreflight(selectedPaths.length > 0
+    const secondAuthored = await authorAndPreflight(selectedPaths.length > 0
       ? `대상 경로: ${selectedPaths.join(' · ')}\n${input.askText}`
       : input.askText, selectedPaths, 2);
+    // 재시도 저작도 AUTHOR-TIMEBOX 로 끊길 수 있다 — 그러면 발사하지 않는다.
+    if ('kind' in secondAuthored) return secondAuthored;
+    authored = secondAuthored;
     // 두 번째 not-grounded 는 re-ground 예산(max_visits 1)을 넘어 needs-human(근거 카드)으로 — 판정은 observeFrontNodeExit 가 선언에서 읽는다.
     observeAuthorExit(2, authored, !authored.decision.shouldLaunch && authorNotGrounded(authored.decision) ? 'not-grounded' : 're-authored');
     deps.log('ask-auto-reauthor', {

package/src/self-dev/decompose-proposal.ts

@@ -276,7 +276,7 @@ export interface ShadowFirstPlan {
 /** shadow-first 집행 판정. ⛔ 「고칠 수 없음」과 「거부」를 같은 값으로 접지 않는다. */
 export type ShadowFirstDispatch =
   | { kind: 'ok'; pieces: DecomposePiece[]; shadowFirst?: ShadowFirstPlan }
-  | { kind: 'rejected'; reason: 'dangling-dependsOn'; danglingIds: string[] };
+  | { kind: 'rejected'; reason: 'dangling-dependsOn' | 'shadow-depends-on-live' | 'shadow-depends-on-self'; detail: string[] };
 
 /**
  * ⭐⭐⭐ shadow 관측이 live 발사보다 «앞선다» — AUTHOR-SHADOW-FIRST-SPLIT ② (#26884 수확).
@@ -290,13 +290,21 @@ export type ShadowFirstDispatch =
  *     없는 조각을 선행으로 단 제안은 승격하지 않는다(`danglingDependsOn` 을 세는 것만으로는 live 발사를 못 막는다).
  *   ⓑ shadow 조각이 «둘» 이상 → `kind: 'ok'` 지만 «가드 없음» — 어느 쪽이 관측인지 모르는 제안은 고치지 않는다.
  *
- * ⭐ 선행 간선은 «실제 발사 지점»(다른 조각이 의존하지 않는 끝 조각)에만 건다 — 중간 조각은
- *   자기 선행 순서만 들고 있으면 되고, 그 것까지 shadow 에 매달면 계획이 사슬로 납작해진다.
- *   shadow 조각은 언제나 맨 앞으로 올라오고, 이미 shadow 를 선행으로 가진 조각은 건드리지 않는다.
+ * ⭐ 모든 live 조각이 shadow 를 선행으로 가져야 관측이 어떤 실행 순서보다 먼저다.
+ *   live 조각 사이의 기존 의미 의존성은 그대로 둔다. shadow 가 live 조각에 의존하는 경우는
+ *   이 순서와 모순이므로 거부한다.
  *
  * 순수 함수다 — 시계·파일·프로세스를 안 만진다. 입력 조각은 «변형하지 않는다».
  */
 export function planShadowFirstDispatch(pieces: readonly DecomposePiece[]): ShadowFirstDispatch {
+  const shadowPieces = pieces.filter((piece) => piece.id === SHADOW_PIECE_ID);
+  if (shadowPieces.length !== 1) return { kind: 'ok', pieces: [...pieces] };
+
+  const shadow = shadowPieces[0]!;
+  const rest = pieces.filter((piece) => piece !== shadow);
+  if (shadow.dependsOn.includes(SHADOW_PIECE_ID)) {
+    return { kind: 'rejected', reason: 'shadow-depends-on-self', detail: [SHADOW_PIECE_ID] };
+  }
   const known = new Set(pieces.map((piece) => piece.id));
   const danglingIds: string[] = [];
   for (const piece of pieces) {
@@ -305,19 +313,20 @@ export function planShadowFirstDispatch(pieces: readonly DecomposePiece[]): Shad
       danglingIds.push(dep);
     }
   }
-  if (danglingIds.length) return { kind: 'rejected', reason: 'dangling-dependsOn', danglingIds };
-
-  const shadowPieces = pieces.filter((piece) => piece.id === SHADOW_PIECE_ID);
-  if (shadowPieces.length !== 1) return { kind: 'ok', pieces: [...pieces] };
-
-  const shadow = shadowPieces[0]!;
-  const rest = pieces.filter((piece) => piece !== shadow);
-  const dependedUpon = new Set<string>();
-  for (const piece of rest) for (const dep of piece.dependsOn) dependedUpon.add(dep);
+  if (danglingIds.length) return { kind: 'rejected', reason: 'dangling-dependsOn', detail: danglingIds };
+
+  // A shadow observation cannot be ordered before a live piece if it itself
+  // depends on that piece. Reject this cyclic ordering instead of returning a
+  // plan that appears shadow-first but cannot be dispatched in that order.
+  const liveIds = new Set(rest.map((piece) => piece.id));
+  const shadowLiveDependencies = shadow.dependsOn.filter((dep) => liveIds.has(dep));
+  if (shadowLiveDependencies.length) {
+    return { kind: 'rejected', reason: 'shadow-depends-on-live', detail: [...new Set(shadowLiveDependencies)] };
+  }
 
   let restoredEdges = 0;
   const reordered = rest.map((piece) => {
-    if (dependedUpon.has(piece.id) || piece.dependsOn.includes(SHADOW_PIECE_ID)) return piece;
+    if (piece.dependsOn.includes(SHADOW_PIECE_ID)) return piece;
     restoredEdges++;
     return { ...piece, dependsOn: [...piece.dependsOn, SHADOW_PIECE_ID] };
   });
@@ -457,7 +466,7 @@ export function readDecomposeProposals(input: {
 /** 승격하지 «않은» 제안 하나 — ⛔ 조용히 원본만 두면 다음 라운드가 같은 제안을 다시 쓴다. */
 export interface DecomposeRejection {
   feature: string;
-  reason: 'dangling-dependsOn';
+  reason: 'dangling-dependsOn' | 'shadow-depends-on-live' | 'shadow-depends-on-self';
   /** 무엇이 매달렸나 — 조각 목록에 없는 선행 id 들. */
   detail: string[];
 }
@@ -533,17 +542,19 @@ export function applyDecomposeProposals(
   for (const goal of goals) {
     const pieces = byFeature.get(goal.feature);
     if (!pieces) { out.push(goal); continue; }
-    // ⛔⭐ shadow-first 가드 — 매달린 선행 간선이 있는 제안은 «쪼개지 않는다»(원본을 그대로 둔다).
+    // ⛔⭐ shadow-first 가드 — shadow proposal의 매달린 간선은 «쪼개지 않는다»(원본 유지).
+    // 일반 proposal은 기존 orderPiecesTopologically 계약대로 dangling 간선을 세고 계속 처리한다.
     const plan = planShadowFirstDispatch(pieces);
     if (plan.kind === 'rejected') {
-      rejected.push({ feature: goal.feature, reason: plan.reason, detail: [...plan.danglingIds] });
+      rejected.push({ feature: goal.feature, reason: plan.reason, detail: [...plan.detail] });
       // ⛔⭐ 거부를 «로그와 값에 다» 남긴다 — 조용히 버리면 다음 라운드가 같은 제안을 다시 쓴다.
       //   혼합 문서 거부(mixed-decompose-document)와 같은 관측 채널·같은 fail-open 규율이다.
       try {
         debug.log('self-dev.decompose', 'decompose-rejected', {
           feature: goal.feature,
           reason: plan.reason,
-          danglingIds: [...plan.danglingIds],
+          detail: [...plan.detail],
+          ...(plan.reason === 'dangling-dependsOn' ? { danglingIds: [...plan.detail] } : {}),
         });
       } catch { /* fail-open */ }
       out.push(goal);

package/src/self-dev/dev-pipeline.ts

@@ -45,7 +45,7 @@ import { addSelfDevRunParticipant, processBirthId, saveSelfDevRun } from './run-
 import { getUserConfig, resolveRoleLlm, type RoleLlmSource } from '../user-config.js';
 import { applyGlmCredentialFallback, GlmChildCredentialError } from './glm-credential-guard.js';
 import { reviewReasoningEffort } from '../model-tier/review-effort.js';
-import { getProvider, inferProviderFromModel } from '../llm.js';
+import { getProvider, getProviderForConfig, inferProviderFromModel } from '../llm.js';
 import { buildReviewProviderAttempts, defaultReviewFallbackModel, runReviewWithFallback, reviewFallbackModelsFromConfig, runSubscriptionReviewer, type SubscriptionReviewerDeps } from './review-provider-fallback.js';
 import { loadLlmPolicy, resolveSubscriptionReviewer } from '../policy/llm-policy.js';
 import type { DefaultSeamsOptions } from '../self-implement/seams.js';
@@ -1126,12 +1126,34 @@ export async function buildDefaultSelfImplementSeams(
   //   ⛔ 쿼터 폴백(`DEFAULT_FALLBACK_CHAIN`)과 «다른 축»이다 — 그 자는 「계정이 남았나」를 본다.
   //   ⭐ 첫 시도 성공이면 종전과 «완전히 동일»하다(관측 한 줄만 는다).
   const reviewFallbackModels = reviewFallbackModelsFromConfig();
-  const reviewAttemptForModel = (model: string, label: string) => ({
-    model,
-    provider: inferProviderFromModel(model) ? getProvider(model) : undefined,
-    label,
-  });
-  const primaryReviewAttempt = reviewAttemptForModel(reviewModel, 'primary');
+  const reviewAttemptForModel = (model: string, label: string, configuredProvider?: string) => {
+    // GLM's historical alias and both OpenRouter spellings identify the same model even when
+    // a Pod/default role carries no provider source. Resolve the provider from the canonical ID.
+    const normalizedInput = model.trim().toLowerCase();
+    const isGlm53 = normalizedInput === 'glm-5.3'
+      || normalizedInput === 'z-ai/glm-5.3'
+      || normalizedInput === 'openrouter/z-ai/glm-5.3';
+    const normalizedModel = isGlm53
+      ? 'openrouter/z-ai/glm-5.3'
+      : configuredProvider === 'openrouter' && !model.startsWith('openrouter/') ? `openrouter/${model}` : model;
+    const routeProvider = normalizedModel === 'openrouter/z-ai/glm-5.3' ? 'openrouter' : configuredProvider;
+    let provider: ReturnType<typeof getProvider> | undefined;
+    try {
+      if (routeProvider) {
+        const config = getUserConfig();
+        provider = getProviderForConfig({ ...config, llm: { ...config.llm, provider: routeProvider as typeof config.llm.provider } }, normalizedModel);
+      } else if (inferProviderFromModel(normalizedModel)) {
+        provider = getProvider(normalizedModel);
+      }
+    } catch {
+      // An unavailable or unsupported configured primary must not prevent the existing fallback attempt.
+    }
+    return { model: normalizedModel, provider, label };
+  };
+  const primaryProviderIsPinned = reviewRole.source === 'flag' || reviewRole.source === 'config-role'
+    || reviewRole.source === 'environment';
+  const configuredPrimaryProvider = primaryProviderIsPinned ? reviewRole.provider : undefined;
+  const primaryReviewAttempt = reviewAttemptForModel(reviewModel, 'primary', configuredPrimaryProvider);
   const reviewAttempts = buildReviewProviderAttempts(
     primaryReviewAttempt,
     [...reviewFallbackModels, defaultReviewFallbackModel(primaryReviewAttempt.provider?.name)]