elanous 0.2.37 → 0.2.40

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

@@ -50,6 +50,8 @@ export type GoalAuthorClarificationAnswerSource = 'injected' | 'recommended' | '
 export interface GoalAuthorClarificationProvenance {
   source: GoalAuthorClarificationAnswerSource;
   evidence?: string[];
+  assumption?: string;
+  assumptionSource?: 'resolver' | 'policy-default' | 'recommended';
 }
 
 export interface GoalAuthorClarificationResponse {
@@ -81,7 +83,7 @@ export interface GoalAuthorSelfResolutionContext {
 }
 
 export type GoalAuthorSelfResolution =
-  | { answer: string; evidence: readonly string[]; declined?: undefined }
+  | { answer: string; evidence: readonly string[]; assumption?: string; declined?: undefined }
   | { answer?: undefined; evidence?: undefined; declined?: boolean };
 
 export interface GoalAuthorClarificationResolutionDeps {
@@ -125,8 +127,8 @@ function truncateAsk(ask: string): string {
 function selfResolutionPrompt(context: GoalAuthorSelfResolutionContext): string {
   return [
     'Answer this goal-author clarification using only the supplied repository evidence.',
-    'Do not delegate to an implementation agent. If the evidence cannot justify one single-line answer, return {"answer":null}.',
-    'Return JSON only: {"answer":"..."} or {"answer":null}.',
+    'Do not delegate to an implementation agent. Choose the best supported candidate and state the assumption that makes it the best fit. If the evidence cannot justify one answer, return {"answer":null}.',
+    'Return JSON only: {"answer":"...","assumption":"..."} or {"answer":null}.',
     ...(context.ask?.trim() ? [`Request being authored:\n${truncateAsk(context.ask.trim())}`] : []),
     `Question: ${context.question}`,
     `Options: ${context.options.join(' | ') || '(free input)'}`,
@@ -195,22 +197,31 @@ export async function defaultGoalAuthorSelfResolve(
     return context.questionId === 'preservation_contract' ? { declined: true } : {};
   }
   const controller = new AbortController();
+  const prompt = selfResolutionPrompt(context);
+  let rejectTimeout!: (reason: Error) => void;
+  const timeoutPromise = new Promise<never>((_, reject) => { rejectTimeout = reject; });
   const timeout = setTimeout(
-    () => controller.abort(new Error(SELF_RESOLUTION_TIMEOUT_MESSAGE)),
+    () => {
+      const error = new Error(SELF_RESOLUTION_TIMEOUT_MESSAGE);
+      controller.abort(error);
+      rejectTimeout(error);
+    },
     selfResolutionTimeoutMs(deps.timeoutMs),
   );
-  const prompt = selfResolutionPrompt(context);
   const onUsage = (usage: LLMUsage) => { usages.push(usage); };
   try {
-    const result = await (deps.stream ?? (async (input, signal, reportUsage) => {
-      const { streamLLM } = await import('../llm.js');
-      return streamLLM([{ role: 'user', content: input }], () => {}, {
-        model: process.env.ELANOUS_GOAL_AUTHOR_MODEL || tierModel('better'),
-        reasoningEffort: 'high',
-        signal,
-        onUsage: reportUsage,
-      });
-    }))(prompt, controller.signal, onUsage);
+    const result = await Promise.race([
+      (deps.stream ?? (async (input, signal, reportUsage) => {
+        const { streamLLM } = await import('../llm.js');
+        return streamLLM([{ role: 'user', content: input }], () => {}, {
+          model: process.env.ELANOUS_GOAL_AUTHOR_MODEL || tierModel('better'),
+          reasoningEffort: 'high',
+          signal,
+          onUsage: reportUsage,
+        });
+      }))(prompt, controller.signal, onUsage),
+      timeoutPromise,
+    ]);
     let parsed: unknown;
     try {
       parsed = JSON.parse(result);
@@ -222,11 +233,15 @@ export async function defaultGoalAuthorSelfResolve(
       ? (parsed as { answer?: unknown }).answer
       : undefined;
     if (typeof answer === 'string') {
+      const assumptionValue = (parsed as { assumption?: unknown }).assumption;
+      const assumption = typeof assumptionValue === 'string' && assumptionValue.trim()
+        ? assumptionValue.trim()
+        : undefined;
       observeSelfResolve('self-resolve-answered', context, startedAt, {
         answerLength: answer.length,
         usage: deriveUsage(usages),
       });
-      return { answer, evidence: context.evidence };
+      return { answer, evidence: context.evidence, ...(assumption ? { assumption } : {}) };
     }
     observeSelfResolve('self-resolve-unanswered', context, startedAt, {
       reason: answer === null ? 'declined' : 'shape-mismatch',
@@ -281,7 +296,11 @@ function responseFor(clarification: IntakeClarification, observe = false, selfRe
     ...deferredResponse(clarification),
     answer: automaticAnswer,
     status: 'ANSWERED',
-    provenance: { source: 'recommended' },
+    provenance: {
+      source: 'recommended',
+      assumption: '저작기가 표시한 단일 recommended 후보를 우선 선택하는 정책을 적용한다',
+      assumptionSource: 'recommended',
+    },
   };
 }
 
@@ -331,11 +350,17 @@ export async function resolveGoalAuthorClarification(
     if (!answer || /[\r\n]/.test(answer) || evidence.length === 0) {
       return deterministic;
     }
+    const resolverAssumption = 'assumption' in resolution ? resolution.assumption?.trim() : undefined;
+    const assumption = resolverAssumption
+      || `정책 가정(resolver가 별도 가정을 생략함): 제공 근거와 요청에 가장 맞는 후보를 선택한다 (${answer})`;
     const response: GoalAuthorClarificationResponse = {
       ...deferredResponse(clarification),
       answer,
       status: 'ANSWERED',
-      provenance: { source: 'self-authored', evidence },
+      provenance: {
+        source: 'self-authored', evidence, assumption,
+        assumptionSource: resolverAssumption ? 'resolver' : 'policy-default',
+      },
     };
     observeGoalAuthor('goal-author.clarify', 'self-answered', {
       questionId: clarification.questionId,
@@ -407,31 +432,58 @@ function parseRecord(raw: string): SerializedGoalAuthorClarification | null {
       && Array.isArray(provenance.evidence)
       && provenance.evidence.length > 0
       && provenance.evidence.every((item) => typeof item === 'string' && item.length > 0);
+    const selfAuthoredAssumption = typeof provenance?.assumption === 'string' && provenance.assumption.trim()
+      ? provenance.assumption.trim()
+      : undefined;
     const response = isSelfAuthored
       ? {
         ...deferredResponse(value.clarification),
         answer: value.response.answer!,
         status: 'ANSWERED' as const,
-        provenance: { source: 'self-authored' as const, evidence: provenance.evidence },
+        provenance: {
+          source: 'self-authored' as const,
+          evidence: provenance.evidence,
+          ...(selfAuthoredAssumption ? { assumption: selfAuthoredAssumption } : {}),
+          ...(provenance.assumptionSource === 'resolver' || provenance.assumptionSource === 'policy-default'
+            ? { assumptionSource: provenance.assumptionSource }
+            : {}),
+        },
       }
       : expected;
     const responseProvenance = response.provenance;
     const serializedProvenance = value.response.provenance;
     const expectedProvenanceKeys = responseProvenance === undefined
       ? []
-      : responseProvenance.evidence === undefined ? ['source'] : ['evidence', 'source'];
+      : [
+        ...(responseProvenance.assumption === undefined ? [] : ['assumption']),
+        ...(responseProvenance.assumptionSource === undefined ? [] : ['assumptionSource']),
+        ...(responseProvenance.evidence === undefined ? [] : ['evidence']),
+        'source',
+      ];
     const serializedProvenanceKeys = serializedProvenance === undefined
       ? []
       : Object.keys(serializedProvenance).sort();
+    // Older serialized goal rows predate assumption provenance. Keep accepting those rows while
+    // still validating every field they actually contain; parsing upgrades them to the current
+    // deterministic response shape above.
+    const legacyAssumptionKeys = responseProvenance?.source === 'recommended'
+      ? ['assumption', 'assumptionSource']
+      : [];
+    const provenanceKeysMatch = (serializedProvenanceKeys.length === expectedProvenanceKeys.length
+      && expectedProvenanceKeys.every((key) => serializedProvenanceKeys.includes(key)))
+      || (legacyAssumptionKeys.length > 0
+        && expectedProvenanceKeys.filter((key) => !legacyAssumptionKeys.includes(key)).every((key) => serializedProvenanceKeys.includes(key))
+        && serializedProvenanceKeys.every((key) => expectedProvenanceKeys.includes(key)));
     const provenanceMatches = (serializedProvenance === undefined) === (responseProvenance === undefined)
-      && serializedProvenanceKeys.length === expectedProvenanceKeys.length
-      && serializedProvenanceKeys.every((key, index) => key === expectedProvenanceKeys[index])
+      && provenanceKeysMatch
       && serializedProvenance?.source === responseProvenance?.source
       && (responseProvenance?.evidence === undefined
         ? serializedProvenance?.evidence === undefined
         : Array.isArray(serializedProvenance?.evidence)
           && serializedProvenance.evidence.length === responseProvenance.evidence.length
-          && serializedProvenance.evidence.every((item, index) => item === responseProvenance.evidence?.[index]));
+          && serializedProvenance.evidence.every((item, index) => item === responseProvenance.evidence?.[index]))
+      && (serializedProvenance?.assumption === undefined || serializedProvenance.assumption === responseProvenance?.assumption)
+      && (serializedProvenance?.assumptionSource === undefined || serializedProvenance.assumptionSource === responseProvenance?.assumptionSource);
     if (value.response.questionId !== response.questionId
       || value.response.answer !== response.answer
       || value.response.status !== response.status
@@ -469,6 +521,21 @@ export interface GoalDocumentClarification {
   provenanceLines?: number[];
 }
 
+export type GoalClarificationDecisionCategory = 'money' | 'security' | 'irreversible';
+
+/** Only questions that could authorize money, security, or irreversible external effects need a decision card. */
+export function goalClarificationDecisionCategory(
+  clarification: Pick<GoalDocumentClarification, 'header' | 'question' | 'options'>,
+): GoalClarificationDecisionCategory | undefined {
+  const text = [clarification.header, clarification.question, ...clarification.options.flatMap((option) => [option.label, option.description])]
+    .join(' ')
+    .toLocaleLowerCase();
+  if (/\b(payment|purchase|spend|budget|credit|charge|price|cost|paid)\b|결제|구매|지출|예산|크레딧|과금|가격|비용/.test(text)) return 'money';
+  if (/\b(security|credential|token|secret|password|authorization|authentication|permission|access control)\b|보안|자격 증명|토큰|비밀키|비밀번호|인가|인증|권한/.test(text)) return 'security';
+  if (/\b(publish|publication|deploy|send|delete|release|irreversible|external side effect|production)\b|발행|게시|배포|전송|삭제|릴리스|되돌릴 수 없|외부 효과|운영 환경/.test(text)) return 'irreversible';
+  return undefined;
+}
+
 interface GoalAuthorClarificationSeed {
   ask: string;
   parent: GoalAuthorParent;
@@ -576,6 +643,17 @@ export function parseGoalDocumentClarifications(document: string): GoalDocumentC
         readingOptions = false;
         continue;
       }
+      const provenanceAssumption = /^  - provenance\.assumption: (.*)$/.exec(line);
+      if (provenanceAssumption) {
+        provenanceLines.push(index);
+        readingOptions = false;
+        continue;
+      }
+      if (/^  - provenance\.assumption-source: (resolver|policy-default|recommended)$/.test(line)) {
+        provenanceLines.push(index);
+        readingOptions = false;
+        continue;
+      }
       if (/^  - evidence: /.test(line)) {
         provenanceLines.push(index);
         readingOptions = false;
@@ -747,6 +825,7 @@ export async function selfAnswerGoalDocumentClarifications(
     evidence?: readonly string[];
     resolver?: GoalClarificationSelfResolver;
     runId?: string;
+    skipQuestionIds?: ReadonlySet<string>;
   },
 ): Promise<{ document: string; asked: number; answered: number; unanswered: number; newlyAnswered: number }> {
   const clarifications = parseGoalDocumentClarifications(document);
@@ -761,7 +840,7 @@ export async function selfAnswerGoalDocumentClarifications(
   const evidence = options.evidence ?? document.split(/\r?\n/)
     .filter((line) => /^(?:\s*- (?:\[code:|\[document:|TRACED PATHS|evidence:|Evidence:)|\s*-?\s*`?(?:src|test|scripts)\/[^\s`]+:\d+)/i.test(line))
     .slice(0, 40);
-  for (const item of pending) {
+  for (const item of pending.filter((entry) => !options.skipQuestionIds?.has(entry.questionId))) {
     if (parseGoalDocumentClarifications(updated).filter((entry) => entry.questionId === item.questionId).length !== 1) continue;
     let response: Awaited<ReturnType<typeof resolveGoalAuthorClarification>>;
     let declined = false;
@@ -789,7 +868,9 @@ export async function selfAnswerGoalDocumentClarifications(
     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' } };
+      response = { ...response, answer: fallback.answer, status: 'ANSWERED', provenance: {
+        source: 'default', assumption: '기존 공개 동작 보존을 기본 가정으로 적용한다', assumptionSource: 'policy-default',
+      } };
       defaultExportCount = fallback.exportCount;
     }
     if (response.answer === null || (response.provenance?.source !== 'self-authored' && response.provenance?.source !== 'default')
@@ -806,6 +887,8 @@ export async function selfAnswerGoalDocumentClarifications(
       lines[answerLine] = `  - answer: ${response.answer}`;
       lines.splice(answerLine + 1, 0,
         `  - provenance.source: ${answerSource}`,
+        ...(response.provenance.assumption ? [`  - provenance.assumption: ${response.provenance.assumption.replace(/[\r\n]/g, ' ')}`] : []),
+        ...(response.provenance.assumptionSource ? [`  - provenance.assumption-source: ${response.provenance.assumptionSource}`] : []),
         ...(response.provenance.evidence ?? []).map((entry) => `  - evidence: ${entry.replace(/[\r\n]/g, ' ')}`));
       updateWhatToBuildRenderAnswers(lines, item.questionId, response.answer);
       if (hasWhatToBuildUnansweredRenderAnswer(lines, item.questionId)) continue;
@@ -836,6 +919,77 @@ export async function selfAnswerGoalDocumentClarifications(
   return { document: updated, asked, answered, unanswered, newlyAnswered };
 }
 
+/** SelfImplement boundary: resolve pending questions itself and record a bounded policy assumption if that fails.
+ *  Interactive callers must not turn an authoring clarification into a human popup. */
+export async function selfAnswerOrAssumeGoalDocumentClarifications(
+  document: string,
+  options: Parameters<typeof selfAnswerGoalDocumentClarifications>[1],
+): Promise<Awaited<ReturnType<typeof selfAnswerGoalDocumentClarifications>> & {
+  assumed: number;
+  decisionRequired: Array<{ questionId: string; header: string; question: string; category: GoalClarificationDecisionCategory }>;
+}> {
+  const safetyQuestions = parseGoalDocumentClarifications(document).filter((entry) => !entry.answered)
+    .map((entry) => ({ entry, category: goalClarificationDecisionCategory(entry) }))
+    .filter((item): item is { entry: GoalDocumentClarification; category: GoalClarificationDecisionCategory } => item.category !== undefined);
+  const attempted = await selfAnswerGoalDocumentClarifications(document, {
+    ...options,
+    skipQuestionIds: new Set(safetyQuestions.map((item) => item.entry.questionId)),
+  });
+  let updated = attempted.document;
+  let assumed = 0;
+  const decisionRequired: Array<{ questionId: string; header: string; question: string; category: GoalClarificationDecisionCategory }> =
+    safetyQuestions.map(({ entry, category }) => ({ questionId: entry.questionId, header: entry.header, question: entry.question, category }));
+  for (const item of parseGoalDocumentClarifications(updated).filter((entry) => !entry.answered)) {
+    const category = goalClarificationDecisionCategory(item);
+    if (category) continue;
+    const offered = item.options.filter((option) => option.label.trim() && !/[\r\n]/.test(option.label));
+    const useOfferedOption = !item.includeOther && offered.length > 0;
+    const answer = useOfferedOption
+      ? offered[0]!.label.trim()
+      : '근거가 부족하므로 요청에 명시된 범위만 진행한다고 가정한다';
+    const assumption = useOfferedOption
+      ? '자가 해소가 답을 내지 못해 자유 답변 없이 제시된 첫 후보를 정책 가정으로 선택했다'
+      : '자가 해소가 답을 내지 못해 추가 범위를 만들지 않고 요청에 명시된 범위만 진행한다고 가정했다';
+    try {
+      const current = findUnansweredGoalDocumentClarification(updated, item.questionId);
+      const lines = updated.split(/\r?\n/);
+      const provenanceLines = current.provenanceLines ?? [];
+      for (const line of [...provenanceLines].sort((left, right) => right - left)) lines.splice(line, 1);
+      const answerLine = current.answerLine - provenanceLines.filter((line) => line < current.answerLine).length;
+      lines[answerLine] = `  - answer: ${answer}`;
+      lines.splice(answerLine + 1, 0,
+        '  - provenance.source: default',
+        `  - provenance.assumption: ${assumption}`,
+        '  - provenance.assumption-source: policy-default',
+      );
+      updateWhatToBuildRenderAnswers(lines, item.questionId, answer);
+      if (hasWhatToBuildUnansweredRenderAnswer(lines, item.questionId)) continue;
+      const candidate = lines.join(updated.includes('\r\n') ? '\r\n' : '\n');
+      if (!parseGoalDocumentClarifications(candidate).some((entry) => entry.questionId === item.questionId
+        && entry.answered && entry.answer === answer && entry.provenanceSource === 'default')) continue;
+      updated = candidate;
+      assumed += 1;
+      observeGoalAuthor('goal-author.clarify', 'self-answer-assumed', {
+        runId: options.runId ?? process.env.ELANOUS_RUN_ID,
+        questionId: item.questionId,
+        assumptionSource: 'policy-default',
+        selectedOfferedOption: useOfferedOption,
+      });
+    } catch {
+      // Keep the pending question visible to the caller as a no-launch reason; never dispatch it to a popup.
+    }
+  }
+  return {
+    ...attempted,
+    document: updated,
+    answered: attempted.answered + assumed,
+    unanswered: Math.max(0, attempted.unanswered - assumed),
+    newlyAnswered: attempted.newlyAnswered + assumed,
+    assumed,
+    decisionRequired,
+  };
+}
+
 
 export type ClarificationIntakeMode = 'none' | 'deferred-noninteractive' | 'ask';
 

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

@@ -471,6 +471,7 @@ export function createGoalAuthorDecomposeSteps(
   config: {
     adversarialReview?: boolean;
     adversarialReviewSource?: 'cli' | 'default' | 'unknown';
+    goalId?: string;
     recentStepCounts?: readonly number[];
     onSizedSlices?: (slices: SizedSlice[], redecomposed: number) => void;
     repositoryRoot?: string;
@@ -589,38 +590,46 @@ export function createGoalAuthorDecomposeSteps(
         return parsed ? { sizes: parsed, sizeSource: 'planner-estimate' as const }
           : { sizes: deriveGoalSliceSizes(slices), sizeSource: 'derived' as const };
       };
-      const observe = (event: 'slice-sized' | 'slice-oversize', sizeSource: 'planner-estimate' | 'derived', data: Record<string, unknown>) => {
+      const observe = (event: 'slice-sized' | 'slice-oversize' | 'resplit' | 'slice-oversize-unavoidable', sizeSource: 'planner-estimate' | 'derived', data: Record<string, unknown>) => {
         try { debug.log('goal-author.decompose', event, { surface: 'goal-author', sizeSource, ...data,
           ...(options?.runId === undefined ? {} : { runId: options.runId }) }); } catch { /* observation is fail-soft */ }
       };
       let redecomposed = 0;
       let measured = await measure(candidate);
       let sizes = measured.sizes;
-      if (sizes) observe('slice-sized', measured.sizeSource, { retry: 0, slices: sizes });
-      const oversized = sizes?.flatMap((size, index) => size.tier === 'high' ? [index] : []) ?? [];
-      if (oversized.length || !sizes) {
-        observe('slice-oversize', measured.sizeSource, { retry: 0, indexes: oversized,
+      for (let retry = 0; ; retry++) {
+        if (sizes) observe('slice-sized', measured.sizeSource, { retry, slices: sizes });
+        const oversized = sizes?.flatMap((size, index) => size.tier === 'high' ? [index] : []) ?? [];
+        if (sizes && oversized.length === 0) break;
+        observe('slice-oversize', measured.sizeSource, { retry, indexes: oversized,
           reasons: sizes ? oversized.map((index) => sizes![index]!.unavoidableReason) : [],
           ...(sizes ? {} : { error: 'size metadata missing or inconsistent' }) });
+        if (retry === 2) {
+          if (!sizes) throw new Error('goal-author slice sizing: size metadata missing after 2 resplits');
+          const unavoidableReason = 'auto';
+          for (const index of oversized) sizes[index] = { ...sizes[index]!,
+            unavoidableReason: sizes[index]!.unavoidableReason ?? unavoidableReason };
+          observe('slice-oversize-unavoidable', measured.sizeSource, {
+            goalId: options?.goalId ?? config.goalId ?? null,
+            resplitCount: redecomposed,
+            slices: oversized.map((index) => ({ index, ...sizes![index]! })),
+          });
+          break;
+        }
+        observe('resplit', measured.sizeSource, { retry: retry + 1, indexes: oversized,
+          ...(sizes ? {} : { reason: 'size metadata missing or inconsistent' }) });
         const retryAsk = [objective, '', 'The previous goal-author proposal had missing size metadata or oversized slices.',
           `PREVIOUS_STEPS_JSON: ${JSON.stringify(candidate)}`,
           `OVERSIZED_INDEXES_JSON: ${JSON.stringify(oversized)}`,
-          'Regenerate the full plan once. Preserve fitting slices and split each oversized slice into dependent low/medium slices where possible.',
-          'If an oversized slice truly cannot split, leave it high and state a concrete unavoidable reason.'].join('\n');
+          `RESPLIT_ATTEMPT: ${retry + 1} of 2. Regenerate the full plan; preserve fitting slices and split every oversized slice into dependent low/medium slices. If any oversized slice remains after the second resplit, keep it as high tier; a concrete unavoidable reason is optional because the system marks it unavoidable=auto.`].join('\n');
         const regenerated = await decompose(retryAsk);
         if (!regenerated.length) throw new Error('goal-author slice sizing: regeneration produced no slices');
-        redecomposed = 1;
+        redecomposed++;
         candidate = ensureDeviceFirstSteps(objective, regenerated, config.repositoryRoot).steps;
         rationale = decompositionRationale;
         measured = await measure(candidate);
         sizes = measured.sizes;
-        if (!sizes) throw new Error('goal-author slice sizing: size metadata missing after one retry');
-        observe('slice-sized', measured.sizeSource, { retry: 1, slices: sizes });
-        const remaining = sizes.flatMap((size, index) => size.tier === 'high' ? [index] : []);
-        if (remaining.length) observe('slice-oversize', measured.sizeSource, { retry: 1, indexes: remaining,
-          reasons: remaining.map((index) => sizes![index]!.unavoidableReason) });
-        if (remaining.some((index) => !sizes![index]!.unavoidableReason))
-          throw new Error('goal-author slice sizing: high slice lacks unavoidable reason after one retry');
+        if (!sizes && retry === 1) throw new Error('goal-author slice sizing: size metadata missing after 2 resplits');
       }
       config.onSizedSlices?.(restoreSlicePaths(publicSizedSlices(candidate, sizes), objective), redecomposed);
       return finalize(candidate, rationale);

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

@@ -39,7 +39,7 @@ export function resolveGoalAuthorGrade(flag?: GoalAuthorGrade, configured?: unkn
 import type { ObserveOnlySource } from './observe-only.js';
 import type { Question } from '../ask-user-question/types.js';
 import { requestTestScenario as defaultRequestTestScenario, type TestScenarioRequestInput, type TestScenarioRequestResult } from './test-scenario-request.js';
-import { resolveGoalAuthorClarification, parseGoalDocumentClarifications, serializeGoalAuthorParent, type GoalAuthorClarificationResponse, type GoalAuthorParent, type GoalAuthorSelfResolution } from './goal-author-clarification.js';
+import { defaultGoalAuthorSelfResolve, resolveGoalAuthorClarification, parseGoalDocumentClarifications, serializeGoalAuthorParent, type GoalAuthorClarificationResponse, type GoalAuthorParent, type GoalAuthorSelfResolution } from './goal-author-clarification.js';
 import { acquireLockSync } from '../storage/file-lock.js';
 import { createRepositoryReferencedFileReader, type ReferencedFileReadResult } from './goal-file-reader.js';
 import { extractGoalDocSections, type GoalDocSourceLine } from './goal-doc/section.js';
@@ -58,6 +58,9 @@ import { parseReleaseNoteSection } from '../release-loop/release-note.js';
 import { declaredNewFilePaths } from './goal-new-paths.js';
 import { classifyGoalCommandExecution, type GoalCommandExecutionResult } from './goal-command-execution.js';
 import { identityLines, repositoryIdentifiers } from './goal-author-identity.js';
+import { selectRelevantAuthoringLessons } from './knowhow-pack.js';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+export { selectRelevantAuthoringLessons } from './knowhow-pack.js';
 export { formatSubmittedAt } from './goal-author-identity.js';
 import { hasUnmetRequirementOutsidePreservationClause } from './goal-author-preservation-obligation.js';
 export { hasUnmetRequirementOutsidePreservationClause } from './goal-author-preservation-obligation.js';
@@ -114,13 +117,17 @@ export interface GoalAuthorDeps {
   /** Optional externally decomposed plan steps rendered verbatim into the authored goal; the author never generates them. */
   steps?: readonly string[];
   /** Optional injected decomposition seam; omitted means authoring never invokes an LLM or decomposition. */
-  decomposeSteps?: (objective: string, opts?: { context?: string; runId?: string }) => Promise<readonly string[]>;
+  decomposeSteps?: (objective: string, opts?: { context?: string; runId?: string; goalId?: string }) => Promise<readonly string[]>;
   /** Optional launch preflight result supplied by the caller; authoring never reads the ledger or logs itself. */
   launchPreflight?: LaunchPreflightResult;
   /** Optional in-process notification for each authored-goal phase transition. */
   onProgress?: (phase: GoalAuthorPhase, event: 'start' | 'end') => void;
   /** AUTHOR-TIMEBOX: budget for the `ground` phase. Omitted means `GOAL_AUTHOR_GROUND_TIMEBOX_MS`. */
   groundTimeboxMs?: number;
+  /** Stable IDs of bounded lessons carried as goal-head provenance. */
+  authoringLessonIds?: readonly string[];
+  /** Bounded prior lessons rendered as explicitly non-normative authoring context. */
+  authoringLessons?: string;
 }
 
 export type GoalAuthorGroundingPath = 'groundMissionInCodebase';
@@ -501,7 +508,7 @@ export function linesOutsideFencedCode(document: string): GoalDocSourceLine[] {
   return outside;
 }
 
-/** TA 완료 경계는 기존 정식 절 안의 세 독립 행이다. 원문에 없는 값을 저작기가 만들지 않는다. */
+/** TA 완료 경계는 정식 절 안의 세 독립 행이다. 명시 행은 보존하고 누락 행은 태스크 넘김이 범위 기반 초안으로 보충한다. */
 export const GOAL_DONE_BOUNDARY_LABELS = ['완료 경계 코드', '완료 경계 실물', '완료 경계 증거 명령'] as const;
 export type GoalDoneBoundaryLabel = typeof GOAL_DONE_BOUNDARY_LABELS[number];
 // This is a declaration check, not a judgement of whether the proposed work
@@ -603,6 +610,39 @@ export function explicitGoalDoneBoundaryLines(ask: string): string[] {
   return GOAL_DONE_BOUNDARY_LABELS.flatMap((label) => values[label] ? [`- ${label}: ${values[label]}`] : []);
 }
 
+/**
+ * A live hand must not silently drop a cell just because its prose omitted the three
+ * completion lines. Preserve explicit values and draft only the missing lines from
+ * declared target paths; the child can refine this visible draft against the ask.
+ */
+export function draftMissingGoalDoneBoundary(document: string, targetPaths: readonly string[]): {
+  document: string;
+  added: GoalDoneBoundaryLabel[];
+} {
+  const { values, missing } = inspectGoalDoneBoundary(document);
+  if (missing.length === 0) return { document, added: [] };
+
+  const scope = targetPaths.length > 0 ? targetPaths.join(' · ') : '요청 문면에 적힌 범위';
+  const explicitTests = targetPaths.filter((path) => /\.(?:test|spec)\.[cm]?[jt]sx?$/i.test(path));
+  const inferredTests = targetPaths.flatMap((path) => {
+    const match = /^(.*)\.([cm]?[jt]sx?)$/i.exec(path);
+    return match && !/\.(?:test|spec)$/i.test(match[1]!) ? [`${match[1]}.test.${match[2]}`] : [];
+  });
+  const evidencePaths = explicitTests.length > 0 ? explicitTests : inferredTests;
+  const quotePath = (path: string): string => /^[A-Za-z0-9_./:=@%+-]+$/.test(path) ? path : `'${path.replaceAll("'", `'\\''`)}'`;
+  const evidenceCommand = evidencePaths.length > 0
+    ? `bun test ${evidencePaths.map(quotePath).join(' ')}`
+    : 'bun test';
+  const drafts: Record<GoalDoneBoundaryLabel, string> = {
+    '완료 경계 코드': `자동 초안: ${scope}에 문면의 요청 동작을 구현하고 대상 밖의 기본 동작은 보존한다.`,
+    '완료 경계 실물': `자동 초안: 격리 시험에서 ${scope}의 생산 경로를 지나 요청 동작과 기존 동작을 함께 관측한다.`,
+    '완료 경계 증거 명령': evidenceCommand,
+  };
+  const lines = missing.map((label) => `- ${label}: ${drafts[label]}`);
+  const separator = document.length === 0 || document.endsWith('\n') ? '' : '\n';
+  return { document: `${document}${separator}${lines.join('\n')}`, added: missing };
+}
+
 // CommonMark 펜스는 **한 종류의 문자**가 3개 이상 이어진 런이다 — `[`~]{3,}` 는 혼합(백틱+틸드)까지
 // 펜스로 인정해 진짜 진양성을 펜스 안으로 숨긴다(리뷰 must-fix). 열기/닫기 모두 이 하나를 쓴다.
 const FENCE_RUN = /^ {0,3}(`{3,}|~{3,})(.*)$/;
@@ -2908,6 +2948,21 @@ const INJECTION_LADDER: Record<InjectionLadderLevel, string> = {
 const VERIFICATION_MENU_DOC = join('docs', 'goal-context', '03-verification-menu.md');
 const MOCK_CATALOG_DOC = join('docs', 'goal-context', '04-mock-scenarios.md');
 
+/**
+ * 새 무대의 식별자 — 카탈로그 `MS-xx` 가 없는 골도 «어느 무대인지»를 원장에 남긴다.
+ *
+ * ⛔ 0.2.38 실측(`GOAL-TDD-PLAN-REACHES-CHILD`): 카탈로그가 맞지 않는 골(표본 대부분)에서
+ *   `stage.id` 가 `null` 이었고, 그래서 `verification-plan` 이벤트의 `stageId` 칸이 비어
+ *   원장만 보고는 ***「무대가 없었다」와 「무대를 안 적었다」를 가를 수 없었다.***
+ * ⭐ 값은 «실제로 고른 갈래»에서 나온다 — 화면 무대(L2) · 기록된 실제 입력 fixture(L1) · 문서 문구 대조(L1).
+ *   ⇒ 같은 골을 두 번 저작하면 같은 id 가 나오고, 다른 갈래는 다른 id 를 갖는다.
+ */
+const NEW_STAGE_IDS = {
+  'ux-sim': 'new-stage:ux-sim',
+  fixture: 'new-stage:fixture',
+  'doc-phrase': 'new-stage:doc-phrase',
+} as const;
+
 /** 저장소 안의 검증 메뉴·무대 카탈로그를 읽는다. 없으면 null(저작은 «새 무대»로 내려간다). */
 export function readVerificationMenuDocs(root: string | undefined): { menu: string | null; catalog: string | null } {
   const read = (relativePath: string): string | null => {
@@ -3064,7 +3119,7 @@ export function authorVerificationPlan(input: VerificationPlanInput): Verificati
       : `bun test ${testFile}`;
     const base = (input.targetPaths.find((path) => !/\.test\./u.test(path)) ?? testFile).split('/').pop()!.replace(/\.[^.]+$/u, '');
     const name = screen ? `${base} ux-sim 고정 입력` : `${base} 기록된 실제 입력 fixture`;
-    stage = { source: 'new-stage', id: null, level };
+    stage = { source: 'new-stage', id: screen ? NEW_STAGE_IDS['ux-sim'] : NEW_STAGE_IDS.fixture, level };
     stageLine = `- ② 무대: 새 무대: ${name} — \`${command}\` · ${level} (${INJECTION_LADDER[level]})${input.catalog ? ' · 카탈로그(04-mock-scenarios.md)에 맞는 MS 없음' : ' · 카탈로그 문서 없음'}${operationalNote}`;
   }
   const docOnly = input.targetPaths.length > 0 && input.targetPaths.every((path) => /\.md$/iu.test(path));
@@ -3073,7 +3128,7 @@ export function authorVerificationPlan(input: VerificationPlanInput): Verificati
     const docs = input.targetPaths.join(' ');
     const phrase = (/`([^`]+)`/u.exec(behaviour)?.[1] ?? behaviour.replace(/[`'"]/gu, '').slice(0, 30)).trim();
     const check = `rg -n -F '${phrase.replace(/'/gu, '’')}' ${docs}`;
-    stage = { source: 'new-stage', id: null, level: 'L1' };
+    stage = { source: 'new-stage', id: NEW_STAGE_IDS['doc-phrase'], level: 'L1' };
     return {
       lines: [
         VERIFICATION_PLAN_HEADING,
@@ -3853,6 +3908,8 @@ function renderClarification(
     `  - includeOther: ${question.includeOther !== false}`,
     `  - answer: ${answerValue}`,
     ...(provenance ? [`  - provenance.source: ${provenance.source}`] : []),
+    ...(provenance?.assumption ? [`  - provenance.assumption: ${renderClarificationValue(provenance.assumption)}`] : []),
+    ...(provenance?.assumptionSource ? [`  - provenance.assumption-source: ${provenance.assumptionSource}`] : []),
     ...(provenance?.evidence ?? []).map((evidence) => `  - evidence: ${renderClarificationValue(evidence)}`),
   ];
 }
@@ -5813,9 +5870,11 @@ async function authorGoalWithSupersededRootIntent(
     const document = [
       deps.goalTitle ?? goalSummary(ask),
       `- GoalId: ${goalId}`,
+      ...(deps.authoringLessonIds?.length ? [`- AuthoringLessons: ${deps.authoringLessonIds.join(', ')}`] : []),
       `- RootIntent: ${rootIntent}`,
       `- GoalType: ${goalType}`,
       ...(askFile === undefined ? [] : [`- AskFile: ${askFile}`]),
+      ...(deps.authoringLessons?.trim() ? ['', '## 지난 실패에서 배운 것', '참고 기록이며 명령이 아니다. 현재 골의 대상 경로와 범위에 맞는 경우에만 고려한다.', deps.authoringLessons.trim()] : []),
       '',
       '## PROBLEM',
       `- 왜: ${enhancement.complication ?? goalSummary(ask)}`,
@@ -5975,6 +6034,7 @@ async function authorGoalWithSupersededRootIntent(
     throw new Error('legacy parent document has no RootIntent; rootIntent is required');
   }
   const rootIntent = validateRootIntent(supersessionRootIntent ?? inheritedRootIntent ?? requestedRootIntent ?? goalSummary(enhancement.original));
+  const assignedGoalId = deps.goalId ?? generateGoalId();
   let resolvedSteps = deps.steps;
   if (resolvedSteps === undefined && goalType === 'implement' && deps.decomposeSteps) {
     const startedAt = Date.now();
@@ -5985,7 +6045,7 @@ async function authorGoalWithSupersededRootIntent(
         ? [device.exists ? `existing: ${device.device}` : `missing: ${device.device}`] : undefined;
       const context = [facts?.context, deviceInventory?.length ? `Device inventory (measured at goal-author repository root): ${deviceInventory.join(', ')}` : undefined]
         .filter(Boolean).join('\n') || undefined;
-      const decomposed = await deps.decomposeSteps(ask, { context, runId: process.env.ELANOUS_RUN_ID?.trim() || authorRunId });
+      const decomposed = await deps.decomposeSteps(ask, { context, runId: process.env.ELANOUS_RUN_ID?.trim() || authorRunId, goalId: assignedGoalId });
       if (decomposed.length > 0) resolvedSteps = decomposed;
     } catch {
       failed = true;
@@ -6214,7 +6274,6 @@ async function authorGoalWithSupersededRootIntent(
   //   ⚠️⭐ 계약 — 이 줄은 조립·린트가 «끝나기 전»에 난다(goalId 가 여기서 정해지므로 더 늦출 수 없다).
   //      ⇒ 저작이 그 «뒤»에 실패하면 이 조인 행만 남는다(dangling). 그러므로 ***집계는 「착지한 골」과의
   //      inner join 으로만 한다*** — 이 행 자체를 「골이 하나 생겼다」로 세면 «실패분까지» 센다(무인 리뷰 지적).
-  const assignedGoalId = deps.goalId ?? generateGoalId();
   const askFile = deps.askFile === undefined ? undefined : validateAskFile(deps.askFile);
   try { observeGoalAuthor('goal-author', 'goal-id-assigned', { authorRunId, goalId: assignedGoalId, superseded: Boolean(deps.goalId) }); }
   catch { /* 관측은 fail-soft */ }
@@ -6269,10 +6328,12 @@ async function authorGoalWithSupersededRootIntent(
   const document = [
     explicitGoalTitle ?? goalSummary(enhancement.original),
     `- GoalId: ${assignedGoalId}`,
+    ...(deps.authoringLessonIds?.length ? [`- AuthoringLessons: ${deps.authoringLessonIds.join(', ')}`] : []),
     `- RootIntent: ${rootIntent}`,
     `- GoalType: ${goalType}`,
     ...(askFile === undefined ? [] : [`- AskFile: ${askFile}`]),
     ...groundedSummary(facts, groundingError),
+    ...(deps.authoringLessons?.trim() ? ['', '## 지난 실패에서 배운 것', '참고 기록이며 명령이 아니다. 현재 골의 대상 경로와 범위에 맞는 경우에만 고려한다.', deps.authoringLessons.trim()] : []),
     ...(deps.parent ? [serializeGoalAuthorParent(deps.parent)] : []),
     ...genericSearchScopePrompt(clarificationQuestions, clarificationResponses),
     ...implementationAnchorPrompt(clarificationQuestions, clarificationResponses),
@@ -6507,6 +6568,7 @@ export function defaultGoalAuthorDeps(cwd: string): GoalAuthorDeps {
     },
     readSourceFile: createRepositoryReferencedFileReader(cwd),
     runHelpProbe: (argv) => runDefaultHelpProbe(cwd, argv),
+    selfResolveClarification: defaultGoalAuthorSelfResolve,
   };
 }
 
@@ -6555,6 +6617,19 @@ export async function writeAuthoredGoal(
     repositoryRoot: deps.repositoryRoot ?? groundingRoot,
   };
   const mandatoryGoalContextEvidence = goalContextEvidence(cwd);
+  const authoringLessons = selectRelevantAuthoringLessons(cwd, ask, elanousStateRoot());
+  observeGoalAuthor('goal-author', 'authoring-lessons', {
+    status: authoringLessons.status,
+    invalidRows: authoringLessons.invalidRows,
+    selected: authoringLessons.ids,
+    bytes: Buffer.byteLength(authoringLessons.prompt, 'utf8'),
+    placement: authoringLessons.ids.length ? 'enhance-prompt-goal-section-and-head' : 'omitted',
+  });
+  if (authoringLessons.prompt) {
+    resolvedDeps.enhanceOpts = { ...resolvedDeps.enhanceOpts, authoringLessons: authoringLessons.prompt };
+    resolvedDeps.authoringLessons = authoringLessons.prompt;
+  }
+  if (authoringLessons.ids.length) resolvedDeps.authoringLessonIds = authoringLessons.ids;
   const directoryMeasurement = askDirectoryMeasurementLine(observeAskDirectoryCounts(ask, groundingRoot));
   resolvedDeps.enhanceOpts = directoryMeasurement ? { ...resolvedDeps.enhanceOpts, directoryMeasurement } : resolvedDeps.enhanceOpts;
   observeGoalAuthor('goal-author', 'ask-directory-measurement-forwarded', { count: directoryMeasurement ? 1 : 0 });

package/src/self-implement/goal-doc/section.ts

@@ -10,6 +10,28 @@ export interface GoalDocSourceLine {
   readonly start: number;
 }
 
+/** Parse the command on a goal's authored decision-signal Condition line. */
+function authoredSignalCommandFromCondition(condition: string | undefined): string | undefined {
+  if (!condition?.trim()) return undefined;
+  return condition.trim()
+    .replace(/^`([^`]+)`(?=\s|를|$)/, '$1')
+    .replace(/\s*를\s*실행한다[.。]?$/, '')
+    .replace(/[.。]$/, '')
+    .trim();
+}
+
+export function authoredSignalCommandFromBody(value: string): string | undefined {
+  return authoredSignalCommandFromCondition(value.match(/^\s*- Condition:\s*(.+?)\s*$/m)?.[1]);
+}
+
+export function authoredSignalCommandFromGoal(goal: string): string | undefined {
+  const lines = goal.split(/\r?\n/);
+  const start = lines.findIndex((line) => line.trim() === '## 판정 신호');
+  if (start < 0) return undefined;
+  const next = lines.findIndex((line, index) => index > start && /^##\s/.test(line));
+  return authoredSignalCommandFromBody(lines.slice(start + 1, next < 0 ? lines.length : next).join('\n'));
+}
+
 type GoalDocSectionOptions =
   | {
     readonly search: 'exact-trimmed-line';