elanous 0.2.16 → 0.2.17

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

@@ -681,6 +681,87 @@ export function injectGoalDocumentClarificationOtherAnswer(document: string, que
  *    「답이 한 번도 안 들어가서 효과를 못 쟀다」***일 수 있다 — 두 무리 다 «답이 없는» 무리였다.
  *  ⛔ 무인 계약은 유지한다 — 대화형이 아니면 종전대로 지나가되 «그 사실을 값으로» 낸다.
  */
+export type GoalClarificationSelfAnswerPath = 'say-first' | 'ask' | 'rework';
+export type GoalClarificationSelfResolver = NonNullable<GoalAuthorClarificationResolutionDeps['selfResolve']>;
+
+/** Attempt only unanswered document questions; retain every unanswered line if evidence is insufficient. */
+export async function selfAnswerGoalDocumentClarifications(
+  document: string,
+  options: {
+    path: GoalClarificationSelfAnswerPath;
+    ask?: string;
+    evidence?: readonly string[];
+    resolver?: GoalClarificationSelfResolver;
+  },
+): Promise<{ document: string; asked: number; answered: number; unanswered: number; newlyAnswered: number }> {
+  const clarifications = parseGoalDocumentClarifications(document);
+  const pending = clarifications.filter((item) => !item.answered);
+  // 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
+    : 0;
+  let updated = document;
+  let answered = 0;
+  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) {
+    if (parseGoalDocumentClarifications(updated).filter((entry) => entry.questionId === item.questionId).length !== 1) continue;
+    let response: Awaited<ReturnType<typeof resolveGoalAuthorClarification>>;
+    try { response = await resolveGoalAuthorClarification({
+      questionId: item.questionId,
+      kind: 'scope',
+      header: item.header,
+      question: item.question,
+      options: item.options.map((option) => ({ label: option.label, description: option.description })),
+      blocking: false,
+    }, {
+      selfResolve: options.resolver ?? defaultGoalAuthorSelfResolve,
+      evidence,
+      ask: options.ask,
+      selfResolutionSelected: true,
+    }); } catch {
+      // A resolver failure leaves this question unanswered; the remaining questions are still attempted.
+      continue;
+    }
+    if (response.answer === null || response.provenance?.source !== 'self-authored'
+      || response.answer.startsWith(DEFERRED_ANSWER_PREFIX)) continue;
+    try {
+      if (!response.answer.trim() || /[\r\n]/.test(response.answer)
+        || (!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 ?? [];
+      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: ${response.answer}`;
+      lines.splice(answerLine + 1, 0,
+        '  - provenance.source: self-authored',
+        ...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;
+      updated = candidate;
+      answered += 1;
+    } catch {
+      // Leave malformed or disallowed answers deferred.
+    }
+  }
+  const asked = pending.length + alreadySelfAnswered;
+  const unanswered = pending.length - answered;
+  const newlyAnswered = answered;
+  answered += alreadySelfAnswered;
+  debug.log('self-implement.clarification-escalation', 'self-answer', {
+    path: options.path, asked, answered, unanswered,
+    reason: unanswered === 0 ? 'answered' : 'insufficient-evidence',
+  });
+  return { document: updated, asked, answered, unanswered, newlyAnswered };
+}
+
+
 export type ClarificationIntakeMode = 'none' | 'deferred-noninteractive' | 'ask';
 
 export interface ClarificationIntakePlan {

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

@@ -1,9 +1,11 @@
 import { readFileSync, realpathSync } from 'node:fs';
+import { writeGoalDocumentAtomic } from './goal-document-write.js';
 import { isAbsolute, relative, resolve } from 'node:path';
 import { debug } from '../debug/log.js';
+import { getUserConfig } from '../user-config.js';
 import { parseAskProseTitle } from '../self-dev/launch-preflight.js';
 import { createGoalAuthorDecomposeSteps, readRecentStepCountsFailOpen, type RecentStepCountReader } from './goal-author-decompose.js';
-import { defaultGoalAuthorSelfResolve, parseGoalDocumentClarifications, seedGoalAuthorFromAnsweredClarification, seedGoalAuthorFromClarification } from './goal-author-clarification.js';
+import { defaultGoalAuthorSelfResolve, parseGoalDocumentClarifications, seedGoalAuthorFromAnsweredClarification, seedGoalAuthorFromClarification, selfAnswerGoalDocumentClarifications } from './goal-author-clarification.js';
 import { classifyGoalInterviewRound, type GoalInterviewRoundStatus } from './goal-author-closure.js';
 import { recordGoalAsk } from './goal-ask-store.js';
 import { pressDecisionSignal } from './decision-signal-press.js';
@@ -15,6 +17,8 @@ import {
   verbatimOriginalAsk,
   writeAuthoredGoal,
   type GoalAuthorDeps,
+  type GoalAuthorGradeSelection,
+  resolveGoalAuthorGrade,
   type GoalType,
   type GoalFileLintFinding,
 } from './goal-author.js';
@@ -77,6 +81,7 @@ interface GoalAuthorCliOptions {
   supersedes?: string;
   rootIntent?: string;
   goalType?: string;
+  authorGrade?: GoalAuthorGradeSelection;
   selfResolveClarifications?: boolean;
   adversarialReview?: boolean;
   disableAdversarialReview?: boolean;
@@ -97,6 +102,7 @@ export interface GoalAuthorCliDeps {
   recentStepCountReader?: RecentStepCountReader;
   /** Resolver supplied only by the explicit CLI self-resolution opt-in. */
   selfResolveClarification?: NonNullable<GoalAuthorDeps['selfResolveClarification']>;
+  writeFile?: (path: string, document: string) => void;
   recordAsk?: typeof recordGoalAsk;
 }
 
@@ -268,8 +274,9 @@ export async function runGoalAuthorCli(
     : opts.reauthorFromAnsweredClarification
       ? { origin: 'answered-clarification-reauthor' }
       : { origin: 'direct-request' };
-  const recentStepCounts = readRecentStepCountsFailOpen(deps.recentStepCountReader);
-  const decomposeSteps = deps.decomposeSteps ?? (deps.createDecomposeSteps ?? createGoalAuthorDecomposeSteps)(undefined, {
+  const authorGrade = opts.authorGrade ?? resolveGoalAuthorGrade(undefined, getUserConfig().harness?.authorGrade);
+  const recentStepCounts = authorGrade.grade === 'lite' ? undefined : readRecentStepCountsFailOpen(deps.recentStepCountReader);
+  const decomposeSteps = authorGrade.grade === 'lite' ? undefined : deps.decomposeSteps ?? (deps.createDecomposeSteps ?? createGoalAuthorDecomposeSteps)(undefined, {
     ...(adversarialReview !== undefined ? { adversarialReview, adversarialReviewSource: 'cli' as const } : {}),
     ...(recentStepCounts !== undefined ? { recentStepCounts } : {}),
   });
@@ -283,13 +290,34 @@ export async function runGoalAuthorCli(
   debug.log('goal-author', 'goal-title-forwarded', proseTitle === undefined
     ? { passed: false }
     : { passed: true, titleChars: proseTitle.length });
+  const gradeDeps = authorGrade.grade === 'lite' || opts.authorGrade ? { authorGrade } : {};
   const authorDeps: Partial<GoalAuthorDeps> = parentGoalFile && parentQuestionId
-    ? { parent: { goalFile: parentGoalFile, questionId: parentQuestionId }, parentDocument, clarificationAnswers, decomposeSteps, ...selfResolutionDeps, ...progressDeps, ...launchPreflightDeps, ...(opts.rootIntent !== undefined && { rootIntent: opts.rootIntent }), ...(goalType !== undefined && { goalType }), ...goalTitleDeps }
-    : { ...(clarificationAnswers && { clarificationAnswers }), decomposeSteps, ...selfResolutionDeps, ...progressDeps, ...launchPreflightDeps, ...(opts.rootIntent !== undefined && { rootIntent: opts.rootIntent }), ...(goalType !== undefined && { goalType }), ...goalTitleDeps };
+    ? { parent: { goalFile: parentGoalFile, questionId: parentQuestionId }, parentDocument, clarificationAnswers, ...(decomposeSteps ? { decomposeSteps } : {}), ...gradeDeps, ...selfResolutionDeps, ...progressDeps, ...launchPreflightDeps, ...(opts.rootIntent !== undefined && { rootIntent: opts.rootIntent }), ...(goalType !== undefined && { goalType }), ...goalTitleDeps }
+    : { ...(clarificationAnswers && { clarificationAnswers }), ...(decomposeSteps ? { decomposeSteps } : {}), ...gradeDeps, ...selfResolutionDeps, ...progressDeps, ...launchPreflightDeps, ...(opts.rootIntent !== undefined && { rootIntent: opts.rootIntent }), ...(goalType !== undefined && { goalType }), ...goalTitleDeps };
   const write = deps.write ?? writeAuthoredGoal;
   const result = opts.groundingCwd === undefined
     ? await write(ask, opts.cwd, authorDeps, superseded ? { supersedes: superseded } : undefined)
     : await write(ask, opts.cwd, authorDeps, superseded ? { supersedes: superseded } : undefined, opts.groundingCwd);
+  if (opts.selfResolveClarifications) {
+    const rework = Boolean(supersededDocument || opts.reauthorFromAnsweredClarification);
+    {
+      try {
+        const resolved = await selfAnswerGoalDocumentClarifications(result.authored.document, {
+          path: rework ? 'rework' : 'say-first', ask, resolver: deps.selfResolveClarification ?? defaultGoalAuthorSelfResolve,
+          evidence: result.authored.facts
+            ? [...(result.authored.facts.persistentEvidence ?? []), ...result.authored.facts.codeFacts, ...result.authored.facts.documentFacts]
+            : undefined,
+        });
+        if (resolved.newlyAnswered > 0) {
+          (deps.writeFile ?? writeGoalDocumentAtomic)(result.path, resolved.document);
+          result.authored.document = resolved.document;
+        }
+      } catch (error) {
+        // The previous goal file is left intact (atomic replace); implementation proceeds from it with the questions deferred.
+        debug.log('goal-author.clarify', 'self-answer-deferred', { reason: error instanceof Error ? error.message : String(error) });
+      }
+    }
+  }
   try {
     const recorded = (deps.recordAsk ?? recordGoalAsk)({
       authorRunId: result.authored.authorRunId,

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

@@ -18,6 +18,17 @@ function observeGoalAuthor(
   debug.log(category === 'goal-author' ? 'harness.author' : 'harness.author.clarify', event, data);
 }
 import { getUserConfig } from '../user-config.js';
+
+export type GoalAuthorGrade = 'full' | 'lite';
+export type GoalAuthorGradeSource = 'flag' | 'config' | 'default';
+export interface GoalAuthorGradeSelection { grade: GoalAuthorGrade; source: GoalAuthorGradeSource }
+
+/** The flag is authoritative; malformed or absent configuration keeps the full pipeline. */
+export function resolveGoalAuthorGrade(flag?: GoalAuthorGrade, configured?: unknown): GoalAuthorGradeSelection {
+  if (flag !== undefined) return { grade: flag, source: 'flag' };
+  if (configured === 'lite' || configured === 'full') return { grade: configured, source: 'config' };
+  return { grade: 'full', source: 'default' };
+}
 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';
@@ -45,6 +56,7 @@ type GoalEnhancement = Omit<Pick<EnhanceResult, 'original' | 'checklist' | 'verb
 export interface GoalAuthorDeps {
   ground: (ask: string, groundingDeps?: GoalAuthorGroundingDeps) => Promise<CodebaseGrounding>;
   persistentGrounding?: GoalAuthorGroundingDeps;
+  authorGrade?: GoalAuthorGradeSelection;
   enhance: (ask: string, opts?: EnhanceOpts) => Promise<GoalEnhancement>;
   /** Additive enhancer options supplied by the file-writing entrypoint. */
   enhanceOpts?: EnhanceOpts;
@@ -4925,6 +4937,17 @@ async function authorGoalWithSupersededRootIntent(
   }
   // ⭐ 이 저작 «한 번»의 id. goalId 보다 «먼저» 있어야 ground·enhance 의 소요를 그 골에 붙일 수 있다.
   const authorRunId = generateGoalId();
+  const authorGrade = deps.authorGrade ?? resolveGoalAuthorGrade(undefined, getUserConfig().harness?.authorGrade);
+  const lite = authorGrade.grade === 'lite';
+  // lite 는 판정선을 남기는 대신 단계를 덜 한다 — 요청에 반증 줄이 하나도 없으면 판정선 없는 골이 나가므로 시작 전에 멈춘다.
+  if (lite && !ask.split(/\r?\n/u).some((line) => /판정선|판정 신호|반증|decision signal/iu.test(line))) {
+    try { observeGoalAuthor('goal-author', 'author-grade-refused', { authorRunId, reason: 'lite-without-falsifiable-signal' }); }
+    catch { /* observation is fail-soft */ }
+    throw new Error('lite authoring needs a falsifiable signal line (판정선/반증) in the ask — add one or use --author-grade full');
+  }
+  const skippedPhases = lite ? ['adversarial-review', 'goal-steps-decomposed', 'persistent-grounding'] : [];
+  try { observeGoalAuthor('goal-author', 'author-grade', { authorRunId, grade: authorGrade.grade, source: authorGrade.source, skippedPhases }); }
+  catch { /* observation is fail-soft */ }
   const authorStartedAt = Date.now();
   const enhanceTokens: GoalAuthorTokens = { inputTokens: null, outputTokens: null };
   const onEnhanceUsage = (usage: LLMUsage): void => {
@@ -4934,18 +4957,20 @@ async function authorGoalWithSupersededRootIntent(
   };
   let facts: CodebaseGrounding | null = null;
   let groundingError = false;
-  const persistentGrounding = resolveGoalAuthorPersistentGrounding('persistentGrounding' in deps ? deps.persistentGrounding : undefined);
-  const groundStartedAt = startGoalAuthorPhase('ground', authorRunId, deps.onProgress);
-  try {
-    facts = await deps.ground(ask, persistentGrounding.deps);
-  } catch {
-    groundingError = true;
-  } finally {
-    endGoalAuthorPhase('ground', groundStartedAt, authorRunId, deps.onProgress);
-    observeGoalAuthorPersistentGroundingResult(
-      persistentGrounding.decision,
-      goalAuthorPersistentGroundingMetrics(facts, groundingError, authorRunId),
-    );
+  if (!lite) {
+    const persistentGrounding = resolveGoalAuthorPersistentGrounding('persistentGrounding' in deps ? deps.persistentGrounding : undefined);
+    const groundStartedAt = startGoalAuthorPhase('ground', authorRunId, deps.onProgress);
+    try {
+      facts = await deps.ground(ask, persistentGrounding.deps);
+    } catch {
+      groundingError = true;
+    } finally {
+      endGoalAuthorPhase('ground', groundStartedAt, authorRunId, deps.onProgress);
+      observeGoalAuthorPersistentGroundingResult(
+        persistentGrounding.decision,
+        goalAuthorPersistentGroundingMetrics(facts, groundingError, authorRunId),
+      );
+    }
   }
 
   const enhanceStartedAt = startGoalAuthorPhase('enhance', authorRunId, deps.onProgress);
@@ -4989,6 +5014,57 @@ async function authorGoalWithSupersededRootIntent(
   }
   enhancement = { ...enhancement, original: ask };
 
+  if (lite) {
+    const goalType = deps.goalType ?? 'implement';
+    const goalId = deps.goalId ?? generateGoalId();
+    const signal = decisionSignalSection(null, ask, enhancement.decisionSignal);
+    const falsifiableSignal = signal.filled > 0 ? signal.lines : [
+      ...signal.lines,
+      ...ask.split(/\r?\n/u).filter((line) => /판정선|판정 신호|반증|decision signal/iu.test(line) && !signal.lines.some((rendered) => rendered.includes(line.trim()))),
+    ];
+    const targetPaths = [...new Set(declaredTargetPaths(ask))];
+    const checklistIds = [...new Set(Array.from(ask.matchAll(/\b[A-Z][A-Z0-9]+-[A-Z0-9]+\b/g), (match) => match[0]))];
+    const askFile = deps.askFile === undefined ? undefined : validateAskFile(deps.askFile);
+    const inheritedRootIntent = deps.parentDocument === undefined ? null : parseRootIntent(deps.parentDocument);
+    const rootIntent = validateRootIntent(deps.supersessionRootIntent ?? inheritedRootIntent ?? deps.rootIntent ?? goalSummary(ask));
+    const document = [
+      deps.goalTitle ?? goalSummary(ask),
+      `- GoalId: ${goalId}`,
+      `- RootIntent: ${rootIntent}`,
+      `- GoalType: ${goalType}`,
+      ...(askFile === undefined ? [] : [`- AskFile: ${askFile}`]),
+      '',
+      '## PROBLEM',
+      `- 왜: ${enhancement.complication ?? goalSummary(ask)}`,
+      '',
+      '## WHAT TO BUILD',
+      `- 무엇: ${enhancement.situation ?? goalSummary(ask)}`,
+      ORIGINAL_ASK_MARKER,
+      fenceFor(ask), ask, fenceFor(ask),
+      '',
+      '## ACCEPTANCE CRITERIA',
+      ...enhancement.checklist.map(requestedCriterionLine),
+      '',
+      '## REQUIRED EVIDENCE',
+      '- [requested] Verify the decision signal and the verbatim ask.',
+      '',
+      ...(goalType === 'implement' ? ['## TRACED PATHS', ...(targetPaths.length ? targetPaths.map((path) => `- ${path}`) : ['- Target paths: not declared in the ask.']), ''] : []),
+      '## SCOPE BOUNDARY',
+      `- 대상 경로: ${targetPaths.length ? targetPaths.join(' · ') : 'not declared'}`,
+      `- 칸 id: ${checklistIds.length ? checklistIds.join(' · ') : 'not declared'}`,
+      '',
+      '## 답하지 못하는 것',
+      '- No persistent grounding was performed in lite authoring.',
+      '',
+      '## 불변식',
+      '- No persistent grounding was performed in lite authoring.',
+      '',
+      '## 판정 신호',
+      ...falsifiableSignal,
+    ].join('\n');
+    return { document, facts: null, grounded: false, authorRunId };
+  }
+
   observeGoalAuthor('goal-author', 'constant-instruction-placement', {
     authorRunId,
     lines: CONSTANT_DOCUMENT_INSTRUCTION_POLICY.length,

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

@@ -11,9 +11,13 @@ import {
   writePendingQuestion,
 } from '../ask-user-question/pending-questions.js';
 import { debug } from '../debug/log.js';
+import { writeGoalDocumentAtomic } from './goal-document-write.js';
 import {
   applyClarificationReply,
   parseGoalDocumentClarifications,
+  selfAnswerGoalDocumentClarifications,
+  type GoalClarificationSelfResolver,
+  type GoalClarificationSelfAnswerPath,
 } from './goal-author-clarification.js';
 import type { HitlDelivery } from '../hitl/types.js';
 
@@ -49,6 +53,8 @@ export interface GoalClarificationEscalationInput {
   resolveOriginDelivery?: (sessionId: string) => HitlDelivery | undefined;
   /** Non-blocking terminal fallback for a non-TUI delivery with no installed resolver. */
   fallback?: (message: string) => void;
+  selfResolveClarification?: GoalClarificationSelfResolver;
+  selfAnswerPath?: GoalClarificationSelfAnswerPath;
   /** Fail-soft pending persistence for terminal fallbacks; injectable for focused tests. */
   pendingQuestionPersistence?: {
     create: typeof createPendingQuestion;
@@ -404,6 +410,7 @@ export async function escalateGoalDocumentClarifications(
   const dispatchDelivery = delivery ?? 'modal';
   const recordedDelivery = input.resolvedDelivery ?? dispatchDelivery;
   let answersWritten = 0;
+  let selfAnswered = 0;
   let questionIds: string[] = [];
   const observeEscalation = (event: GoalClarificationObservationEvent, data: Record<string, unknown>): void => {
     writeEscalationObservation(event, { ...data, deliverySource, answersWritten, questionIds });
@@ -430,6 +437,35 @@ export async function escalateGoalDocumentClarifications(
     return result;
   }
 
+  if (input.selfAnswerPath) {
+    try {
+      const resolution = await selfAnswerGoalDocumentClarifications(document, {
+        path: input.selfAnswerPath,
+        ask: document,
+        resolver: input.selfResolveClarification,
+      });
+      if (resolution.newlyAnswered > 0) {
+        writeGoalDocumentAtomic(input.goalFile, resolution.document);
+        answersWritten += resolution.newlyAnswered;
+        selfAnswered += resolution.newlyAnswered;
+        document = resolution.document;
+        clarifications = parseGoalDocumentClarifications(document);
+        unanswered = clarifications.filter((clarification) => !clarification.answered);
+        deliveryIds = mapClarificationDeliveryIds(clarifications);
+        questionIds = [...new Set(unanswered.map((clarification) => clarification.questionId))];
+      }
+      if (unanswered.length === 0) {
+        const result = { unanswered: 0, escalated: 0, delivery: recordedDelivery, outcome: 'skipped' as const, answeredBy: 'agent' as const };
+        observeEscalation(result.outcome, { goalFile: input.goalFile, ...result, reason: 'self-answered' });
+        return result;
+      }
+    } catch (error) {
+      debug.log(GOAL_CLARIFICATION_ESCALATION_CATEGORY, 'self-answer-failed', {
+        path: input.selfAnswerPath, reason: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
   const dispatch = input.dispatch ?? dispatchAskUserQuestion;
   const pendingQuestionPersistence = input.pendingQuestionPersistence ?? {
     create: createPendingQuestion,
@@ -444,7 +480,7 @@ export async function escalateGoalDocumentClarifications(
   // ⛔⭐⭐⭐ 여기서부터의 조기 반환·폴백은 이 «누적값»을 쓴다 — 'none' 을 하드코딩하면
   //  앞 배치가 답했는데 뒤 배치가 취소·실패했을 때 「아무도 안 답했다」는 «거짓»이 된다
   //  (무인 리뷰 R2 must-fix · 실측 형태: 관측이 거짓말한다).
-  const seenProvenance = { explicit: new Set<'human' | 'agent'>(), unmarkedAnswer: false };
+  const seenProvenance = { explicit: new Set<'human' | 'agent'>(selfAnswered > 0 ? ['agent' as const] : []), unmarkedAnswer: false };
   const aggregate = (): GoalClarificationAnsweredBy => {
     const { explicit, unmarkedAnswer } = seenProvenance;
     // ⭐ 표시 없는 답도 «한 출처»로 센다 — legacy 경로는 사람이다(레포 안 리졸버는 이제 전부 명시한다).

package/src/self-implement/goal-document-write.ts

@@ -0,0 +1,28 @@
+/** Atomic goal-document replacement for self-answered clarifications (POD-SELF-ANSWER). */
+import { chmodSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+
+export interface GoalDocumentWriteIo {
+  writeFileSync: (path: string, data: string, options?: { mode?: number }) => void;
+  renameSync: (from: string, to: string) => void;
+  rmSync: (path: string, options: { force: boolean }) => void;
+  statSync: (path: string) => { mode: number };
+  chmodSync: (path: string, mode: number) => void;
+}
+
+const realIo: GoalDocumentWriteIo = { writeFileSync, renameSync, rmSync, statSync, chmodSync };
+
+/** Replace a goal document atomically (temp file next to it + rename) so a failed write never leaves a torn goal.
+ *  The existing file's permission bits are kept, so a 0600 goal stays 0600 after replacement. */
+export function writeGoalDocumentAtomic(path: string, document: string, io: GoalDocumentWriteIo = realIo): void {
+  let mode: number | undefined;
+  try { mode = io.statSync(path).mode & 0o777; } catch { mode = undefined; }
+  const temporary = `${path}.self-answer-${process.pid}-${Date.now()}.tmp`;
+  try {
+    io.writeFileSync(temporary, document, mode === undefined ? undefined : { mode });
+    if (mode !== undefined) io.chmodSync(temporary, mode);
+    io.renameSync(temporary, path);
+  } catch (error) {
+    try { io.rmSync(temporary, { force: true }); } catch { /* best effort */ }
+    throw error;
+  }
+}

package/src/self-implement/heal-intake.ts

@@ -68,6 +68,10 @@ function liveHealRuns(root: string): Set<string> {
 /** A test process must never start the real heal loop — it spawns external grounding (10-05 load 150 incident). */
 export async function startHealLoop(file: string, options: HealLoopOptions, env: NodeJS.ProcessEnv = process.env,
   run: StartHealLoop = async (graph, args) => (await import('../graph-runner/runner.js')).runGraph(graph, args)): Promise<unknown> {
+  if (env.ELANOUS_POD_NAME) {
+    debug.log('heal.intake', 'skipped-in-pod', { ref: options.input.failureEvent.ref });
+    return undefined;
+  }
   if (env.NODE_ENV === 'test' || env.ELANOUS_TEST_HOME) {
     debug.log('heal.intake', 'loop-start-skipped-test', { runId: options.runId });
     return undefined;

package/src/self-implement/host-regate.ts

@@ -30,6 +30,8 @@ export type HostRegateDeps = {
   acquire?: (repoRoot: string) => Promise<() => void>;
   log?: (event: 'passed' | 'failed' | 'unmeasured' | 'base-raced', data: Record<string, unknown>) => void;
   freezeRoot?: string;
+  /** Test seam for the operational freeze authority; production always uses the host root. */
+  prodFreezeRoot?: string;
   runExposeGate?: typeof runExposeGate;
   syncMergedChecklist?: typeof import('../release-loop/merged-pr-checklist.js').syncMergedPrChecklist;
 };
@@ -241,7 +243,7 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
     // --match-head-commit pins the head. gh has no base pin, so the base was re-read just
     // above; the seconds between that read and the merge are checked after the fact below.
     if (input.verifyOnly) return result('passed');
-    const landing = admitLandingMerge({ prNumber: input.prNumber, headCommit: input.headCommit, repoRoot: input.repoRoot, ...(input.goalFile ? { goalFile: input.goalFile } : {}) }, deps.freezeRoot, {}, input.resumed ? undefined : { prNumber: input.prNumber, repoRoot: input.repoRoot, headCommit: input.headCommit });
+    const landing = admitLandingMerge({ prNumber: input.prNumber, headCommit: input.headCommit, repoRoot: input.repoRoot, ...(input.goalFile ? { goalFile: input.goalFile } : {}) }, deps.freezeRoot, {}, input.resumed ? undefined : { prNumber: input.prNumber, repoRoot: input.repoRoot, headCommit: input.headCommit }, { prodFreezeRoot: deps.prodFreezeRoot });
     if (landing.kind !== 'merge') {
       debug.log('harness.merge', 'frozen', { pr: input.prNumber, ...(landing.kind === 'held' ? { reason: landing.freeze.reason, until: landing.freeze.until } : { resumedElsewhere: true }) });
       return { passed: true, failures: [], os: process.platform, status: 'frozen' };

package/src/self-implement/orchestrator.ts

@@ -34,6 +34,7 @@ import { judgePredictionAccuracy } from './judge-prediction-accuracy.js';
 import { measureReviewFindingRecurrence, type ReviewFindingRecurrence } from './review-finding-recurrence.js';
 import { createHash } from 'node:crypto';
 import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
+import { writeGoalDocumentAtomic } from './goal-document-write.js';
 import { hostname, loadavg } from 'node:os';
 import { resolveHostId } from '../platform/host-id.js';
 import { resolveInstanceName } from '../instance-identity.js';
@@ -242,7 +243,7 @@ export type { QuotaAccountAvailabilityEvidence };
 import { decideReworkSalvage, type ReworkSalvageEvidence } from './rework-salvage.js';
 import { type SupervisorGoalFillEvidence, fillUnverifiableGoalSlots, type SupervisorGoalFillResult } from './goal-supervisor-fill.js';
 import { escalateGoalDocumentClarifications, recordSupervisorPlanRevision, type GoalClarificationEscalationResult, type SupervisorPlanRevisionRelaxation, type SupervisorPlanRevisionResult } from './goal-clarification-escalation.js';
-import { parseGoalDocumentClarifications } from './goal-author-clarification.js';
+import { parseGoalDocumentClarifications, selfAnswerGoalDocumentClarifications, type GoalClarificationSelfResolver } from './goal-author-clarification.js';
 import {
   createFileAskUserQuestionResolver,
   type AskUserQuestionDispatchContext,
@@ -1154,6 +1155,8 @@ export interface SelfImplementSeams {
   /** ⭐ 「이 표면에 답할 사람이 있나」. 기본은 실제 stdin 의 TTY 여부다 —
    *  ⛔ 실물에 매이면 테스트가 «환경»을 검사하게 되므로 주입 가능하게 둔다. */
   stdinIsInteractive?: () => boolean;
+  /** Optional author self-answer seam for non-TTY Pods; never installs a terminal HITL resolver. */
+  selfResolveClarification?: GoalClarificationSelfResolver;
 }
 
 /** onProgress seam 이 통지하는 단계(관측·UX 라벨). */
@@ -5364,6 +5367,7 @@ async function runSelfImplementInner(
           ? { resolvedDelivery: installDecision.delivery }
           : {}),
         ...(s.escalateGoalClarifications ? { dispatch: s.escalateGoalClarifications } : {}),
+        ...(!stdinIsInteractive && !clarificationResolverLease.installed ? { selfAnswerPath: 'ask' as const, selfResolveClarification: s.selfResolveClarification } : {}),
         fallback: (message) => process.stdout.write(`${message}\n`),
       });
     } finally {
@@ -6175,6 +6179,20 @@ async function runSelfImplementInner(
             if (relaxation) pendingPlanRevision = { ...pendingPlanRevision!, relaxation };
             if (opts.goalFile) {
               try {
+                if (!(s.stdinIsInteractive ?? (() => Boolean(process.stdin.isTTY && process.stdout.isTTY)))()) {
+                  try {
+                    const source = readFileSync(opts.goalFile, 'utf8');
+                    // Always run the shared self-answer so every rework pass leaves one observation, even with nothing pending.
+                    const resolved = await selfAnswerGoalDocumentClarifications(source, {
+                      path: 'rework', ask: source, resolver: s.selfResolveClarification,
+                    });
+                    if (resolved.newlyAnswered > 0) writeGoalDocumentAtomic(opts.goalFile, resolved.document);
+                  } catch (error) {
+                    debug.log('self-implement.clarification-escalation', 'self-answer-failed', {
+                      path: 'rework', reason: error instanceof Error ? error.message : String(error),
+                    });
+                  }
+                }
                 const recorded: SupervisorPlanRevisionResult = recordSupervisorPlanRevision(opts.goalFile, { reason: parsedDecision.reason, round, ...(relaxation ? { relaxation } : {}) });
                 pendingPlanRevision = { ...pendingPlanRevision!, ...(relaxation ? { relaxation } : {}), application: {
                   status: recorded.status === 'applied' || recorded.status === 'already-applied' ? recorded.status : 'failed',

package/src/task-agent/actions.ts

@@ -0,0 +1,118 @@
+export type NextActionKind = 'review' | 'land' | 'retry' | 'green' | 'decision';
+export interface NextAction {
+  kind: NextActionKind;
+  taskId: string;
+  rationale: string;
+  pr: number;
+  runId: string;
+  original: string;
+  checklistId: string;
+  history?: string[];
+  mustFix?: string[];
+  cwd?: string;
+  risk?: 'money' | 'security' | 'irreversible-publication';
+}
+export interface ActionDeps {
+  command(args: string[]): Promise<{ status: number; stdout: string; stderr?: string }>;
+  mode?: string;
+  landingsToday?: number;
+  landingDay?: string;
+  saveState?(): void;
+  dailyLimit?: number;
+  failures?: number;
+  failureCounts?: Record<string, number>;
+  /** 하루 착지 칸을 잠금 안에서 먼저 확보한다 — 다른 프로세스와 같은 잔여 칸을 두 번 쓰지 않게. 없으면 메모리 셈. */
+  reserveLanding?(day: string, limit: number): boolean;
+  /** 병합이 확인되지 않으면 확보한 칸을 돌려준다. */
+  releaseLanding?(day: string): void;
+  /** 실패 한 번을 잠금 안에서 디스크에 더한다(다른 프로세스의 실패를 덮지 않게) · 더한 뒤의 값을 돌려준다. */
+  incrementFailure?(key: string): number;
+  observe(event: 'task-agent.action', data: { taskId: string; kind: NextActionKind; result: string; reason: string }): void;
+}
+
+export async function executeNextAction(action: NextAction, deps: ActionDeps): Promise<string> {
+  const record = (result: string, reason: string) => {
+    if (result === 'failed' && (deps.failureCounts || deps.incrementFailure)) {
+      const key = JSON.stringify([action.taskId, action.kind]);
+      const next = deps.incrementFailure ? deps.incrementFailure(key) : (deps.failureCounts![key] ?? 0) + 1;
+      if (deps.failureCounts) deps.failureCounts[key] = next;
+      if (!deps.incrementFailure) deps.saveState?.();
+    }
+    deps.observe('task-agent.action', { taskId: action.taskId, kind: action.kind, result, reason });
+    return result;
+  };
+  if (deps.mode !== 'live') return record('shadow', `would ${action.kind}: ${action.rationale}`);
+  const card = async (reason: string) => {
+    const evidence = JSON.stringify({ runId: action.runId, pr: action.pr, mustFix: action.mustFix ?? [], history: action.history ?? [], selected: action.kind, reason });
+    const result = await deps.command(['decisions', 'raise', '--title', `${action.taskId}: ${reason}`, '--category', action.risk === 'money' ? 'money' : action.risk === 'security' ? 'security' : action.risk === 'irreversible-publication' ? 'publish' : 'other', '--s', `Task ${action.taskId} needs a decision.`, '--c', reason, '--ref', evidence, '--q', 'Which action should be taken?', '--option', 'h=Keep on hold:no automatic execution', '--option', 'p=Approve action:execute after approval', '--skip-recommend', 'requires human decision', '--no-xcheck', 'automated escalation']);
+    return record(result.status === 0 ? 'decision' : 'failed', reason);
+  };
+  if (action.risk) return card(`risk: ${action.risk}`);
+  if ((deps.failureCounts?.[JSON.stringify([action.taskId, action.kind])] ?? deps.failures ?? 0) >= 2) return card('same task/action failed twice');
+  if (action.kind === 'land') {
+    if (!action.cwd) return card('landing worktree unknown');
+    const view = await deps.command(['gh', 'pr', 'view', String(action.pr), '--json', 'labels']);
+    if (view.status !== 0) return card('PR labels unavailable');
+    let labels: unknown;
+    try { labels = (JSON.parse(view.stdout) as { labels?: unknown }).labels; }
+    catch { return card('PR labels unavailable'); }
+    if (!Array.isArray(labels) || !labels.every(label => label && typeof label === 'object' && typeof label.name === 'string')) return card('PR labels unavailable');
+    if (labels.some(label => label.name === 'elanous:release-path')) return card('release-path');
+    const day = new Date().toLocaleDateString('en-CA', { timeZone: 'Asia/Seoul' });
+    if (deps.landingDay && deps.landingDay !== day) deps.landingsToday = 0;
+    deps.landingDay = day;
+    const limit = deps.dailyLimit ?? 5;
+    if (deps.reserveLanding ? !deps.reserveLanding(day, limit) : (deps.landingsToday ?? 0) >= limit) return card('daily landing limit');
+  }
+  if (action.kind === 'decision') return card(action.rationale);
+  if (action.kind === 'green') return card('green requires a verified landing in this execution');
+  if (action.kind === 'retry' && !action.mustFix?.length) return card('must-fix missing; cannot narrow retry');
+  if (action.kind === 'review') {
+    const review = await deps.command(['self', 'review', String(action.pr), '--json']);
+    if (review.status !== 0) return record('failed', 'review command failed');
+    let parsed: { verdict?: string; mustFix?: string[]; reviewed?: boolean };
+    try {
+      const payload: unknown = JSON.parse(review.stdout);
+      const item = Array.isArray(payload) ? payload.find((entry: unknown) => entry && typeof entry === 'object' && 'pr' in entry && Number(entry.pr) === action.pr) : payload;
+      if (!item || typeof item !== 'object' || Array.isArray(item)) return record('failed', 'invalid review JSON');
+      parsed = item as typeof parsed;
+    } catch { return record('failed', 'invalid review JSON'); }
+    if (parsed.reviewed !== true) return record('failed', 'review was not performed');
+    if (parsed.verdict === 'pass') { record('done', 'review pass'); return executeNextAction({ ...action, kind: 'land', history: [...(action.history ?? []), 'review pass'] }, deps); }
+    if (parsed.verdict === 'fail' && Array.isArray(parsed.mustFix) && parsed.mustFix.length > 0 && parsed.mustFix.every(fix => typeof fix === 'string' && fix.trim())) { record('done', 'review fail'); return executeNextAction({ ...action, kind: 'retry', mustFix: parsed.mustFix, history: [...(action.history ?? []), 'review fail'] }, deps); }
+    return card('review verdict or must-fix unavailable');
+  }
+  // 여기 닿는 종류는 land · retry 둘뿐이다(green·decision·review 는 위에서 끝난다).
+  const args = action.kind === 'land' ? ['pr', 'land', '--cwd', action.cwd!]
+    : ['harness', 'say', `${action.original}\n\nMust-fix:\n${(action.mustFix ?? []).join('\n')}\n\nPrevious run: ${action.runId}`];
+  const day = deps.landingDay ?? new Date().toLocaleDateString('en-CA', { timeZone: 'Asia/Seoul' });
+  const outcome = await deps.command(args);
+  if (outcome.status !== 0) {
+    if (action.kind === 'land') deps.releaseLanding?.(day);
+    return record('failed', `${action.kind} command failed: ${outcome.stderr ?? ''}`);
+  }
+  if (action.kind === 'land') {
+    const merged = await deps.command(['gh', 'pr', 'view', String(action.pr), '--json', 'state,mergeCommit']);
+    let sha: string | undefined;
+    let notMerged = false;
+    try {
+      const value = JSON.parse(merged.stdout) as { state?: string; mergeCommit?: { oid?: string } };
+      if (merged.status === 0 && value.state === 'MERGED' && /^[a-f0-9]{40}$/i.test(value.mergeCommit?.oid ?? '')) sha = value.mergeCommit?.oid;
+      else if (merged.status === 0 && typeof value.state === 'string' && value.state !== 'MERGED') notMerged = true;
+    } catch { /* unknown merge state is never green */ }
+    if (!sha) {
+      // «열림»으로 확인됐을 때만 칸을 돌려준다. 상태를 못 읽었으면 병합됐을 수 있으니 칸은 쓴 것으로 둔다(상한을 넘지 않게).
+      if (notMerged) deps.releaseLanding?.(day);
+      return card('landing commit unknown; checklist remains unchanged');
+    }
+    record('done', action.rationale);
+    if (!deps.reserveLanding) deps.landingsToday = (deps.landingsToday ?? 0) + 1;
+    deps.saveState?.();
+    const green = await deps.command(['release', 'checklist', 'set', action.checklistId, '--status', 'green', '--evidence', `${action.pr}·${sha}`]);
+    // 체크리스트 실패는 이 과제·land 의 실패로 센다(두 번이면 다음엔 카드).
+    if (green.status !== 0) return record('failed', `green command failed: ${green.stderr ?? ''}`);
+    deps.observe('task-agent.action', { taskId: action.taskId, kind: 'green', result: 'done', reason: action.rationale });
+    return 'done';
+  }
+  return record('done', action.rationale);
+}