elanous 0.2.21 → 0.2.22

package/src/self-implement/l8-merge-queue.ts

@@ -1,8 +1,9 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { NEXT_MD_PATH, resolveNextMdConflict } from '../release-loop/next-md-merge.js';
+import { defaultLlmResolve, mergeMainWithLlmResolve, type MergeGitSeam } from '../autopilot/build/llm-conflict-merge.js';
 import { getDefaultLogStore } from '../mss/logging/log-store.js';
 
 type Command = (bin: string, args: readonly string[], cwd: string) => { status: number | null; stdout: string; stderr: string };
@@ -30,7 +31,10 @@ export type L8MergeQueueDeps = {
 
 export type L8ShadowVerdict = { number: number; head: string; base?: string; verdict: 'pass' | 'conflict' | 'fail'; detail?: string; tests: string[]; at: string };
 export type L8ShadowQueueState = { pending: { number: number; head: string }[]; verdicts: L8ShadowVerdict[] };
-export type L8ShadowQueueDeps = L8MergeQueueDeps & { observe?: (verdict: L8ShadowVerdict) => void | Promise<void> };
+export type L8ShadowQueueDeps = L8MergeQueueDeps & {
+  observe?: (verdict: L8ShadowVerdict) => void | Promise<void>;
+  resolveConflict?: (file: string, conflicted: string, target: string, worktree: string) => Promise<string>;
+};
 
 function shadowCommand(execute: Command, bin: string, args: string[], cwd: string): string {
   const result = execute(bin, args, cwd);
@@ -129,7 +133,8 @@ 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;
+      let integrated = merge.status === 0;
+      let resolvedNextMd = false;
       if (merge.status !== 0) {
         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}`}`);
@@ -148,14 +153,81 @@ export async function runL8ShadowQueue(cwd: string, deps: L8ShadowQueueDeps = {}
             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;
+            resolvedNextMd = true;
+            integrated = true;
           }
         } else {
-          verdict.verdict = 'conflict';
-          verdict.detail = unresolved.join('\n');
+          const unsafe = unresolved.some((file) => file.startsWith('-') || file.startsWith('/') || file.split('/').includes('..') || file.includes('\\'));
+          if (unsafe) throw new Error('unsafe conflict path');
+          const staged = (stage: number, file: string): string | null => {
+            const result = execute('git', ['show', `:${stage}:${file}`], temp!);
+            return result.status === 0 ? result.stdout : null;
+          };
+          // Reject unsupported index shapes before consulting either resolver.
+          // A directory, submodule or unreadable path is an unsupported conflict shape, not an evaluator failure.
+          const hasTextMarkers = (file: string): boolean => {
+            try {
+              const path = join(temp!, file);
+              return existsSync(path) && statSync(path).isFile() && readFileSync(path, 'utf8').includes('<<<<<<< ');
+            } catch {
+              return false;
+            }
+          };
+          const unsupported = unresolved.some((file) => file !== NEXT_MD_PATH && !hasTextMarkers(file));
+          // A non-append-only next.md conflict must not fall through to the LLM even when other files conflict.
+          const nextStages = !unsupported && unresolved.includes(NEXT_MD_PATH)
+            ? [staged(1, NEXT_MD_PATH), staged(2, NEXT_MD_PATH), staged(3, NEXT_MD_PATH)] as const
+            : undefined;
+          const nextMd = nextStages
+            ? nextStages.some((value) => value === null) ? null
+              : resolveNextMdConflict(nextStages[0]!, nextStages[1]!, nextStages[2]!)
+            : undefined;
+          if (unsupported || nextMd === null || unresolved.some((file) => file !== NEXT_MD_PATH
+            && (staged(1, file) === null || staged(2, file) === null || staged(3, file) === null))) {
+            verdict.verdict = 'conflict';
+            verdict.detail = nextMd === null ? 'release/next.md conflict is not append-only' : unresolved.join('\n');
+          } else {
+            const git = (args: string[]) => execute('git', args, temp!);
+            const mergeGit: MergeGitSeam = {
+              isConfiguredRemote: () => false, // item.head is the fetched, pinned commit, not a remote branch.
+              fetch: () => false,
+              merge: () => ({ ok: false, conflict: true, stdout: merge.stdout, errorDetail: merge.stderr.trim() }),
+              conflictedFiles: () => run('git', ['diff', '--name-only', '--diff-filter=U'], temp!).split('\n').filter(Boolean),
+              readIndexStage: (_wt, stage, file) => {
+                const result = git(['show', `:${stage}:${file}`]);
+                if (result.status !== 0) throw new Error(`index stage ${stage} unavailable: ${file}`);
+                return result.stdout;
+              },
+              readFile: (file) => readFileSync(file, 'utf8'),
+              writeFile: (file, content) => writeFileSync(file, content),
+              add: (_wt, file) => { run('git', ['add', '--', file], temp!); },
+              commit: () => {
+                const result = git(['-c', 'user.name=elanous shadow', '-c', 'user.email=shadow@localhost', 'commit', '-m', 'Integrate PR for L8 shadow evaluation']);
+                return { ok: result.status === 0, errorDetail: result.stderr.trim() };
+              },
+              abort: () => { run('git', ['merge', '--abort'], temp!); },
+            };
+            const resolved = await mergeMainWithLlmResolve(temp, item.head, async (file, conflicted) => {
+              if (file === NEXT_MD_PATH) {
+                const next = resolveNextMdConflict(mergeGit.readIndexStage(temp!, 1, file), mergeGit.readIndexStage(temp!, 2, file), mergeGit.readIndexStage(temp!, 3, file));
+                if (next === null) throw new Error('release/next.md conflict is not append-only');
+                return next;
+              }
+              return (deps.resolveConflict ?? ((path, content, target, worktree) => defaultLlmResolve(path, content, target, { worktreePath: worktree, mode: 'on' })))(file, conflicted, item.head, temp!);
+            }, mergeGit);
+            if (resolved.status === 'conflict-unresolved') {
+              verdict.verdict = 'conflict';
+              verdict.detail = resolved.failedFile === NEXT_MD_PATH ? 'release/next.md conflict is not append-only'
+                : `${resolved.failedFile ?? 'merge conflict'}: ${resolved.reason ?? 'context resolution failed'}`;
+            } else if (resolved.status === 'error') {
+              throw new Error(`git merge failed: ${resolved.errorStep}: ${resolved.errorDetail ?? 'unknown error'}`);
+            }
+            integrated = resolved.status === 'llm-resolved';
+            resolvedNextMd = integrated && resolved.resolvedFiles?.includes(NEXT_MD_PATH) === true;
+          }
         }
       }
-      if (merge.status === 0 || autoResolvedNextMd) {
+      if (integrated) {
         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);
@@ -174,7 +246,7 @@ export async function runL8ShadowQueue(cwd: string, deps: L8ShadowQueueDeps = {}
         } else {
           verdict.verdict = 'pass';
         }
-        if (autoResolvedNextMd) {
+        if (resolvedNextMd) {
           verdict.detail = verdict.detail ? `release/next.md auto-resolved; ${verdict.detail}` : 'release/next.md auto-resolved';
         }
       }

package/src/self-implement/orchestrator.ts

@@ -434,7 +434,7 @@ function resolveDefaultBranchTarget(
  * 🔑 실패일 때만 두 칸을 더한다 — 성공 경로 payload 를 바꾸면 기존 소비자가 흔들린다.
  *   `moduleLoadFailure` 는 ***「산출이 상했다」와 「그 순간 트리가 불일치했다」***를 가르는 값이다.
  */
-type PostSyncStatus = 'merged' | 'llm-resolved';
+type PostSyncStatus = 'merged' | 'llm-resolved' | 'deterministic-resolved';
 
 type PostSyncGatePolicy = {
   exempted: boolean;
@@ -495,7 +495,7 @@ function postSyncGatePolicy(
     && !introduced && childResponsibility === 'none'
     && syncStatus === 'llm-resolved';
   const exempted = !passed
-    && (timeoutOnly || (!introduced && childResponsibility === 'none' && syncStatus === 'merged'));
+    && (timeoutOnly || (!introduced && childResponsibility === 'none' && (syncStatus === 'merged' || syncStatus === 'deterministic-resolved')));
   return {
     exempted,
     exemptionWithheld,
@@ -2256,6 +2256,8 @@ export interface SelfImplementResult {
   branch?: string;
   gate?: SelfImplementGateResult;
   review?: SelfImplementReview;
+  /** Worktree commit observed while this review ran; not inferred from the later PR head. */
+  reviewedHeadCommit?: string;
   completionDisposition?: SelfImplementCompletionDisposition;
   /** Explicit supervisor rework verdict retained independently of workflow execution verdicts. */
   supervisorVerdict?: ReworkBudgetVerdict;
@@ -2362,7 +2364,18 @@ function truncatePrTitle(text: string): string {
   return points.length <= 72 ? text : `${points.slice(0, 69).join('')}...`;
 }
 
-export function prTitle(feature: string): string {
+export function goalChecklistIds(feature: string, goalFile?: string): string[] {
+  const document = goalFile ? goalDocumentForReleaseNote(goalFile) : feature;
+  const declaration = document.split(/\r?\n/).find((line) => line.startsWith('- 칸 id: '));
+  const declared = declaration?.slice('- 칸 id: '.length).trim();
+  if (declared && declared !== 'not declared') {
+    return [...new Set(declared.split(' · ').map((id) => id.trim()).filter(Boolean))];
+  }
+  const firstLine = feature.split(/\r?\n/, 1)[0] ?? '';
+  return [...new Set(Array.from(firstLine.matchAll(/\b[A-Z][A-Z0-9]+-[A-Z0-9]+\b/g), (match) => match[0]))];
+}
+
+function prTitleWithoutChecklistId(feature: string): string {
   const proseTitle = parseAskProseTitle(feature);
   if (proseTitle) return truncatePrTitle(proseTitle);
 
@@ -2405,6 +2418,13 @@ export function prTitle(feature: string): string {
   return truncatePrTitle(firstFileName);
 }
 
+export function prTitle(feature: string, goalFile?: string): string {
+  const title = prTitleWithoutChecklistId(feature);
+  const id = goalChecklistIds(feature, goalFile)[0];
+  if (!id) return title;
+  return truncatePrTitle(title.startsWith(`${id}: `) ? title : `${id}: ${title}`);
+}
+
 const BLOCKED_DRAFT_PR_HUMAN_JUDGMENT_ANCHOR = '## 사람 판단 필요';
 
 /** 사람이 읽는 중단 사유 상한. 관측 `reason.slice(0, 240)` 과 같은 길이라 표시가 앞부분을 버리지 않는다. */
@@ -2665,6 +2685,7 @@ function prBody(feature: string, implSummary: string, gateLog?: string, review?:
     ? ['', '## 감독 수용 기준 완화', `- 대상: ${planRevision.relaxation.target}`, `- 이전: ${planRevision.relaxation.expected}`, `- 완화: ${planRevision.relaxation.replacement}`, `- 이유: ${planRevision.reason}`, `- 적용: ${planRevision.application?.status ?? 'failed'}${planRevision.application?.detail ? ` (${planRevision.application.detail})` : ''}`, ...(planRevision.disposition ? [`- 충돌 처분: ${planRevision.disposition}`] : [])]
     : [];
   return [
+    `칸: ${goalChecklistIds(feature, goalFile).join(' · ') || '없음'}`,
     '## 요청',
     ...(goalFile ? [`- 골 파일: ${formatGoalFileForPrBody(goalFile)}`] : []),
     feature.trim(),
@@ -2882,6 +2903,7 @@ export function formatBlockedDraftClassificationSection(
 
 function blockedDraftPrBody(feature: string, implSummary: string, state: BlockedDraftPrState, goalFile?: string): string {
   return [
+    `칸: ${goalChecklistIds(feature, goalFile).join(' · ') || '없음'}`,
     BLOCKED_DRAFT_PR_HUMAN_JUDGMENT_ANCHOR,
     state.salvageStatusExpected
       ? BLOCKED_DRAFT_PR_SALVAGE_STATUS_INSTRUCTION
@@ -3638,7 +3660,7 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
     }
     try {
       const pushed = opts.seams.preserveBlockedBranch
-        ? await opts.seams.preserveBlockedBranch({ cwd: worktreePath, branch, title: prTitle(opts.feature), commit: preSyncCommit })
+        ? await opts.seams.preserveBlockedBranch({ cwd: worktreePath, branch, title: prTitle(opts.feature, opts.goalFile), commit: preSyncCommit })
         : runGitCommand(worktreePath, ['push', '-u', 'origin', `${preSyncCommit}:refs/heads/${branch}`]).status === 0;
       if (!pushed) throw new Error('branch push failed');
       // The worktree is left untouched: a late merge may still be writing it. The harvest source is the pinned commit.
@@ -4963,7 +4985,7 @@ async function runSelfImplementInner(
     role: describeRole({ role: 'executor', executorKind: 'self' }),
     entry: siEntry, capabilities: [...siCaps.active], enhanceActive,
   });
-  progress('start', `🔨 self-implement 시작 — ${prTitle(opts.feature)}`);
+  progress('start', `🔨 self-implement 시작 — ${prTitle(opts.feature, opts.goalFile)}`);
 
   let sessionId: string | undefined;
   if (opts.parentSessionId && s.forkSession) {
@@ -5202,6 +5224,7 @@ async function runSelfImplementInner(
   /** GATE-ENV-RETRY: 재시도 뒤에도 남은 환경 결손의 종류. 정의되면 이 라운드의 gate 실패는 «수확 대기»로 끝난다. */
   let gateEnvDeficitKind: GateEnvDeficitKind | undefined;
   let review: SelfImplementReview | undefined;
+  let reviewedHeadCommit: string | undefined;
   /** Review-budget leftovers and the body that carried them, so a later merge drafts from the same text. */
   let preparedReviewBudgetPrBody: string | undefined;
   const reviewMustFixCountHistory: number[] = [];
@@ -5791,11 +5814,11 @@ async function runSelfImplementInner(
             throw new Error(`worktree not found: ${wt.path}`);
           }
           if (s.preserveBlockedBranch) {
-            pushed = await s.preserveBlockedBranch({ cwd: wt.path, branch: wt.branch, title: prTitle(opts.feature) });
+            pushed = await s.preserveBlockedBranch({ cwd: wt.path, branch: wt.branch, title: prTitle(opts.feature, opts.goalFile) });
             if (!pushed) throw new Error('브랜치 push가 성공하지 않았음');
           } else {
             preservationErrorStep = 'commit';
-            const commit = commitWorktree(wt.path, prTitle(opts.feature));
+            const commit = commitWorktree(wt.path, prTitle(opts.feature, opts.goalFile));
             if (!commit.ok && !/nothing to commit/.test(commit.out)) throw new Error(commit.out);
             committed = commit.ok;
             if (runGitCommand(wt.path, ['remote', 'get-url', 'origin']).status === 0) {
@@ -5875,10 +5898,10 @@ async function runSelfImplementInner(
       let salvageError: string | undefined;
       try {
         if (s.preserveBlockedBranch) {
-          if (!await s.preserveBlockedBranch({ cwd: wt.path, branch: salvageBranch, title: prTitle(opts.feature) })) throw new Error('수확 가지 push가 성공하지 않았음');
+          if (!await s.preserveBlockedBranch({ cwd: wt.path, branch: salvageBranch, title: prTitle(opts.feature, opts.goalFile) })) throw new Error('수확 가지 push가 성공하지 않았음');
         } else {
           if (!existsSync(wt.path)) throw new Error(`worktree not found: ${wt.path}`);
-          const commit = commitWorktree(wt.path, prTitle(opts.feature));
+          const commit = commitWorktree(wt.path, prTitle(opts.feature, opts.goalFile));
           if (!commit.ok && !/nothing to commit/.test(commit.out)) throw new Error(`로컬 커밋 실패: ${commit.out}`);
           const push = runGitCommand(wt.path, ['push', 'origin', `HEAD:refs/heads/${salvageBranch}`]);
           if (push.status !== 0) throw new Error(push.stderr || push.stdout || 'git push failed');
@@ -5915,10 +5938,10 @@ async function runSelfImplementInner(
       let pushed = false;
       try {
         if (s.preserveBlockedBranch) {
-          pushed = await s.preserveBlockedBranch({ cwd: wt.path, branch: wt.branch, title: prTitle(opts.feature) });
+          pushed = await s.preserveBlockedBranch({ cwd: wt.path, branch: wt.branch, title: prTitle(opts.feature, opts.goalFile) });
         } else {
           if (commitFirst) {
-            const commit = commitWorktree(wt.path, prTitle(opts.feature));
+            const commit = commitWorktree(wt.path, prTitle(opts.feature, opts.goalFile));
             if (!commit.ok && !/nothing to commit/.test(commit.out)) throw new Error(`로컬 브랜치 커밋 실패: ${commit.out}`);
           }
           const push = runGitCommand(wt.path, ['push', '-u', 'origin', `HEAD:refs/heads/${wt.branch}`]);
@@ -5942,7 +5965,7 @@ async function runSelfImplementInner(
     if (stage === 'review-blocked' && podReviewBlockedDraft) {
       let commitError: string | undefined;
       try {
-        const commit = commitWorktree(wt.path, prTitle(opts.feature));
+        const commit = commitWorktree(wt.path, prTitle(opts.feature, opts.goalFile));
         if (!commit.ok && !/nothing to commit/.test(commit.out)) commitError = commit.out.trim() || 'git commit failed';
       } catch (error) {
         commitError = safeErrorDescription(error);
@@ -5954,7 +5977,7 @@ async function runSelfImplementInner(
     let pr: { url: string; number: number };
     try {
       pr = await withStepTimeout(s.openPr({
-        title: prTitle(opts.feature),
+        title: prTitle(opts.feature, opts.goalFile),
         body: assembled.body,
         head: wt.branch,
         ...(opts.base ? { base: opts.base } : {}),
@@ -6110,7 +6133,7 @@ async function runSelfImplementInner(
     );
     preparedReviewBudgetPrBody = preparedPrBody.body;
     const pr = await withStepTimeout(s.openPr({
-      title: prTitle(opts.feature),
+      title: prTitle(opts.feature, opts.goalFile),
       body: preparedPrBody.body,
       head: wt.branch,
       ...(opts.base ? { base: opts.base } : {}),
@@ -6826,7 +6849,7 @@ async function runSelfImplementInner(
             && targets.some((target) => changedFileIsInsideDeclaredTarget(path, target)));
         if (eligible.length) {
           inspectStaleReverts(revertGuardTargetPaths(opts.feature, goalDocument));
-          const message = `self-implement: ${prTitle(opts.feature)}`;
+          const message = `self-implement: ${prTitle(opts.feature, opts.goalFile)}`;
           let outcome: { ok: boolean; out: string };
           try {
             outcome = (s.commitFinishedChildWork ?? ((cwd, paths, title) => {
@@ -7347,6 +7370,7 @@ async function runSelfImplementInner(
     lastReviewContext = reviewContext;
     reviewIntent = buildReviewIntent(reviewContext);
 
+    reviewedHeadCommit = undefined;
     if (s.reviewDiff) {
       try {
         const stoppedBeforeReview = honorParentSoftStop('review');
@@ -7356,7 +7380,18 @@ async function runSelfImplementInner(
         }
         onNodeEntry(node('review'), round);
         progress('reviewing', '내부 리뷰 (리뷰어 비평)…');
+        const readReviewHead = s.headCommit ?? ((cwd: string) => {
+          const commit = runGitCommand(cwd, ['rev-parse', '--verify', 'HEAD'], { encoding: 'utf8', timeout: 10_000 });
+          return commit.status === 0 ? commit.stdout.trim() : undefined;
+        });
+        const headBeforeReview = readReviewHead(wt.path);
+        const statusBeforeReview = runGitCommand(wt.path, ['status', '--porcelain'], { encoding: 'utf8', timeout: 10_000 });
         review = await withStepTimeout(s.reviewDiff(wt.path, reviewContext), T.review, 'review');
+        const statusAfterReview = runGitCommand(wt.path, ['status', '--porcelain'], { encoding: 'utf8', timeout: 10_000 });
+        reviewedHeadCommit = review.reviewed && headBeforeReview && /^[0-9a-f]{40}$/i.test(headBeforeReview)
+          && statusBeforeReview.status === 0 && statusBeforeReview.stdout.trim() === ''
+          && statusAfterReview.status === 0 && statusAfterReview.stdout.trim() === ''
+          && headBeforeReview === readReviewHead(wt.path) ? headBeforeReview : undefined;
       } catch (error) {
         finalizeSupervisorDeliveries(error instanceof StepTimeoutError ? 'next-round-review-timeout' : 'next-round-review-failed');
         throw error;
@@ -7595,6 +7630,7 @@ async function runSelfImplementInner(
     ? { completionDisposition }
     : {};
   const reviewReal = !!review?.reviewed;
+  const reviewedHeadResult = reviewReal && reviewedHeadCommit ? { reviewedHeadCommit } : {};
   const reviewDiffComplete = review?.diffTruncated === false;
   const requiredEvidenceMissing = evidenceCoverage !== undefined && evidenceCoverage.uncoveredCount > 0;
   const { latestSignalIncomplete } = signalIncompleteState(roundClassifications);
@@ -7680,7 +7716,7 @@ async function runSelfImplementInner(
       try { goalDocument = readFileSync(opts.goalFile, 'utf8'); } catch { /* no documented targets */ }
     }
     inspectStaleReverts(revertGuardTargetPaths(opts.feature, goalDocument));
-    s.commitWork(wt.path, prTitle(opts.feature));
+    s.commitWork(wt.path, prTitle(opts.feature, opts.goalFile));
     // ⛔⭐ resume 경로와 «같은» 해석기를 쓴다 — 두 자리가 갈리면 같은 원인이 다른 얼굴로 나온다.
     const resolvedTarget = resolveDefaultBranchTarget(s.defaultBranchRef ?? defaultBranchRef, wt.path);
     const mergeTarget = resolvedTarget.target;
@@ -7725,9 +7761,9 @@ async function runSelfImplementInner(
         && await preserveMergeHarvest(sync.reason, sync.inputChars);
       return { ok: false, stage: 'merge-conflict', node: 'main-sync', ...resolveRunOutcome({ termination: 'abandoned' }), ...decisionSignalResult, sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...(harvestable ? { harvestable: true } : {}), detail: harvestable ? sync.reason === 'conflict-input-too-large' ? `충돌 큼 — 사람 수확 (${wt.branch}, 입력 ${sync.inputChars}자)` : `충돌 해결 중단 — 사람 수확 (${wt.branch})` : `pre-PR main sync ${sync.status}` };
     }
-    if (sync.status === 'llm-resolved' || sync.status === 'merged') {
+    if (sync.status === 'llm-resolved' || sync.status === 'merged' || sync.status === 'deterministic-resolved') {
       preservationBase = opts.base ?? mergeTarget;
-      progress('gating', sync.status === 'llm-resolved'
+      progress('gating', sync.status === 'llm-resolved' || sync.status === 'deterministic-resolved'
         ? `${mergeTarget} 충돌해결됨 — ${formatLlmMergeOutcome(sync)} — 통합 결과 full 재-gate…`
         : `${mergeTarget} 정합됨 — 통합 결과 full 재-gate…`);
       onNodeEntry('regate', round);
@@ -7880,7 +7916,7 @@ async function runSelfImplementInner(
   let pr: { url: string; number: number };
   try {
     pr = await withStepTimeout(s.openPr({
-      title: prTitle(opts.feature),
+      title: prTitle(opts.feature, opts.goalFile),
       body: preparedPrBody.body,
       head: wt.branch,
       ...(opts.base ? { base: opts.base } : {}),
@@ -7902,6 +7938,11 @@ async function runSelfImplementInner(
     progress('aborted', formatPrOpenFailedProgress(location, prErrorFirstLine));
     throw new Error(`${location}\n${prError}`);
   }
+  // PR creation may commit generated body/release notes or sync the base after review. Never bind an old review to that new head.
+  if (reviewedHeadCommit) {
+    const current = runGitCommand(wt.path, ['rev-parse', '--verify', 'HEAD'], { encoding: 'utf8', timeout: 10_000 });
+    if (current.status !== 0 || current.stdout.trim() !== reviewedHeadCommit) delete reviewedHeadResult.reviewedHeadCommit;
+  }
   observe('pr-opened', {
     url: pr.url,
     number: pr.number,
@@ -7951,7 +7992,7 @@ async function runSelfImplementInner(
     }
     recordMergeDecision();
     progress('pr-opened', `OP 승인 대기 (#${pr.number}): ${releaseHoldPath}`);
-    return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), mergeReason, prUrl: pr.url, prNumber: pr.number, detail: `OP approval required: ${releaseHoldPath}` };
+    return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason, prUrl: pr.url, prNumber: pr.number, detail: `OP approval required: ${releaseHoldPath}` };
   }
   if (!releasePathInspectionError && labels?.includes(AUTO_REVIEW_LABEL)) {
     try {
@@ -7969,7 +8010,7 @@ async function runSelfImplementInner(
       : 'release-path-inspection-failed';
     recordMergeDecision();
     progress('pr-opened', `OP 승인 대기 (#${pr.number}): PR 경로 조회 실패`);
-    return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), mergeReason, prUrl: pr.url, prNumber: pr.number };
+    return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason, prUrl: pr.url, prNumber: pr.number };
   }
 
   if (canAuto && (s.mergePr || opts.mergeByHost)) {
@@ -8019,12 +8060,12 @@ async function runSelfImplementInner(
       //    판정(mergeReason)이 아니라 «집행 직전 가드»가 막았으므로 그 사실을 값으로 말한다.
       //    ⛔ 안 그러면 마지막 줄이 침묵하고, 그건 이 착지가 없애려던 상태다(리뷰 must-fix 2R).
       const guardSkipReason = mergeSkipReason ?? (guardFailure ? 'merge-guard-unevaluated' : 'docs-deletion-threshold');
-      return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), mergeReason: guardSkipReason, prUrl: pr.url, prNumber: pr.number, detail };
+      return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason: guardSkipReason, prUrl: pr.url, prNumber: pr.number, detail };
     }
     if (opts.mergeByHost) {
       observe('merge-ready', { number: pr.number, checkedHeadCommit });
       progress('pr-opened', `호스트 재게이트 대기 (#${pr.number})`);
-      return { ok: true, stage: 'merge-ready', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), checkedHeadCommit: checkedHeadCommit!, prUrl: pr.url, prNumber: pr.number };
+      return { ok: true, stage: 'merge-ready', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, checkedHeadCommit: checkedHeadCommit!, prUrl: pr.url, prNumber: pr.number };
     }
     // Landing freeze: the in-flight marker is written before the freeze is read, so a `freeze on` racing this merge waits.
     // The resume sweep merges from the repository that owns the run worktree (the worktree itself may be cleaned up).
@@ -8036,13 +8077,13 @@ async function runSelfImplementInner(
     };
     const landing = admitLandingMerge(heldEntry, undefined, {}, { prNumber: pr.number, repoRoot: owningRepoRoot(wt.path) ?? wt.path, ...(checkedHeadCommit ? { headCommit: checkedHeadCommit } : {}) });
     if (landing.kind === 'held' && !(checkedHeadCommit && /^[0-9a-f]{40}$/i.test(checkedHeadCommit))) {
-      return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), mergeReason: 'merge-guard-unevaluated', prUrl: pr.url, prNumber: pr.number, detail: 'freeze: checked head SHA unavailable; PR left ready for review' };
+      return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason: 'merge-guard-unevaluated', prUrl: pr.url, prNumber: pr.number, detail: 'freeze: checked head SHA unavailable; PR left ready for review' };
     }
     if (landing.kind !== 'merge') {
       const detail = landing.kind === 'held' ? landingFreezeMessage(landing.freeze) : 'freeze lifted; a resume sweep is merging this PR';
       debug.log('harness.merge', 'frozen', { pr: pr.number, ...(landing.kind === 'held' ? { reason: landing.freeze.reason, until: landing.freeze.until } : { resumedElsewhere: true }) });
       progress('pr-opened', `#${pr.number} ready · ${detail}`);
-      return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), mergeReason: landing.kind === 'held' ? 'frozen' : 'resumed-elsewhere', prUrl: pr.url, prNumber: pr.number, detail };
+      return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason: landing.kind === 'held' ? 'frozen' : 'resumed-elsewhere', prUrl: pr.url, prNumber: pr.number, detail };
     }
     // The marker and claim live until the merge call itself settles — a step timeout does not stop a merge already
     // sent — and anything that throws before the merge call is made releases them.
@@ -8132,10 +8173,10 @@ async function runSelfImplementInner(
     //    그대로 두면 마지막 산출 줄이 «침묵»한다 — 이 착지가 없애려던 바로 그 상태다(리뷰 must-fix).
     //    ⇒ 판정이 아니라 «집행»에서 막힌 것이므로 그 사실을 별도 값으로 말한다.
     const mergeAttemptSkipReason = mergeSkipReason ?? 'merge-attempt-failed';
-    return { ok: true, stage: 'pr-opened', node: 'merge', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), mergeReason: mergeAttemptSkipReason, merged: false, prUrl: pr.url, prNumber: pr.number, ...(m.detail ? { detail: m.detail } : {}) };
+    return { ok: true, stage: 'pr-opened', node: 'merge', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, mergeReason: mergeAttemptSkipReason, merged: false, prUrl: pr.url, prNumber: pr.number, ...(m.detail ? { detail: m.detail } : {}) };
   }
   progress('pr-opened', `✅ PR 개설 (#${pr.number})`);
-  return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...(lastSupervisorReason ? { supervisorReason: lastSupervisorReason } : {}), ...(mergeSkipReason ? { mergeReason: mergeSkipReason } : {}), prUrl: pr.url, prNumber: pr.number };
+  return { ok: true, stage: 'pr-opened', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, ...(lastSupervisorReason ? { supervisorReason: lastSupervisorReason } : {}), ...(mergeSkipReason ? { mergeReason: mergeSkipReason } : {}), prUrl: pr.url, prNumber: pr.number };
 }
 
 /** 결정적 요청 거부 — 같은 요청을 다시 보내면 «같은» 답이 온다(BACKLOG B6).

package/src/self-implement/seams.ts

@@ -986,7 +986,7 @@ export interface DefaultSeamsOptions {
   runAndroidUnitTestGate?: (io: { args: readonly string[]; cwd: string }) => number;
   runIosUnitTestGate?: (io: { args: readonly string[]; cwd: string }) => number;
   /** Source-policy gate adapter for focused seam tests. */
-  runHarnessPolicyGates?: typeof runHarnessPolicyGates;
+  runHarnessPolicyGates?: (input: Parameters<typeof runHarnessPolicyGates>[0]) => Awaited<ReturnType<typeof runHarnessPolicyGates>> | ReturnType<typeof runHarnessPolicyGates>;
   runExposeGate?: typeof runExposeGate;
   /** Dependency-wide validation adapter for focused seam tests. */
   runDependencyChangeGate?: typeof runDependencyChangeGate;
@@ -1020,6 +1020,8 @@ export interface DefaultSeamsOptions {
    *  agent-substrate·staged 하니스와 동일 엔진) 배선. 미주입 시 reviewDiff 미노출(gate 통과=바로 병합결정·
    *  리뷰 스킵). dev-harness 의 llmReview 와 동일 형태(streamLLM 래퍼). */
   llmReview?: (prompt: string) => Promise<string>;
+  /** Optional independent reviewer for reviewDiff only; other judgment calls retain llmReview. */
+  subscriptionReviewLLM?: (prompt: string) => Promise<string>;
   /**
    * 이 리뷰 심이 파일을 스스로 읽을 수 있나. **선택 선언** — 안 주면 reviewDiff 가 칸을 만들지 않고
    * 오케스트레이터 관측은 `'unknown'` 이다(`false` 와 같은 값으로 접지 않는다).
@@ -2073,7 +2075,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       //   tsc-깨짐(F1 refFacts 미정의)을 결정론 차단. 변경 전체(.ts·테스트 포함)를 tsc 로 검사(변경 경로만 카운트).
       const tc = changedFileTypecheck(cwd, changedAll);
       debug.log('self-implement', 'gate.tsc', { checked: tc.checked, passed: tc.passed, errors: tc.errors, exempted: tc.exempted, noInspectionReason: tc.noInspectionReason }, { level: tc.passed ? 'info' : 'warn' });
-      const policy = (o.runHarnessPolicyGates ?? runHarnessPolicyGates)({ cwd, changedFiles: changedAll });
+      const policy = await (o.runHarnessPolicyGates ?? runHarnessPolicyGates)({ cwd, changedFiles: changedAll });
       debug.log('self-implement', 'gate.policy', {
         passed: policy.passed, failures: policy.failures.map((failure) => failure.gate), skipped: policy.skipped,
       });
@@ -2530,7 +2532,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
               ...(ctx.round !== undefined ? { round: ctx.round } : {}),
             },
           } : {}),
-        }, o.llmReview!);
+        }, o.subscriptionReviewLLM ?? o.llmReview!);
         debug.log('self-implement', 'review.done', {
           verdict: rr.verdict, reviewed: rr.reviewed ?? false, mustFix: rr.mustFix.length, shouldFix: rr.shouldFix.length,
           gateEvidenceLines: evidenceNote?.split(/\r?\n/).length ?? 0,

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

@@ -111,6 +111,7 @@ export function singleRunAsJobResult(feature: string, r: SelfImplementResultWith
     ...(r.harvestable === true && r.branch ? { harvestable: true } : {}),
     ...(r.worktreePath ? { worktreePath: r.worktreePath } : {}),
     ...(r.prUrl ? { prUrl: r.prUrl } : {}),
+    ...(r.prNumber !== undefined ? { prNumber: r.prNumber } : {}),
     // TA-LIVE-REVIEW-POD — 작업 트리 없는 런(Pod)의 live review 가 «런이 낸 PR 머리»를 확인하는 근거.
     ...(r.checkedHeadCommit !== undefined ? { checkedHeadCommit: r.checkedHeadCommit } : {}),
     ...(r.merged !== undefined ? { merged: r.merged } : {}),
@@ -121,6 +122,9 @@ export function singleRunAsJobResult(feature: string, r: SelfImplementResultWith
     ...(r.decomposeProposal ? { decomposeProposal: r.decomposeProposal } : {}),
     ...(r.goalPlanRevision ? { goalPlanRevision: r.goalPlanRevision } : {}),
     ...(r.salvage !== undefined ? { salvage: r.salvage } : {}),
+    ...(r.review?.reviewed === true && r.review.verdict === 'pass'
+      && r.reviewedHeadCommit && /^[0-9a-f]{40}$/i.test(r.reviewedHeadCommit)
+      ? { selfReview: { verdict: r.review.verdict, head: r.reviewedHeadCommit } } : {}),
     ...(r.review?.reviewed !== undefined ? { reviewed: r.review.reviewed } : {}),
     ...(r.review?.failureReason !== undefined ? { reviewReason: r.review.failureReason } : {}),
     // ⭐ 대표 지시(2026-09-08) — 걸음을 슈퍼바이저까지 나른다.

package/src/shell-env-bootstrap.ts

@@ -65,6 +65,12 @@ const POSIX_SHELLS = new Set(['zsh', 'bash', 'fish', 'sh', 'dash', 'ksh']);
 let cached: Record<string, string> | null = null;
 let captured = false;
 
+// Both the daemon warm path (nexus/index.ts) and PTY's first synchronous capture
+// pass through here. Keep the existing capture events intact; these are additive timings.
+function logBootPhase(phase: string, start: number, outcome: string): void {
+  debug.log('boot.phase', phase, { ms: performance.now() - start, outcome });
+}
+
 /** Parse `KEY=VALUE\n` output from `printenv`. Tolerates values that
  *  themselves contain `=`; does not attempt to unescape newlines
  *  (bash/zsh `printenv` emits them literally, which is fine for
@@ -121,10 +127,13 @@ function acceptCapture(stdout: string): Record<string, string> | null {
 }
 
 export function runPrintenvCapture(): Record<string, string> | null {
+  const seedStart = performance.now();
   const seed = captureSeed();
+  logBootPhase('login-env.seed', seedStart, seed ? 'ready' : 'unavailable');
   if (!seed) return null;
   const { shell, seedEnv } = seed;
 
+  const shellStart = performance.now();
   let res: ReturnType<typeof spawnSync>;
   try {
     res = spawnSync(shell, ['-l', '-i', '-c', 'printenv'], {
@@ -137,13 +146,14 @@ export function runPrintenvCapture(): Record<string, string> | null {
       // OSC sequences would corrupt our TUI output otherwise.
     });
   } catch {
+    logBootPhase('login-env.shell', shellStart, 'error');
     return null;
   }
   // ETIMEDOUT with status 0 = the shell outlived the timeout; never trust a late capture.
-  if (res.error) return null;
-  if (res.status !== 0 && res.status !== null) return null;
-  if (res.signal) return null;
-  return acceptCapture(typeof res.stdout === 'string' ? res.stdout : '');
+  const parsed = !res.error && (res.status === 0 || res.status === null) && !res.signal
+    ? acceptCapture(typeof res.stdout === 'string' ? res.stdout : '') : null;
+  logBootPhase('login-env.shell', shellStart, parsed ? 'ok' : 'failed');
+  return parsed;
 }
 
 /** Fill the login-env cache off the event loop (daemon boot). The first web-terminal spawn otherwise ran the
@@ -152,9 +162,12 @@ export function runPrintenvCapture(): Record<string, string> | null {
 export async function warmCapturedEnv(spawn: typeof Bun.spawn = Bun.spawn): Promise<boolean> {
   if (captured) return cached !== null;
   if (process.env.ELANOUS_SKIP_LOGIN_ENV === '1' || process.env.TERM_PROGRAM === 'monad-agent-nested') return false;
+  const seedStart = performance.now();
   const seed = captureSeed();
+  logBootPhase('login-env.seed', seedStart, seed ? 'ready' : 'unavailable');
   if (!seed) return false;
   const start = Date.now();
+  const shellStart = performance.now();
   try {
     const proc = spawn([seed.shell, '-l', '-i', '-c', 'printenv'], { env: seed.seedEnv as Record<string, string>, stdin: 'ignore', stdout: 'pipe', stderr: 'ignore' });
     // A grandchild (e.g. a pyenv rehash) can keep the stdout pipe open after the shell is killed,
@@ -167,6 +180,7 @@ export async function warmCapturedEnv(spawn: typeof Bun.spawn = Bun.spawn): Prom
     const result = await Promise.race([finished, timedOut]);
     clearTimeout(timer);
     const parsed = result && result[1] === 0 ? acceptCapture(result[0]) : null;
+    logBootPhase('login-env.shell', shellStart, parsed ? 'ok' : result ? 'failed' : 'timeout');
     if (captured) return cached !== null; // a synchronous capture won the race
     if (!parsed) return false;
     cached = parsed;
@@ -174,6 +188,7 @@ export async function warmCapturedEnv(spawn: typeof Bun.spawn = Bun.spawn): Prom
     debug.log('shell.envbootstrap.capture', 'warmed', { ok: true, ms: Date.now() - start, keyCount: Object.keys(parsed).length });
     return true;
   } catch {
+    logBootPhase('login-env.shell', shellStart, 'error');
     return false;
   }
 }

package/src/steward/triage.ts

@@ -57,6 +57,8 @@ export interface StewardDeps {
   cardStore?: StewardCardDeps['store'];
   warn?: (message: string) => void;
   ask?: StewardAsk;
+  /** Maximum time for each working-backwards wish draft in schedule (milliseconds). */
+  draftItemMs?: number;
   launchSettings?: Pick<StewardSettings, 'mode' | 'launch' | 'maxParallel' | 'podPool'>;
   launchCommand?: LaunchDeps['command'];
   spawnLaunch?: LaunchDeps['spawn'];
@@ -413,20 +415,35 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
       const wishes = rows.filter(row => present.has(row.issue) && row.capability === 'new-capability' && row.rung !== 'hitl');
       const store = wishes.length ? deps.cardStore ?? new CardStore(root) : undefined;
       const invalid = new Set<string>();
+      const carried = new Set<string>();
       if (store) try {
         recordTriageOnCards(wishes, issues, { root, store, now: deps.now });
         for (const wish of wishes) {
-          try { await recordWorkingBackwardsOnCards([wish], issues, store, deps.ask ?? askSteward); }
-          catch (error) {
-            if (!(error instanceof InvalidWorkingBackwardsDraft)) throw error;
-            invalid.add(wish.issue);
-            debug.log('steward.stage', 'draft-invalid', { issue: wish.issue });
-          }
+          const timedOut = Symbol('draft-timeout');
+          let timer: ReturnType<typeof setTimeout> | undefined;
+          const timeout = new Promise<never>((_, reject) => {
+            timer = setTimeout(() => reject(timedOut), deps.draftItemMs ?? 120_000);
+          });
+          // The draft may finish without ever racing this promise (no ask needed) — never leave its rejection unhandled.
+          timeout.catch(() => undefined);
+          try {
+            // Bound the ask itself so a late answer cannot write to a store closed after this tick.
+            const ask: StewardAsk = (prompt, role) => Promise.race([(deps.ask ?? askSteward)(prompt, role), timeout]);
+            await recordWorkingBackwardsOnCards([wish], issues, store, ask);
+          } catch (error) {
+            if (error instanceof InvalidWorkingBackwardsDraft) {
+              invalid.add(wish.issue);
+              debug.log('steward.stage', 'draft-invalid', { issue: wish.issue });
+            } else {
+              carried.add(wish.issue);
+              debug.log('steward.schedule', 'draft-carried', { issue: wish.issue, reason: error === timedOut ? 'timeout' : 'error' });
+            }
+          } finally { if (timer) clearTimeout(timer); }
         }
       } finally { if (!deps.cardStore) store.close(); }
-      if (invalid.size) rows = rows.map(row => invalid.has(row.issue)
+      if (invalid.size || carried.size) rows = rows.map(row => invalid.has(row.issue)
         ? { ...row, rung: 'hitl' as const, disposition: 'hitl' as const, hitlReason: 'other' as const, why: 'working-backwards draft invalid' }
-        : row);
+        : carried.has(row.issue) ? { ...row, deferred: true as const, disposition: 'wait' as const } : row);
     }
     for (const row of rows) try { debug.log('steward.schedule', 'decision', {
       kind: row.disposition, target: row.issue, wouldAct: row.disposition === 'now' && liveLike(settings.mode),