elanous 0.2.16 → 0.2.18

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

@@ -18,6 +18,22 @@ 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' | 'env' | 'config' | 'default';
+export interface GoalAuthorGradeSelection { grade: GoalAuthorGrade; source: GoalAuthorGradeSource }
+
+/**
+ * Precedence flag > env (`ELANOUS_AUTHOR_GRADE`) > config > default(full). Malformed env or
+ * configuration values are ignored and keep the full pipeline. The env seam lets the Pod carry the
+ * grade without a CLI flag an older in-Pod elanous would reject (AUTHOR-LITE2-POD).
+ */
+export function resolveGoalAuthorGrade(flag?: GoalAuthorGrade, configured?: unknown, env: unknown = process.env.ELANOUS_AUTHOR_GRADE): GoalAuthorGradeSelection {
+  if (flag !== undefined) return { grade: flag, source: 'flag' };
+  if (env === 'lite' || env === 'full') return { grade: env, source: 'env' };
+  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 +61,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 +4942,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 +4962,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 +5019,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/l8-merge-queue.ts

@@ -129,12 +129,33 @@ export async function runL8ShadowQueue(cwd: string, deps: L8ShadowQueueDeps = {}
       if (changed.some((file) => file.startsWith('-') || file.startsWith('/') || file.split('/').includes('..') || file.includes('\\'))) throw new Error('unsafe changed-file path');
       verdict.tests = files.filter((file) => /(?:^|\/)[^/]+\.(?:test|spec)\.(?:[cm]?[jt]sx?)$/.test(file));
       const merge = execute('git', ['-c', 'user.name=elanous shadow', '-c', 'user.email=shadow@localhost', 'merge', '--no-ff', '--no-edit', item.head], temp);
+      let autoResolvedNextMd = false;
       if (merge.status !== 0) {
-        const unresolved = run('git', ['diff', '--name-only', '--diff-filter=U'], temp);
-        if (!unresolved) throw new Error(`git merge failed: ${merge.stderr.trim() || `exit ${merge.status}`}`);
-        verdict.verdict = 'conflict';
-        verdict.detail = unresolved;
-      } else {
+        const unresolved = run('git', ['diff', '--name-only', '--diff-filter=U'], temp).split('\n').filter(Boolean);
+        if (!unresolved.length) throw new Error(`git merge failed: ${merge.stderr.trim() || `exit ${merge.status}`}`);
+        if (unresolved.length === 1 && unresolved[0] === NEXT_MD_PATH) {
+          const stage = (n: number): string => {
+            const result = execute('git', ['show', `:${n}:${NEXT_MD_PATH}`], temp!);
+            if (result.status !== 0) throw new Error(`release/next.md stage ${n} unavailable: ${result.stderr}`);
+            return result.stdout;
+          };
+          // Stage 2 is main in this checkout; preserve the incoming PR (stage 3) and union main's additions.
+          const resolved = resolveNextMdConflict(stage(1), stage(2), stage(3));
+          if (resolved === null) {
+            verdict.verdict = 'conflict';
+            verdict.detail = 'release/next.md conflict is not append-only';
+          } else {
+            writeFileSync(join(temp, NEXT_MD_PATH), resolved);
+            run('git', ['add', '--', NEXT_MD_PATH], temp);
+            run('git', ['-c', 'user.name=elanous shadow', '-c', 'user.email=shadow@localhost', 'commit', '-m', 'Integrate PR for L8 shadow evaluation'], temp);
+            autoResolvedNextMd = true;
+          }
+        } else {
+          verdict.verdict = 'conflict';
+          verdict.detail = unresolved.join('\n');
+        }
+      }
+      if (merge.status === 0 || autoResolvedNextMd) {
         if (verdict.tests.length) {
           if (verdict.tests.some((file) => !existsSync(join(temp!, file)))) throw new Error('changed test path unavailable');
           run('bun', ['install', '--frozen-lockfile'], temp);
@@ -153,6 +174,9 @@ export async function runL8ShadowQueue(cwd: string, deps: L8ShadowQueueDeps = {}
         } else {
           verdict.verdict = 'pass';
         }
+        if (autoResolvedNextMd) {
+          verdict.detail = verdict.detail ? `release/next.md auto-resolved; ${verdict.detail}` : 'release/next.md auto-resolved';
+        }
       }
     } finally {
       try {

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,
@@ -1077,6 +1078,9 @@ export interface SelfImplementSeams {
   openPr: (opts: { title: string; body: string; head: string; base?: string; draft?: boolean; labels?: string[]; cwd: string }) => Promise<{ url: string; number: number }>;
   /** PR 생성 뒤 런의 라운드 대화를 게시한다. 실패는 PR 개설을 되돌리지 않는다. */
   postPrComment?: (opts: { number: number; body: string; cwd: string }) => Promise<void>;
+  /** Read and edit the single marked status comment; missing seams fall back to individual comments. */
+  findPrComment?: (opts: { number: number; marker: string; cwd: string; comments?: unknown }) => Promise<{ id: number; body: string } | undefined>;
+  editPrComment?: (opts: { id: number; body: string; cwd: string }) => Promise<void>;
   addPrLabel?: (opts: { number: number; label: string; cwd: string }) => Promise<void>;
   readPrFiles?: (opts: { number: number; cwd: string; base?: string }) => Promise<string[]>;
   /** PR의 base/head SHA와 관측된 PR base를 한 응답에서 고정한다. 미주입·실패·빈 SHA면 검사 대상을 증명할 수 없어 fail-closed로 PR을 열어 둔다. */
@@ -1154,6 +1158,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 라벨). */
@@ -3182,6 +3188,20 @@ function autoMergeEnabled(opts: Pick<SelfImplementOptions, 'completion' | 'autoM
   return completionIntentOf(opts) === 'auto-merge';
 }
 
+/**
+ * FREEZE-POD — a Pod child never merges its own PR. The host's landing freeze is invisible inside the Pod, so an
+ * auto-merge run there always stops at merge-ready and the launching host re-gates and merges (or holds it).
+ * Local (non-Pod) runs are returned unchanged.
+ */
+export function routePodMergeToHost<T extends Pick<SelfImplementOptions, 'completion' | 'autoMerge' | 'mergeByHost'>>(
+  opts: T, env: NodeJS.ProcessEnv = process.env,
+): { opts: T; reason: 'requested' | 'pod-child-auto-merge' | null } {
+  const podChild = env.ELANOUS_SUBSTRATE === 'pod' && Boolean(env.ELANOUS_POD_NAME?.trim());
+  if (!podChild || !autoMergeEnabled(opts)) return { opts, reason: null };
+  if (opts.mergeByHost === true) return { opts, reason: 'requested' };
+  return { opts: { ...opts, mergeByHost: true }, reason: 'pod-child-auto-merge' };
+}
+
 const SELF_IMPLEMENT_LOG_CATEGORY = 'self-implement';
 
 /** Emits a run-aware auxiliary log without admitting it to the run ledger. */
@@ -3465,6 +3485,12 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
   }
   const identity = resolveRunIdentity({ explicit: opts.runId });
   const { runId } = identity;
+  const podMerge = routePodMergeToHost(opts);
+  if (podMerge.reason) {
+    opts = podMerge.opts;
+    try { debug.log('self-implement.pod', 'merge-routed-to-host', { job: process.env.ELANOUS_POD_NAME ?? null, runId, reason: podMerge.reason }); }
+    catch { /* observation must not block the run */ }
+  }
   const branch = opts.branchName ?? plannedSelfImplBranch(opts.feature, opts.goalId, runId);
   try {
     debug.log('self-implement.branch', 'planned', {
@@ -5364,6 +5390,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 {
@@ -5440,9 +5467,11 @@ async function runSelfImplementInner(
     const omission = `\n\n[${omittedChars} characters omitted; original body length ${body.length}]`;
     prCommentBuffer.push(`${body.slice(0, MAX_PR_COMMENT_BODY_CHARS - omission.length)}${omission}`);
   };
-  const flushPrComments = async (pr: { number: number }): Promise<void> => {
+  let statusCommentCreateAttempted = false;
+  const flushPrComments = async (pr: { number: number }, salvageAction?: 'launched'): Promise<void> => {
     if (!prCommentBuffer.length) return;
     if (!s.postPrComment) {
+      observe('pr.comment.mode', { number: pr.number, mode: 'seam-missing', buffered: prCommentBuffer.length });
       observe('pr.comment.seam-missing', { number: pr.number, buffered: prCommentBuffer.length }, { level: 'warn' });
       return;
     }
@@ -5450,24 +5479,39 @@ async function runSelfImplementInner(
     if (s.findPrComment && s.editPrComment) {
       try {
         const existing = await s.findPrComment({ number: pr.number, marker, cwd: wt.path });
-        const history = prCommentBuffer.join('\n\n');
-        const body = existing
-          ? existing.body.includes('</details>')
-            ? existing.body.replace(/<\/details>(?![\s\S]*<\/details>)/, `\n\n${history}\n</details>`)
-            : `${existing.body}\n\n<details>\n<summary>Round history</summary>\n\n${history}\n</details>`
-          : `${marker}\n<details>\n<summary>Round history</summary>\n\n${history}\n</details>`;
-        if (existing) await s.editPrComment({ id: existing.id, body, cwd: wt.path });
-        else await s.postPrComment({ number: pr.number, body, cwd: wt.path });
+        if (!existing && statusCommentCreateAttempted) {
+          observe('pr.comment.mode', { number: pr.number, mode: 'individual-fallback', reason: 'status-creation-uncertain', buffered: prCommentBuffer.length });
+        } else {
+          const history = prCommentBuffer.join('\n\n');
+          const body = existing
+            ? existing.body.includes('</details>')
+              ? existing.body.replace(/<\/details>(?![\s\S]*<\/details>)/, `\n\n${history}\n</details>`)
+              : `${existing.body}\n\n<details>\n<summary>Round history</summary>\n\n${history}\n</details>`
+            : `${marker}\n<details>\n<summary>Round history</summary>\n\n${history}\n</details>`;
+          if (existing) await s.editPrComment({ id: existing.id, body, cwd: wt.path });
+          else {
+            statusCommentCreateAttempted = true;
+            await s.postPrComment({ number: pr.number, body, cwd: wt.path });
+          }
+          observe('pr.comment.mode', { number: pr.number, mode: existing ? 'status-updated' : 'status-created', buffered: prCommentBuffer.length });
+          prCommentBuffer.length = 0;
+        }
       } catch (error) {
         // Unknown lookup/edit outcome is not proof of absence: never create a second status comment.
         observe('pr.comment.status-failed', { number: pr.number, error: error instanceof Error ? error.message : String(error) }, { level: 'warn' });
+        observe('pr.comment.mode', { number: pr.number, mode: 'individual-fallback', reason: 'status-failed', buffered: prCommentBuffer.length });
       }
+    } else {
+      observe('pr.comment.mode', { number: pr.number, mode: 'individual-fallback', reason: 'status-seam-missing', buffered: prCommentBuffer.length });
     }
-    for (const body of prCommentBuffer) {
+    if (!prCommentBuffer.length) return;
+    const pending = prCommentBuffer.splice(0);
+    for (const body of pending) {
       try {
         await s.postPrComment({ number: pr.number, body, cwd: wt.path });
       } catch (error) {
-        observe('pr.comment.post-failed', { number: pr.number, error: error instanceof Error ? error.message : String(error) }, { level: 'warn' });
+        // Posting may have succeeded remotely even if the response failed; do not retry an uncertain comment.
+        observe('pr.comment.post-failed', { number: pr.number, ...(salvageAction && body.includes('Rework salvage status: launched.') ? { salvageAction } : {}), error: error instanceof Error ? error.message : String(error) }, { level: 'warn' });
       }
     }
   };
@@ -5818,7 +5862,13 @@ async function runSelfImplementInner(
   };
   const postSalvageStatus = async (pr: { number: number } | undefined, action: 'launched' | 'parked', reason?: string): Promise<void> => {
     if (!pr) return;
+    if (action === 'launched') {
+      bufferPrComment(round, 'author', 'Rework salvage status: launched.', reason ? [`reason: ${reason}`] : []);
+      await flushPrComments(pr, 'launched');
+      return;
+    }
     if (!s.postPrComment) {
+      observe('pr.comment.mode', { number: pr.number, mode: 'seam-missing', salvageAction: action });
       observe('pr.comment.seam-missing', { number: pr.number, salvageAction: action }, { level: 'warn' });
       return;
     }
@@ -5827,6 +5877,7 @@ async function runSelfImplementInner(
       `Rework salvage status: ${action}.`,
       ...(reason ? ['', `- reason: ${reason}`] : []),
     ].join('\n');
+    observe('pr.comment.mode', { number: pr.number, mode: 'individual', salvageAction: action });
     try {
       await s.postPrComment({ number: pr.number, body, cwd: wt.path });
     } catch (error) {
@@ -5996,7 +6047,7 @@ async function runSelfImplementInner(
       if (!s.launchReworkSalvage) throw new Error('launch seam unavailable');
       await s.launchReworkSalvage({ goalFile: opts.goalFile!, base: wt.branch, salvageAttempt: (opts.salvageAttempt ?? 0) + 1 });
       observe('rework-salvage', { action: 'launched', ...launchObservation });
-      await postSalvageStatus(pr, 'launched');
+      await postSalvageStatus(pr, 'launched', environmentReason ?? (hardCapBlockedExtend ? 'hard-cap-extend' : undefined));
       return 'launched';
     } catch (error) {
       const reason = 'launch-failed';
@@ -6175,6 +6226,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/self-implement/prior-draft-findings.ts

@@ -2,7 +2,7 @@ import { execFileSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { debug } from '../debug/log.js';
-import { parse as parsePrCommentMeta } from '../agent-substrate/pr-comment-meta.js';
+import { expandRecords, parse as parsePrCommentMeta } from '../agent-substrate/pr-comment-meta.js';
 
 export interface PriorDraftPr {
   number: number;
@@ -85,9 +85,10 @@ export async function collectPriorDraftFindings({
         continue;
       }
       const prActivity = Date.parse(pr.state.toUpperCase() === 'CLOSED' ? pr.closedAt ?? pr.createdAt : pr.createdAt);
+      const records = comments.flatMap((comment) => expandRecords(comment.body).map((body) => ({ ...comment, body })));
       // A PR bearing the current run's comment is this run's PR, not a predecessor.
-      if (comments.some((comment) => parsePrCommentMeta(comment.body)?.run === currentRunId)) continue;
-      const reviewers = comments.flatMap((comment) => {
+      if (records.some((comment) => parsePrCommentMeta(comment.body)?.run === currentRunId)) continue;
+      const reviewers = records.flatMap((comment) => {
         const meta = parsePrCommentMeta(comment.body);
         return meta?.role === 'reviewer' && meta.run && meta.round !== undefined
           ? [{ comment, meta }] : [];

package/src/skills/skill-feedback.ts

@@ -0,0 +1,76 @@
+import { appendFileSync, readFileSync } from 'node:fs';
+import { debug } from '../debug/log.js';
+
+export interface SkillRun {
+  skill: string;
+  runId: string;
+  outcome: 'success' | 'failure';
+  failureKind?: string;
+  userCorrected: boolean;
+  retries: number;
+  durationMs: number;
+  at: string;
+}
+
+export interface SkillFixProposal {
+  skill: string;
+  failureKind: string;
+  evidenceRunIds: string[];
+  suggestion: string;
+  expectedEffect: string;
+}
+
+/** Record one run at the caller-supplied ledger path; never touch a skill file. */
+export function appendSkillRun(ledgerPath: string, run: SkillRun): void {
+  appendFileSync(ledgerPath, `${JSON.stringify(run)}\n`, 'utf8');
+}
+
+/** Read the JSONL ledger in append order; an absent ledger has no runs. */
+export function readSkillRuns(ledgerPath: string): SkillRun[] {
+  let text: string;
+  try {
+    text = readFileSync(ledgerPath, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
+    throw error;
+  }
+  return text.split('\n').filter((line) => line.trim() !== '').map((line) => JSON.parse(line) as SkillRun);
+}
+
+/** Shadow-only suggestions for recurring failures within the same skill and failure kind. */
+export function proposeSkillFixes(
+  runs: readonly SkillRun[],
+  { threshold = 3 }: { threshold?: number } = {},
+): SkillFixProposal[] {
+  const grouped = new Map<string, Map<string, Map<string, SkillRun>>>();
+  for (const run of runs) {
+    if (run.outcome !== 'failure' || !run.failureKind) continue;
+    let kinds = grouped.get(run.skill);
+    if (!kinds) { kinds = new Map(); grouped.set(run.skill, kinds); }
+    let failures = kinds.get(run.failureKind);
+    if (!failures) { failures = new Map(); kinds.set(run.failureKind, failures); }
+    const previous = failures.get(run.runId);
+    if (!previous || run.at >= previous.at) failures.set(run.runId, run);
+  }
+
+  const proposals: SkillFixProposal[] = [];
+  for (const [skill, kinds] of grouped) {
+    for (const [failureKind, failures] of kinds) {
+      if (failures.size < threshold) continue;
+      const evidenceRunIds = [...failures.values()]
+        .map((run, index) => ({ run, index }))
+        .sort((a, b) => a.run.at.localeCompare(b.run.at) || a.index - b.index)
+        .slice(-3)
+        .map(({ run }) => run.runId);
+      proposals.push({
+        skill,
+        failureKind,
+        evidenceRunIds,
+        suggestion: `스킬 ${skill}의 ${failureKind} 실패 처리를 점검·개선하세요 — 같은 실패가 ${failures.size}번 반복됐습니다.`,
+        expectedEffect: `${skill}의 ${failureKind} 재발 감소`,
+      });
+      debug.log('skill.feedback', 'proposal', { skill, failureKind, runs: failures.size });
+    }
+  }
+  return proposals;
+}