elanous 0.2.18 → 0.2.20

package/src/self-implement/gate-env-retry.ts

@@ -0,0 +1,83 @@
+// ── GATE-ENV-RETRY (0.2.20 P1) — 환경 결손 gate 실패는 «게이트만» 다시 돈다 ─────────────
+//
+// S: 하니스 후반 gate 가 «환경 결손»(시험 결과 미수신 · git index.lock 경합 · tsc 힙 OOM ·
+//    「측정 불가」 · 네트워크/레지스트리 타임아웃)을 자식 실패와 같은 칸으로 받아,
+//    재작업 없이 `abandoned` 로 런을 끝냈다.
+// C: 📏 10-06 — TASK-AGENT 런 PR #24438 «test-result-unavailable · escalating without rework» ·
+//    NESTEDGUARD3 baseline index.lock 경합 · tsc 힙 OOM «could not measure».
+//    구현은 멀쩡한데 «잰 쪽»이 넘어졌고, 그 구현이 버려진 칸으로 셌다.
+// Q: 구현을 버리지 않고 잴 수 있나?
+// A: ⓐ 이 판정자가 «환경 결손»이라 말하면 짧게 쉬고 gate «만» 다시 돈다(기본 2회).
+//    ⓑ 그래도 결손이면 브랜치·PR 을 남기고 `harvestable` 로 끝낸다(「버림」이 아니라 「수확 대기」).
+//
+// ⛔ 틀리는 방향이 비대칭이다(`self-dev/execution-transient.ts` 와 같은 계산):
+//    도입 실패를 「환경」으로 부르면 → 자식 결손이 재작업 없이 수확 칸으로 빠진다.
+//    ⇒ `introduced > 0` 또는 자식 책임이 «있음»이면 무조건 거짓. 어휘는 좁게 둔다.
+// ⛔ `budget-exceeded`·`module-load-error` 는 넣지 않는다 — 다시 재도 같은 값이 나온다.
+
+/** 환경 결손의 종류 — 관측(로그)과 PR 문면에 그대로 실린다. */
+export type GateEnvDeficitKind =
+  | 'test-result-unavailable'
+  | 'infrastructure-failure'
+  | 'git-lock'
+  | 'out-of-memory'
+  | 'unmeasured'
+  | 'network-timeout';
+
+export type GateEnvDeficitVerdict =
+  | { readonly envDeficit: true; readonly kind: GateEnvDeficitKind }
+  | { readonly envDeficit: false; readonly reason: 'passed' | 'introduced' | 'child-responsible' | 'non-retryable-reason' | 'no-env-signal' };
+
+export interface GateEnvDeficitInput {
+  readonly passed: boolean;
+  readonly log?: string;
+  readonly reflectGateFacts?: {
+    readonly introduced?: number;
+    readonly unknownReason?: string;
+    readonly childResponsibility?: string;
+  };
+}
+
+/** unknownReason 중 «다시 재면 풀릴 수 있는» 것만. */
+const RETRYABLE_UNKNOWN_REASONS: ReadonlySet<string> = new Set(['test-result-unavailable', 'infrastructure-failure']);
+
+/** unknownReason 중 «다시 재도 같은 값이 나오는» 것 — 로그에 환경 어휘가 섞여 있어도 이 사유가 이긴다. */
+const NON_RETRYABLE_UNKNOWN_REASONS: ReadonlySet<string> = new Set(['budget-exceeded', 'module-load-error']);
+
+/** 로그 어휘 — ⛔ 좁게(위 비대칭). 순서가 곧 우선순위. */
+const LOG_PATTERNS: ReadonlyArray<readonly [GateEnvDeficitKind, RegExp]> = [
+  ['git-lock', /index\.lock|another git process seems to be running|cannot lock ref/i],
+  ['out-of-memory', /javascript heap out of memory|heap out of memory|oomkilled|fatal error: .*allocation failed/i],
+  ['unmeasured', /could not measure|측정 불가/i],
+  ['network-timeout', /\b(?:ETIMEDOUT|ECONNRESET|EAI_AGAIN|ENOTFOUND)\b|registry\.npmjs\.org.*(?:timeout|timed out)|network timeout|socket hang up/i],
+];
+
+/**
+ * 순수: 실패한 gate 결과가 «환경 결손»인가를 판정한다.
+ * ⛔ 도입 실패(`introduced > 0`)·자식 책임 있음은 언제나 거짓 — 그 동작은 바꾸지 않는다.
+ */
+export function classifyGateEnvDeficit(gate: GateEnvDeficitInput): GateEnvDeficitVerdict {
+  if (gate.passed) return { envDeficit: false, reason: 'passed' };
+  const facts = gate.reflectGateFacts;
+  if ((facts?.introduced ?? 0) > 0) return { envDeficit: false, reason: 'introduced' };
+  if (facts?.childResponsibility !== undefined && facts.childResponsibility !== 'none') {
+    return { envDeficit: false, reason: 'child-responsible' };
+  }
+  if (facts?.unknownReason !== undefined && NON_RETRYABLE_UNKNOWN_REASONS.has(facts.unknownReason)) {
+    return { envDeficit: false, reason: 'non-retryable-reason' };
+  }
+  if (facts?.unknownReason !== undefined && RETRYABLE_UNKNOWN_REASONS.has(facts.unknownReason)) {
+    return { envDeficit: true, kind: facts.unknownReason as GateEnvDeficitKind };
+  }
+  const log = gate.log ?? '';
+  for (const [kind, pattern] of LOG_PATTERNS) {
+    if (pattern.test(log)) return { envDeficit: true, kind };
+  }
+  return { envDeficit: false, reason: 'no-env-signal' };
+}
+
+/** 기본 재시도 정책 — 짧게 쉬고 gate 만 최대 2회. */
+export const DEFAULT_GATE_ENV_RETRY = { attempts: 2, delayMs: 20_000 } as const;
+
+/** 수확 대기로 남길 때 PR·종료 사유에 싣는 표지. */
+export const GATE_ENV_DEFICIT_HARVESTABLE_MARK = 'env-deficit, harvestable';

package/src/self-implement/goal-author-clarification.ts

@@ -1,3 +1,6 @@
+import { readFileSync, realpathSync } from 'node:fs';
+import { resolve, relative, isAbsolute } from 'node:path';
+import ts from 'typescript';
 import { tierModel } from '../llm/model-defaults.js';
 import { debug } from '../debug/log.js';
 import type { LLMUsage } from '../prompt-cache/types.js';
@@ -42,7 +45,7 @@ export function parseGoalAuthorParent(document: string): GoalAuthorParent | null
   return matches.length === 1 ? matches[0] : null;
 }
 
-export type GoalAuthorClarificationAnswerSource = 'injected' | 'recommended' | 'self-authored';
+export type GoalAuthorClarificationAnswerSource = 'injected' | 'recommended' | 'self-authored' | 'default';
 
 export interface GoalAuthorClarificationProvenance {
   source: GoalAuthorClarificationAnswerSource;
@@ -78,8 +81,8 @@ export interface GoalAuthorSelfResolutionContext {
 }
 
 export type GoalAuthorSelfResolution =
-  | { answer: string; evidence: readonly string[] }
-  | { answer?: undefined; evidence?: undefined };
+  | { answer: string; evidence: readonly string[]; declined?: undefined }
+  | { answer?: undefined; evidence?: undefined; declined?: boolean };
 
 export interface GoalAuthorClarificationResolutionDeps {
   /** Elanousic authoring seam; it must return no answer when the available evidence is insufficient. */
@@ -189,7 +192,7 @@ export async function defaultGoalAuthorSelfResolve(
   const usages: LLMUsage[] = [];
   if (context.evidence.length === 0) {
     observeSelfResolve('self-resolve-no-evidence', context, startedAt, { usage: deriveUsage(usages) });
-    return {};
+    return context.questionId === 'preservation_contract' ? { declined: true } : {};
   }
   const controller = new AbortController();
   const timeout = setTimeout(
@@ -230,7 +233,7 @@ export async function defaultGoalAuthorSelfResolve(
       evidenceCount: context.evidence.length,
       usage: deriveUsage(usages),
     });
-    return {};
+    return answer === null && context.questionId === 'preservation_contract' ? { declined: true } : {};
   } catch (error) {
     observeSelfResolve(
       isSelfResolutionTimeout(error, controller.signal) ? 'self-resolve-timeout' : 'self-resolve-error',
@@ -471,6 +474,57 @@ interface GoalAuthorClarificationSeed {
   parent: GoalAuthorParent;
 }
 
+const PRESERVATION_DEFAULT = '대상 경로의 기존 공개 동작(내보내는 함수 시그니처 · CLI 인자·출력·종료 코드)은 그대로 유지한다 · 바뀌는 것은 골이 명시한 동작뿐';
+
+function preservationDefault(ask: string): { answer: string; exportCount: number } {
+  const request = /Original ask \(verbatim, unmodified\):\s*```\r?\n([\s\S]*?)\r?\n```/.exec(ask)?.[1] ?? ask;
+  // Every `대상 경로:` line counts, plain or as a Markdown list item; backticks around a path are cosmetic.
+  const paths = [...new Set(request.split(/\r?\n/).flatMap((line) => {
+    const match = /^\s*(?:(?:[-*+]|\d+[.)])\s+)?대상 경로:\s*(.*)$/.exec(line);
+    return match ? match[1].split(/\s*[,·]\s*/).map((path) => path.trim().replace(/^`|`$/g, '')) : [];
+  }))];
+  const exports: string[] = [];
+  for (const path of paths) {
+    if (!/^[\w./-]+\.[cm]?[jt]sx?$/.test(path) || path.startsWith('/') || path.split('/').includes('..')) continue;
+    const absolute = resolve(process.cwd(), path);
+    try {
+      const actual = realpathSync(absolute);
+      const withinRepo = relative(realpathSync(process.cwd()), actual);
+      if (withinRepo === '..' || withinRepo.startsWith('../') || isAbsolute(withinRepo)) continue;
+      const source = ts.createSourceFile(path, readFileSync(actual, 'utf8'), ts.ScriptTarget.Latest, true);
+      for (const statement of source.statements) {
+        if (ts.isExportDeclaration(statement)) {
+          if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+            for (const element of statement.exportClause.elements) exports.push(`${path}: ${element.name.text}`);
+          } else if (statement.exportClause && ts.isNamespaceExport(statement.exportClause)) {
+            exports.push(`${path}: ${statement.exportClause.name.text}`);
+          } else if (!statement.exportClause && statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)) {
+            // Names re-exported by `export *` are not resolved here; record the re-export itself so the preserved surface is explicit.
+            exports.push(`${path}: * from ${statement.moduleSpecifier.text}`);
+          }
+        } else if (ts.isExportAssignment(statement)) {
+          exports.push(`${path}: ${statement.isExportEquals ? 'export =' : 'default'}`);
+        } else if (ts.canHaveModifiers(statement) && ts.getModifiers(statement)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
+          if (ts.getModifiers(statement)?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword)) {
+            exports.push(`${path}: default`);
+          } else if (ts.isVariableStatement(statement)) {
+            const bindingNames = (name: ts.BindingName): string[] => ts.isIdentifier(name)
+              ? [name.text]
+              : name.elements.flatMap((element) => ts.isOmittedExpression(element) ? [] : bindingNames(element.name));
+            for (const declaration of statement.declarationList.declarations) {
+              for (const exported of bindingNames(declaration.name)) exports.push(`${path}: ${exported}`);
+            }
+          } else if ('name' in statement && statement.name && ts.isIdentifier(statement.name as ts.Node)) {
+            exports.push(`${path}: ${(statement.name as ts.Identifier).text}`);
+          }
+        }
+      }
+    } catch { /* An unavailable target cannot supply verified export names. */ }
+  }
+  const names = [...new Set(exports)];
+  return { answer: names.length ? `${PRESERVATION_DEFAULT} · export 이름: ${names.join(', ')}` : PRESERVATION_DEFAULT, exportCount: names.length };
+}
+
 const DEFERRED_ANSWER = 'DEFERRED-UNTIL: ';
 const DEFERRED_ANSWER_PREFIX = 'DEFERRED-UNTIL';
 
@@ -515,7 +569,7 @@ export function parseGoalDocumentClarifications(document: string): GoalDocumentC
         readingOptions = false;
         continue;
       }
-      const provenanceSource = /^  - provenance\.source: (injected|recommended|self-authored)$/.exec(line);
+      const provenanceSource = /^  - provenance\.source: (injected|recommended|self-authored|default)$/.exec(line);
       if (provenanceSource) {
         fields.set('provenanceSource', provenanceSource[1]);
         provenanceLines.push(index);
@@ -692,6 +746,7 @@ export async function selfAnswerGoalDocumentClarifications(
     ask?: string;
     evidence?: readonly string[];
     resolver?: GoalClarificationSelfResolver;
+    runId?: string;
   },
 ): Promise<{ document: string; asked: number; answered: number; unanswered: number; newlyAnswered: number }> {
   const clarifications = parseGoalDocumentClarifications(document);
@@ -699,7 +754,7 @@ export async function selfAnswerGoalDocumentClarifications(
   // The first say pass may already have self-answered some questions while authoring: count those,
   // never re-ask them, and still attempt every question that is left unanswered.
   const alreadySelfAnswered = options.path === 'say-first'
-    ? clarifications.filter((item) => item.answered && item.provenanceSource === 'self-authored').length
+    ? clarifications.filter((item) => item.answered && (item.provenanceSource === 'self-authored' || item.provenanceSource === 'default')).length
     : 0;
   let updated = document;
   let answered = 0;
@@ -709,6 +764,7 @@ export async function selfAnswerGoalDocumentClarifications(
   for (const item of pending) {
     if (parseGoalDocumentClarifications(updated).filter((entry) => entry.questionId === item.questionId).length !== 1) continue;
     let response: Awaited<ReturnType<typeof resolveGoalAuthorClarification>>;
+    let declined = false;
     try { response = await resolveGoalAuthorClarification({
       questionId: item.questionId,
       kind: 'scope',
@@ -717,7 +773,11 @@ export async function selfAnswerGoalDocumentClarifications(
       options: item.options.map((option) => ({ label: option.label, description: option.description })),
       blocking: false,
     }, {
-      selfResolve: options.resolver ?? defaultGoalAuthorSelfResolve,
+      selfResolve: async (context) => {
+        const resolution = await (options.resolver ?? defaultGoalAuthorSelfResolve)(context);
+        declined = resolution.declined === true;
+        return resolution;
+      },
       evidence,
       ask: options.ask,
       selfResolutionSelected: true,
@@ -725,11 +785,19 @@ export async function selfAnswerGoalDocumentClarifications(
       // A resolver failure leaves this question unanswered; the remaining questions are still attempted.
       continue;
     }
-    if (response.answer === null || response.provenance?.source !== 'self-authored'
+    let defaultExportCount: number | undefined;
+    if (response.answer === null && item.questionId === 'preservation_contract'
+      && declined) {
+      const fallback = preservationDefault(options.ask ?? document);
+      response = { ...response, answer: fallback.answer, status: 'ANSWERED', provenance: { source: 'default' } };
+      defaultExportCount = fallback.exportCount;
+    }
+    if (response.answer === null || (response.provenance?.source !== 'self-authored' && response.provenance?.source !== 'default')
       || response.answer.startsWith(DEFERRED_ANSWER_PREFIX)) continue;
+    const answerSource = response.provenance.source;
     try {
       if (!response.answer.trim() || /[\r\n]/.test(response.answer)
-        || (!item.includeOther && !item.options.some((option) => option.label === response.answer))) continue;
+        || (answerSource !== 'default' && !item.includeOther && !item.options.some((option) => option.label === response.answer))) continue;
       const current = findUnansweredGoalDocumentClarification(updated, item.questionId);
       const lines = updated.split(/\r?\n/);
       const provenanceLines = current.provenanceLines ?? [];
@@ -737,15 +805,22 @@ export async function selfAnswerGoalDocumentClarifications(
       const answerLine = current.answerLine - provenanceLines.filter((line) => line < current.answerLine).length;
       lines[answerLine] = `  - answer: ${response.answer}`;
       lines.splice(answerLine + 1, 0,
-        '  - provenance.source: self-authored',
-        ...response.provenance.evidence!.map((entry) => `  - evidence: ${entry.replace(/[\r\n]/g, ' ')}`));
+        `  - provenance.source: ${answerSource}`,
+        ...(response.provenance.evidence ?? []).map((entry) => `  - evidence: ${entry.replace(/[\r\n]/g, ' ')}`));
       updateWhatToBuildRenderAnswers(lines, item.questionId, response.answer);
       if (hasWhatToBuildUnansweredRenderAnswer(lines, item.questionId)) continue;
       const candidate = lines.join(document.includes('\r\n') ? '\r\n' : '\n');
       if (!parseGoalDocumentClarifications(candidate).some((entry) => entry.questionId === item.questionId
-        && entry.answered && entry.answer === response.answer && entry.provenanceSource === 'self-authored')) continue;
+        && entry.answered && entry.answer === response.answer && entry.provenanceSource === answerSource)) continue;
       updated = candidate;
       answered += 1;
+      if (defaultExportCount !== undefined) {
+        observeGoalAuthor('goal-author', 'self-answer-default-applied', {
+          runId: options.runId ?? process.env.ELANOUS_RUN_ID,
+          questionId: item.questionId,
+          exportCount: defaultExportCount,
+        });
+      }
     } catch {
       // Leave malformed or disallowed answers deferred.
     }

package/src/self-implement/goal-clarification-escalation.ts

@@ -39,6 +39,7 @@ type GoalClarificationAnsweredBy = 'human' | 'agent' | 'none' | 'mixed';
 
 export interface GoalClarificationEscalationInput {
   goalFile: string;
+  runId?: string;
   /** Explicit provenance for isolated test fixtures; never inferred from goalFile. */
   testOrigin?: true;
   delivery?: GoalClarificationDelivery;
@@ -443,6 +444,7 @@ export async function escalateGoalDocumentClarifications(
         path: input.selfAnswerPath,
         ask: document,
         resolver: input.selfResolveClarification,
+        runId: input.runId ?? process.env.ELANOUS_RUN_ID,
       });
       if (resolution.newlyAnswered > 0) {
         writeGoalDocumentAtomic(input.goalFile, resolution.document);