elanous 0.2.17 → 0.2.19

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

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

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

@@ -20,12 +20,17 @@ function observeGoalAuthor(
 import { getUserConfig } from '../user-config.js';
 
 export type GoalAuthorGrade = 'full' | 'lite';
-export type GoalAuthorGradeSource = 'flag' | 'config' | 'default';
+export type GoalAuthorGradeSource = 'flag' | 'env' | '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 {
+/**
+ * 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' };
 }

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

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

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

@@ -1078,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을 열어 둔다. */
@@ -3185,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. */
@@ -3468,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', {
@@ -5358,6 +5381,7 @@ async function runSelfImplementInner(
       const { listSubscribers } = await import('../session/index.js');
       clarificationEscalation = await escalateGoalDocumentClarifications({
         goalFile: resolvedGoalFile,
+        runId,
         dispatchContext: clarificationDispatchContext,
         resolveOriginDelivery: (sessionId) => originHitlDelivery(listSubscribers(sessionId)),
         // ⛔ seam 이 주입되면 전역 리졸버는 «불리지 않는다» — 그때 'terminal' 이라 적으면
@@ -5444,9 +5468,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;
     }
@@ -5454,24 +5480,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' });
       }
     }
   };
@@ -5822,7 +5863,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;
     }
@@ -5831,6 +5878,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) {
@@ -6000,7 +6048,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';
@@ -6184,7 +6232,7 @@ async function runSelfImplementInner(
                     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,
+                      path: 'rework', ask: source, resolver: s.selfResolveClarification, runId,
                     });
                     if (resolved.newlyAnswered > 0) writeGoalDocumentAtomic(opts.goalFile, resolved.document);
                   } catch (error) {

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 }] : [];