elanous 0.2.24 → 0.2.25

package/src/self-dev/dev-pipeline.ts

@@ -26,6 +26,7 @@ import { createRepositoryReferencedFileReader, type ReferencedFileReader } from
 import { parseGoalDocumentClarifications } from '../self-implement/goal-author-clarification.js';
 import { requiredEvidenceFromGoal } from '../self-implement/off-diff-evidence.js';
 import { debug } from '../debug/log.js';
+import { REVIEW_DEFERRED_TO_HOST_ENV, reviewDeferredToHostFromEnv } from '../self-implement/review-deferred-to-host.js';
 import { releasePathHold, releasePathHoldComment, RELEASE_PATH_LABEL } from './release-path-guard.js';
 import { runGitCommand } from '../git-fs/runner.js';
 import type { GitRunResult } from '../git-fs/retry.js';
@@ -41,7 +42,7 @@ import type { IngestionEntry } from '../agent-substrate/execution/ingestion-poli
 import type { ReviewerContextItem } from '../agent-substrate/pr-reviewer.js';
 import { resolveRunIdentity, type RunIdSource } from '../harness/harness-space.js';
 import { addSelfDevRunParticipant, processBirthId, saveSelfDevRun } from './run-store.js';
-import { getUserConfig, resolveRoleLlm } from '../user-config.js';
+import { getUserConfig, resolveRoleLlm, type RoleLlmSource } from '../user-config.js';
 import { reviewReasoningEffort } from '../model-tier/review-effort.js';
 import { getProvider, inferProviderFromModel } from '../llm.js';
 import { buildReviewProviderAttempts, defaultReviewFallbackModel, runReviewWithFallback, reviewFallbackModelsFromConfig, runSubscriptionReviewer, type SubscriptionReviewerDeps } from './review-provider-fallback.js';
@@ -1051,16 +1052,29 @@ export function unmannedToolReviewerRateFromConfig(
   return DEFAULT_UNMANNED_TOOL_REVIEWER_RATE;
 }
 
-function observeUnmannedToolReviewerSelection(selection: UnmannedToolReviewerSelection): void {
+function observeUnmannedToolReviewerSelection(selection: UnmannedToolReviewerSelection, skipped?: { reason: 'role-pinned'; roleSource: RoleLlmSource }): void {
   try {
     debug.log('self-dev.reviewer', 'tool-reviewer.select', {
       picked: selection.picked,
       rate: selection.rate,
       sample: selection.sample,
+      ...(skipped ? { skipped: skipped.reason, roleSource: skipped.roleSource } : {}),
     });
   } catch { /* fail-soft */ }
 }
 
+/**
+ * TOOL-REVIEWER-ROLE-PIN — a review role pinned for THIS launch (`--role-llm review=…` flag, or the Pod's
+ * `ELANOUS_ROLE_LLM_REVIEW` env pin) is a declaration that every review in the run uses that model; the
+ * unmanned tool-reviewer lottery must not swap it out (10-10 OR probe #25906: the draw picked the ACP
+ * reviewer and skipped the glm-5.3 pin, so bench arms got different reviewers). `environment` also covers the
+ * older `ELANOUS_PR_REVIEW_MODEL` env model pin. Config `roleLlm.review` is a standing default, not a per-launch
+ * pin — it keeps the lottery.
+ */
+export function reviewRolePinnedForLaunch(source: RoleLlmSource): boolean {
+  return source === 'flag' || source === 'environment';
+}
+
 async function defaultMakeUnmannedToolReviewLLM(): Promise<UnmannedToolReviewLLM> {
   const { makeLazyAcpReviewLLM } = await import('../agent-substrate/acp-reviewer.js');
   return makeLazyAcpReviewLLM({ cwd: process.cwd() });
@@ -1085,6 +1099,8 @@ export async function buildDefaultSelfImplementSeams(
     makeToolReviewLLM?: () => UnmannedToolReviewLLM | Promise<UnmannedToolReviewLLM>;
     subscriptionReviewerDeps?: SubscriptionReviewerDeps;
     makeSubscriptionReviewLLM?: (spawn: ReturnType<typeof import('./review-provider-fallback.js').subscriptionReviewerSpawn>) => (prompt: string) => Promise<string>;
+    /** REVIEW-ACP-POD ②-b 시험 주입 — 기본은 env `ELANOUS_REVIEW_DEFERRED_TO_HOST=1`(발사 호스트가 싣는다). */
+    reviewDeferredToHost?: boolean;
   } = {},
 ): Promise<SelfImplementSeams> {
   const { defaultSeams } = await import('../self-implement/seams.js');
@@ -1139,11 +1155,14 @@ export async function buildDefaultSelfImplementSeams(
   let reviewerCanSelfRead: boolean | undefined;
   if (reviewerIsDefaultApiCall) {
     const rate = parseUnmannedToolReviewerRate(deps.toolReviewerRate) ?? unmannedToolReviewerRateFromConfig();
-    const sample = typeof deps.toolReviewerSample === 'number' && Number.isFinite(deps.toolReviewerSample)
-      ? deps.toolReviewerSample
-      : (deps.toolReviewerRoll ?? Math.random)();
-    const selection = selectUnmannedToolReviewer(rate, sample);
-    observeUnmannedToolReviewerSelection(selection);
+    const rolePinned = reviewRolePinnedForLaunch(reviewRole.source);
+    const sample = rolePinned
+      ? 1
+      : typeof deps.toolReviewerSample === 'number' && Number.isFinite(deps.toolReviewerSample)
+        ? deps.toolReviewerSample
+        : (deps.toolReviewerRoll ?? Math.random)();
+    const selection = rolePinned ? { picked: false, rate, sample } : selectUnmannedToolReviewer(rate, sample);
+    observeUnmannedToolReviewerSelection(selection, rolePinned ? { reason: 'role-pinned', roleSource: reviewRole.source } : undefined);
     if (selection.picked) {
       llmReview = await (deps.makeToolReviewLLM ?? defaultMakeUnmannedToolReviewLLM)();
       reviewerCanSelfRead = true;
@@ -1164,6 +1183,11 @@ export async function buildDefaultSelfImplementSeams(
       reviewerCanSelfRead = undefined;
     }
   }
+  // REVIEW-ACP-POD ②-b — 발사 호스트가 Claude ACP 로 리뷰할 때만 실린다. 리뷰 심이 api 리뷰어를 부르지 않는다(판정은 호스트).
+  const reviewDeferredToHost = deps.reviewDeferredToHost ?? reviewDeferredToHostFromEnv(process.env);
+  if (reviewDeferredToHost) {
+    try { debug.log('self-dev.review-fallback', 'review-deferred-to-host', { env: REVIEW_DEFERRED_TO_HOST_ENV, source: deps.reviewDeferredToHost !== undefined ? 'option' : 'env' }); } catch { /* fail-soft */ }
+  }
   const opensPr = plan.completion !== 'worktree-only';
   const target = plan.target === undefined ? undefined : revalidateHarnessTarget(plan.target);
   if (target?.status === 'outside-home') {
@@ -1181,6 +1205,7 @@ export async function buildDefaultSelfImplementSeams(
     ...(plan.self?.activityGraceSec !== undefined ? { implementActivityGraceSec: plan.self.activityGraceSec } : {}),
     llmReview,
     ...(subscriptionReviewLLM ? { subscriptionReviewLLM } : {}),
+    ...(reviewDeferredToHost ? { reviewDeferredToHost: true } : {}),
     ...(reviewerCanSelfRead !== undefined ? { reviewerCanSelfRead } : {}),
     ...(deps.reviewScopeDiff ? { reviewScopeDiff: deps.reviewScopeDiff } : {}),
     onProgress: ({ stage, message }) => {

package/src/self-dev/draft-residue.ts

@@ -7,16 +7,19 @@ import { debug } from '../debug/log.js';
 import { PR_LABELS } from '../github/pr-labels.js';
 import { appendRunLedgerEntry, listRunLedgers, loadRunLedger, runLedgerDir, type RunLedgerEntry } from '../self-implement/run-ledger.js';
 import { queryRunningRuns } from '../self-implement/running-runs.js';
+import { clipRegateDetail, regateFailureFacts, type HostRegateFailure } from '../self-implement/regate-detail.js';
 import { DRAFT_SWEEP_CLOSE_CAP } from './draft-sweep.js';
 import { PROTECTED_LABELS, sameVerifiedGoal, type DraftTriagePr } from './draft-triage-rules.js';
 
-export type PodTerminalClass = 'landed' | 'merge-ready-not-merged' | 'failed-with-pr' | 'failed-no-pr' | 'failed-pr-unobserved';
+export type PodTerminalClass = 'landed' | 'merge-ready-not-merged' | 'failed-with-pr' | 'failed-no-pr' | 'failed-pr-unobserved' | 'timed-out-harvestable';
 export interface PrTerminalRecord {
   childRunId: string;
   prNumber: number | null;
   prUrl: string | null;
   repository: string | null;
   headSha: string | null;
+  /** Copied from disposition.branch when present; null when the child did not name a branch. */
+  branch?: string | null;
   terminalClass: PodTerminalClass;
   stage: string | null;
   owner: string;
@@ -24,13 +27,16 @@ export interface PrTerminalRecord {
   card: string | null;
   at: string;
   /** Which host-regate gate failed and why — null for every other terminal. */
-  hostRegateFailure: { step: string; detail: string; os: string } | null;
+  /** HOST-REGATE-REASON-LOST: detail keeps a bounded head ⊕ tail (4KB); pr-head · merge steps add the expected/actual
+   *  head, merge-conflict adds the conflicted files, merge adds the failure kind (race · moved head · conflict · policy). */
+  hostRegateFailure: (HostRegateFailure & { os: string }) | null;
 }
 export interface PodTerminalInput {
   childRunId: string;
   state: 'complete' | 'failed' | 'aborted';
   disposition?: { prNumber?: number | null; prUrl?: string | null; checkedHeadCommit?: string | null; stage?: string; merged?: boolean; ok?: boolean;
-    hostRegate?: { passed: boolean; failures: Array<{ step: string; detail: string }>; os: string } | null } | null;
+    branch?: string | null;
+    hostRegate?: { passed: boolean; failures: HostRegateFailure[]; os: string } | null } | null;
   env?: Readonly<Record<string, string | undefined>>;
   prBody?: string;
   goalText?: string;
@@ -47,6 +53,7 @@ export function classifyPodTerminal(input: PodTerminalInput): PrTerminalRecord {
   const prUrl = typeof d?.prUrl === 'string' ? d.prUrl : null;
   const match = prUrl && /^https:\/\/github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)\/?$/.exec(prUrl);
   const repository = match && Number(match[3]) === prNumber ? `${match[1]}/${match[2]}` : null;
+  const branch = typeof d?.branch === 'string' && d.branch.trim() ? d.branch.trim() : null;
   const card = cardOf(input.prBody) ?? cardOf(input.goalText);
   const seat = input.env?.ELANOUS_HARNESS_SEAT;
   const ownerSource = seat === 'OP' || seat === 'TC' || seat === 'MK' || seat === 'UX' ? 'seat' : card ? 'card' : 'unknown';
@@ -55,14 +62,16 @@ export function classifyPodTerminal(input: PodTerminalInput): PrTerminalRecord {
   const hostRegateFailure = d?.stage === 'host-regate-failed' && hostRegate?.passed === false
     ? { step: typeof firstFailure?.step === 'string' && firstFailure.step ? firstFailure.step : 'unknown',
       detail: typeof firstFailure?.detail === 'string' && firstFailure.detail
-        ? firstFailure.detail.split(/\s+/).filter(Boolean).join(' ').slice(0, 300)
+        ? clipRegateDetail(firstFailure.detail.split(/\s+/).filter(Boolean).join(' '))
         : 'failures empty',
+      ...regateFailureFacts(firstFailure),
       os: hostRegate.os }
     : null;
   return {
-    childRunId: input.childRunId, prNumber, prUrl, repository,
+    childRunId: input.childRunId, prNumber, prUrl, repository, branch,
     headSha: typeof d?.checkedHeadCommit === 'string' && /^[a-f0-9]{40}$/i.test(d.checkedHeadCommit) ? d.checkedHeadCommit : null,
     terminalClass: !d ? 'failed-pr-unobserved' : d.merged === true ? 'landed'
+      : prNumber === null && d.stage === 'timed-out' && branch ? 'timed-out-harvestable'
       : prNumber === null ? 'failed-no-pr'
         : input.state === 'complete' && d.ok !== false ? 'merge-ready-not-merged' : 'failed-with-pr',
     stage: d?.stage ?? null, hostRegateFailure,
@@ -282,7 +291,7 @@ export async function replayPodTerminals(options: DraftResidueReplayOptions = {}
     for (const terminal of terminals) {
       const record = terminal.data as unknown as PrTerminalRecord;
       if (typeof record.childRunId !== 'string' || typeof record.owner !== 'string'
-        || !['landed', 'merge-ready-not-merged', 'failed-with-pr', 'failed-no-pr', 'failed-pr-unobserved'].includes(record.terminalClass)
+          || !['landed', 'merge-ready-not-merged', 'failed-with-pr', 'failed-no-pr', 'failed-pr-unobserved', 'timed-out-harvestable'].includes(record.terminalClass)
         || (record.prNumber !== null && (!Number.isSafeInteger(record.prNumber) || record.prNumber <= 0))
         || (record.repository !== null && (typeof record.repository !== 'string' || !/^[\w.-]+\/[\w.-]+$/.test(record.repository)))) {
         throw new Error(`Invalid terminal record: ${ledgerRunId}`);
@@ -338,6 +347,7 @@ export async function applyPodTerminal(record: PrTerminalRecord, ctx: DraftResid
       adapters.appendLedger({ runId: ctx.ledgerRunId, event: 'pr-terminal', data: { ...record } }, ctx.ledgerDir);
       log('terminal-recorded');
     }
+    // AUT-TIMEOUT-NO-HARVEST 첫 조각은 «분류만» — 그 branch 로 PR 을 여는 효과는 다음 조각(원격 가지 존재·기존 PR 확인 관문과 함께).
     if (record.terminalClass === 'failed-no-pr' || record.terminalClass === 'failed-pr-unobserved' || record.prNumber === null) {
       acknowledge('complete', 0);
       return skipped(record.terminalClass);

package/src/self-dev/draft-sweep.ts

@@ -121,9 +121,25 @@ export interface DraftSweepResult {
    * harvestable (review PASS and gate pass), and blocked (must-fix remains).
    */
   daily?: DraftSweepDaily;
+  /**
+   * Same-lineage rule outcomes this tick (DRAFT-SWEEP-LINEAGE-HARVESTABLE): closes it decided (harvestable among them)
+   * and every candidate it let fall through to the older rules, by reason.
+   */
+  lineage?: DraftSweepLineageCounts;
   error?: string;
 }
 
+export interface DraftSweepLineageCounts {
+  closed: number;
+  harvestableClosed: number;
+  fallThrough: Record<string, number>;
+}
+
+/** A review counts as passed only on an observed PASS with no must-fix left. */
+function reviewPassed(posture: SweepReviewGate | undefined): boolean {
+  return posture?.review === 'pass' && posture.mustFix !== true;
+}
+
 /** Daily old-draft census. `date` is the sweep clock's UTC calendar day. */
 export interface DraftSweepDaily {
   readonly date: string;
@@ -769,6 +785,13 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
   let unobserved = 0;
   let claimed = 0;
   let claimExpired = 0;
+  const lineageCounts: DraftSweepLineageCounts = { closed: 0, harvestableClosed: 0, fallThrough: {} };
+  result.lineage = lineageCounts;
+  // Review posture for the harvestable lineage check, reusing the census lookups (one lookup per PR per tick).
+  const postureFor = async (pr: SweepDraft): Promise<SweepReviewGate | undefined> => {
+    if (!reviewGate.has(pr.number)) reviewGate.set(pr.number, await adapters.getReviewGate!(pr, repository));
+    return reviewGate.get(pr.number);
+  };
   for (const listedDraft of drafts) {
     const draft = { ...listedDraft, labels: [...listedDraft.labels], latestFileChanges: latestFileChanges.get(listedDraft.number) };
     let releasedThisTick = false;
@@ -882,7 +905,10 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       ? (now.getTime() - Date.parse(draft.updatedAt)) / 3_600_000 : NaN;
     // A newer open draft of the same goal lineage (a rerun, e.g. a forced requeue) supersedes this one even when
     // its running claim is fresh or its run is still live. Holds, merged twins and the title-based duplicate rule keep their priority.
-    const lineageNewer = contradiction || draft.labels.includes(harvestableLabel) ? undefined : newerLineageDraft(draft, drafts);
+    // DRAFT-SWEEP-LINEAGE-HARVESTABLE (10-12): a harvestable draft is no longer skipped — the skip left 70+ harvestable
+    // reruns open until the 24h idle expiry. It is still protected when its own review passed and the newer one's did not.
+    const harvestable = draft.labels.includes(harvestableLabel);
+    const lineageNewer = contradiction ? undefined : newerLineageDraft(draft, drafts);
     if (lineageNewer) {
       const base = decideDraft({ draft, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
         finalRunResult, ageHours: runStatus ? ageHours : idleHours });
@@ -895,9 +921,24 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
         // Every lineage outcome that does not close falls through to the existing rules (preservation contract):
         // a duplicate this rule cannot settle is decided exactly as it was before this rule existed.
         const fallThrough = (why: string) => {
-          try { debug.log('self-dev.draft-sweep', 'lineage-fall-through', { number: draft.number, newer: lineageNewer.number, lineageKey, why }); } catch { /* fail-soft */ }
+          lineageCounts.fallThrough[why] = (lineageCounts.fallThrough[why] ?? 0) + 1;
+          try { debug.log('self-dev.draft-sweep', 'lineage-fall-through', { number: draft.number, newer: lineageNewer.number, lineageKey, why, harvestable }); } catch { /* fail-soft */ }
         };
-        if (runLive && !adapters.supersedeRun) fallThrough('lineage-duplicate-run-live');
+        // A harvestable draft yields only to a newer draft at least as complete: an observed review PASS on the old one
+        // is kept unless the newer one passed review too. Unobservable review posture keeps the old draft (fail-closed).
+        let harvestProtection: string | undefined;
+        if (harvestable) {
+          if (!adapters.getReviewGate) harvestProtection = 'lineage-harvestable-review-unobserved';
+          else {
+            try {
+              const [oldPosture, newPosture] = [await postureFor(draft), await postureFor(lineageNewer)];
+              if (oldPosture === undefined) harvestProtection = 'lineage-harvestable-review-unobserved';
+              else if (reviewPassed(oldPosture) && !reviewPassed(newPosture)) harvestProtection = 'lineage-harvestable-review-pass-protected';
+            } catch { harvestProtection = 'lineage-harvestable-review-unobserved'; }
+          }
+        }
+        if (harvestProtection) fallThrough(harvestProtection);
+        else if (runLive && !adapters.supersedeRun) fallThrough('lineage-duplicate-run-live');
         // Safety (OP 10-11): a live run is stopped only when the newer run of the same lineage is itself live —
         // never trade a running attempt for one that already ended or was never observed running.
         else if (runLive && !live(statuses.get(lineageNewer.number), lineageNewer.branch)) fallThrough('lineage-newer-run-not-live');
@@ -921,6 +962,8 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
           else {
             // A close is counted against the cap only once it is decided here; a failed write gives the slot back.
             closes += 1;
+            lineageCounts.closed += 1;
+            if (harvestable) lineageCounts.harvestableClosed += 1;
             const entry: DraftSweepEntry = { number: draft.number, action: 'close', reason, statusLabel: supersededLabel, applied: false };
             record(entry);
             if (!apply) continue;
@@ -937,7 +980,11 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
               entry.applied = true;
             } catch (error) {
               if (labelsChanged) entry.partialApplied = true;
-              else closes -= 1;
+              else {
+                closes -= 1;
+                lineageCounts.closed -= 1;
+                if (harvestable) lineageCounts.harvestableClosed -= 1;
+              }
               entry.error = String(error);
             }
             continue;
@@ -1052,6 +1099,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     }
   }
   timing('decide', drafts.length);
+  try { debug.log('self-dev.draft-sweep', 'lineage-summary', { ...lineageCounts, apply }); } catch { /* fail-soft */ }
   try { debug.log('self-dev.draft-sweep', 'timing', { phase: 'total', ms: Date.now() - started, count: drafts.length, closed: closes, closeCap, closeCapSource }); } catch { /* fail-soft */ }
   result.unobserved = unobserved;
   // `closed` stays «closed by this sweep»; replay closes only consume the shared cap (alreadyClosed).

package/src/self-dev/fabric-decompose-adapter.ts

@@ -1,4 +1,3 @@
-import { tierModel } from '../llm/model-defaults.js';
 import { statSync } from 'node:fs';
 import { resolve, sep } from 'node:path';
 import {
@@ -9,6 +8,7 @@ import {
 } from '../autopilot/mission-rfc-author.js';
 import {
   DEFAULT_MAX_TASKS,
+  decomposeModel,
   decomposeSelfDevGoal,
   type SelfDevDecomposeLlm,
   type SelfDevDecomposeOptions,
@@ -70,9 +70,16 @@ export type FabricDecomposeRequestResult =
   | { status: 'grounding-failed'; message: string; cause: unknown }
   | { status: 'grounding-empty'; message: string; grounding: GoalAuthoringGroundingResult };
 
+/**
+ * Default fabric resolve seam — lazy `streamLLM` wire. The model comes from the
+ * shared planning-role selector `decomposeModel` (src/self-dev/decompose.ts),
+ * so the review env `ELANOUS_PR_REVIEW_MODEL` cannot retarget fabric
+ * decomposition (ROLE-RELAY-SPLIT).
+ */
 async function defaultFabricResolve(prompt: string): Promise<string> {
   const { streamLLM } = await import('../llm.js');
-  const model = process.env.ELANOUS_PR_REVIEW_MODEL || tierModel('best');
+  const { model, source } = decomposeModel();
+  debug.log('self-dev.decompose', 'model', { model, source });
   return streamLLM([{ role: 'user', content: prompt }], () => {}, { model, reasoningEffort: 'low' });
 }
 

package/src/self-dev/run-supervisor.ts

@@ -39,6 +39,25 @@ export interface SupervisorRound {
    * history, which never measured it, so the no-PR streak guard reads it as «not measured» and stays off.
    */
   noPrTaskIds?: string[];
+  /**
+   * Piece key (normalized feature — {@link noPrStreakKey}) of each `noPrTaskIds` entry, same index. A rework round mints a
+   * new taskId for the same piece (run-27b03878: task:1ded008a8aeb → task:f54a6e6fca25 → task:fade5a6931a4), so the no-PR
+   * streak pairs rounds by this key. Omitted on older history — the guard then pairs by taskId as before.
+   */
+  noPrFeatureKeys?: string[];
+}
+
+/** Failed without a PR — a result that carries either a PR number or a PR URL has one (fixtures and older producers set only one). */
+function failedWithoutPr(result: SupervisorJobResult): boolean {
+  return result.status === 'failed' && result.prNumber === undefined && !result.prUrl;
+}
+
+/**
+ * «Same piece» key for the no-PR streak guard: the feature text with whitespace collapsed, lower-cased and trailing
+ * punctuation dropped. Empty when the result carries no feature — the caller then falls back to the taskId.
+ */
+export function noPrStreakKey(feature: unknown): string {
+  return typeof feature === 'string' ? resumeKey(feature).replace(/[\s.,;:!?。…·]+$/u, '') : '';
 }
 
 export const SUPERVISOR_STOP_REASONS = [
@@ -458,17 +477,27 @@ export function decideNextRun(input: {
   // AUT-NO-PROGRESS-RETRY-LOOP — 같은 후보가 PR 없이 두 라운드 연속 실패하면 세 번째 Pod 를 띄우지 않는다
   //   (부검 run-1166bcd1 · run-1bde4815 · run-427bd632 · run-46a02f42). 직전 라운드가 noPrTaskIds 를 안 쟀으면 서지 않는다.
   //   호출자가 stallRounds 를 기본보다 늘렸으면(제자리 인내를 늘림) 서지 않는다 — 0.2.24 컷 회귀(orchestrate-cli.test 라운드 상한 둘).
+  //   NO-PR-STREAK-FEATURE-KEY — 짝은 taskId 가 아니라 «같은 조각»(noPrFeatureKeys)으로 맞춘다: rework 가 라운드마다 taskId 를
+  //   새로 만들어 taskId 짝은 운영에서 한 번도 안 섰다(run-27b03878). 키를 안 잰 옛 원장·feature 없는 결과는 taskId 로(fail-open).
   const previousNoPr = history.at(-1)?.noPrTaskIds;
+  const previousNoPrKeys = history.at(-1)?.noPrFeatureKeys;
   if (previousNoPr !== undefined && retryIds.length > 0 && stallRounds <= DEFAULT_STALL_ROUNDS) {
-    const failedNoPr = (taskId: string) => activeResults.find((result) => result.taskId === taskId
-      && result.status === 'failed' && result.prNumber === undefined);
-    const streak = retryIds.every((taskId) => previousNoPr.includes(taskId) && failedNoPr(taskId) !== undefined);
+    const failedNoPr = (taskId: string) => activeResults.find((result) => result.taskId === taskId && failedWithoutPr(result));
+    const keyOf = (taskId: string): string => noPrStreakKey(activeResults.find((result) => result.taskId === taskId)?.feature);
+    const pairedBy = (taskId: string): 'feature-key' | 'task-id' =>
+      previousNoPrKeys !== undefined && keyOf(taskId) !== '' ? 'feature-key' : 'task-id';
+    const sameAsPrevious = (taskId: string): boolean => pairedBy(taskId) === 'feature-key'
+      ? previousNoPrKeys!.includes(keyOf(taskId))
+      : previousNoPr.includes(taskId);
+    const streak = retryIds.every((taskId) => sameAsPrevious(taskId) && failedNoPr(taskId) !== undefined);
     if (streak && !madeProgress(history.at(-1), thisRound)) {
       const errors = retryIds.flatMap((taskId) => {
         const message = failedNoPr(taskId)?.error?.message;
         return message ? [message.slice(0, 200)] : [];
       });
-      try { debug.log('self-dev.supervisor', 'no-pr-streak-stop', { taskIds: retryIds, round, errors }); } catch { /* fail-open */ }
+      try { debug.log('self-dev.supervisor', 'no-pr-streak-stop', {
+        taskIds: retryIds, featureKeys: retryIds.map(keyOf), pairedBy: [...new Set(retryIds.map(pairedBy))], round, errors,
+      }); } catch { /* fail-open */ }
       return {
         ...base,
         action: 'stop',
@@ -558,8 +587,9 @@ export function appendRound(
   const t = triageRun(results.filter((result) => result.salvage !== 'launched'), undefined, false, undefined, mainSyncRelaunchSpent(history));
   const baseCompleted = countBaseCompleted(results);
   const base = roundBase(results);
-  const noPrTaskIds = results.filter((result) => result.status === 'failed' && result.prNumber === undefined)
-    .map((result) => result.taskId);
+  const noPrResults = results.filter(failedWithoutPr);
+  const noPrTaskIds = noPrResults.map((result) => result.taskId);
+  const noPrFeatureKeys = noPrResults.map((result) => noPrStreakKey(result.feature));
   return [...history, {
     round: history.length,
     landed: countLanded(results),
@@ -586,7 +616,7 @@ export function appendRound(
       return { oscillationRepairTaskIds: pairs.map(([id]) => id!), oscillationRepairFeatures: pairs.map(([, feature]) => feature!),
         ...(decision.oscillation.repairGoals ? { oscillationRepairGoals: decision.oscillation.repairGoals } : {}) };
     })() : {}),
-    ...(noPrTaskIds.length > 0 ? { noPrTaskIds } : {}),
+    ...(noPrTaskIds.length > 0 ? { noPrTaskIds, noPrFeatureKeys } : {}),
   }];
 }
 

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

@@ -16,7 +16,7 @@ import { publicExposureFiles, runExposeGate } from './expose-gate.js';
 import { getUserConfig } from '../user-config.js';
 import { debug } from '../debug/log.js';
 import { buildDocumentGuardianIndex, formatDocumentGuardians } from './document-guardian-index.js';
-import { buildImporterTestIndex, isTestPath, type ImporterTestIndex } from './importer-test-index.js';
+import { buildImporterTestIndex, importerTestsNotInRunSet, isTestPath, type ImporterTestIndex } from './importer-test-index.js';
 import { buildRouteConsumerTestIndex } from './route-consumer-test-index.js';
 import { gitChangedFiles, observeGateBaselineLocation } from './seams.js';
 import {
@@ -33,6 +33,9 @@ export interface SelfGateCliOptions {
   /** LIGHT-RC (0.2.19) — repository-relative test paths run on every call, whatever changed. Existing ones join the
    *  run (deduplicated, same introduced/preexisting baseline as the rest); missing ones go to `alwaysIncludeMissing`. */
   alwaysInclude?: readonly string[];
+  /** RELEASE-DAILY-LIGHT-RC ② — run every tracked test that imports a changed (non-test) source, past the caller cap
+   *  (importer index · reason=changed-source-importer). Off by default: the plain `self gate` scope is unchanged. */
+  includeImporterTests?: boolean;
 }
 
 interface ProcessResult {
@@ -115,6 +118,8 @@ export interface SelfGateCliResult {
   documentsWithoutDerivedTests: readonly string[];
   /** `alwaysInclude` paths that do not exist in the tree (empty when none were given). */
   alwaysIncludeMissing: readonly string[];
+  /** RELEASE-DAILY-LIGHT-RC ② — importer tests added because `includeImporterTests` was set (empty otherwise). */
+  importerTestsAdded?: readonly string[];
   /** New vs. already-present failures (unknown/preconditionUnmet = failures it could not classify). Absent = the test
    *  step did not produce a measurement (e.g. shards unmeasured). */
   baseline?: { introduced: number; preexisting: number; unknown: number; preconditionUnmet: number };
@@ -605,9 +610,20 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
   const alwaysIncludeMissing = alwaysInclude.filter((path) => !exists(path));
   const scopedTests = scope.testArgs ?? [];
   const alwaysIncludeExtra = alwaysInclude.filter((path) => exists(path) && !scopedTests.includes(path));
-  const testFiles = [...scopedTests, ...alwaysIncludeExtra];
-  const skipTestStep = scope.skipTestStep && alwaysIncludeExtra.length === 0;
-  const unrunImporterTotal = lookupFailed ? null : (scope.importerTestsNotRun?.total ?? 0);
+  // RELEASE-DAILY-LIGHT-RC ② — the scope already runs importer tests as callers, but capped (GATE_CALLER_TEST_LIMIT);
+  // a day of landings overflows that cap and source-only regressions went unrun (0.2.24: 20). Opt-in: every importer.
+  const changedSources = selection.files.filter((path) => !isTestPath(path));
+  const importerTestsAdded = options.includeImporterTests && availableIndex
+    ? [...new Set(changedSources.flatMap((source) => availableIndex.testsBySource.get(source) ?? []))]
+      .filter((path) => exists(path) && !scopedTests.includes(path) && !alwaysIncludeExtra.includes(path)).sort()
+    : [];
+  const testFiles = [...scopedTests, ...alwaysIncludeExtra, ...importerTestsAdded];
+  const skipTestStep = scope.skipTestStep && alwaysIncludeExtra.length === 0 && importerTestsAdded.length === 0;
+  const importerTestsNotRun = options.includeImporterTests && availableIndex
+    ? importerTestsNotInRunSet(availableIndex, changedSources, testFiles) : scope.importerTestsNotRun;
+  const unrunImporterTotal = lookupFailed ? null : (importerTestsNotRun?.total ?? 0);
+  // Overflowed callers that ② ran anyway are not «not run».
+  const callerTestsOverflow = scope.callerTestsOverflow.filter(({ file }) => !importerTestsAdded.includes(file));
   const importerLookupFailed = Boolean(lookupFailed);
   const lines = [
     // ⛔⭐ 「changed=0」을 «초록»으로 읽는 사고가 났다(2026-09-02 · 🅕 보고 · 🅣 재현).
@@ -630,15 +646,18 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
     documentGuardianLine(cwd, scope.documentPaths, deps.runCommand),
     // 🚨 러너 우주 «밖» — 형제들과 같은 정책으로 «말만» 한다(`OBS-T418`).
     formatUnrunnableChangeKinds(selection.files),
-    formatUnrunImporterTests(scope.importerTestsNotRun, lookupFailed),
+    formatUnrunImporterTests(importerTestsNotRun, lookupFailed),
     `caller tests: ${lookupFailed ? `lookup failed (${lookupFailed})` : scope.callerTests.map(({ file, reasons }) => `${file} (${reasons.join('+')})`).join(', ') || (routeIndex?.lookupFailures.length ? 'route lookup incomplete' : '(none)')}`,
     ...(routeIndex?.lookupFailures.length ? [`⚠️ caller route base lookup failed — unmeasured: ${routeIndex.lookupFailures.map(({ source, reason }) => `${source} (${reason})`).join(', ')}`] : []),
-    ...(scope.callerTestsOverflow.length ? [`⚠️ caller test cap exceeded — not run: ${scope.callerTestsOverflow.map(({ file, reasons }) => `${file} (${reasons.join('+')})`).join(', ')}`] : []),
+    ...(callerTestsOverflow.length ? [`⚠️ caller test cap exceeded — not run: ${callerTestsOverflow.map(({ file, reasons }) => `${file} (${reasons.join('+')})`).join(', ')}`] : []),
     changedTestCountNote(cwd, selection.files, selection.baseRef, deps.runCommand, deps.readFile),
     // Only printed when the caller asked for always-include paths — the plain `self gate` output is unchanged.
     ...(options.alwaysInclude !== undefined
       ? [`always include: ${alwaysInclude.length - alwaysIncludeMissing.length}/${alwaysInclude.length} (added ${alwaysIncludeExtra.length}${alwaysIncludeMissing.length ? ` · missing: ${alwaysIncludeMissing.join(', ')}` : ''})`]
       : []),
+    ...(options.includeImporterTests
+      ? [`importer tests added: ${lookupFailed ? `lookup failed (${lookupFailed})` : `${importerTestsAdded.length} (reason=changed-source-importer${importerTestsAdded.length ? ` · ${importerTestsAdded.join(', ')}` : ''})`}`]
+      : []),
   ];
   if (expose.log) lines.push(expose.log);
   if (options.pr) {
@@ -664,7 +683,7 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
   if (skipTestStep) {
     const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
     logGateCliBaseline(cwd, { ...ZERO_GATE_BASELINE, unrunImporterTotal, lookupFailed: importerLookupFailed });
-    return { exitCode: androidPassed && iosPassed && pwaPassed && policyPassed && expose.passed ? 0 : 1, lines, changedFiles: selection.files, testFiles: [], unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests, alwaysIncludeMissing, baseline: { introduced: 0, preexisting: 0, unknown: 0, preconditionUnmet: 0 } };
+    return { exitCode: androidPassed && iosPassed && pwaPassed && policyPassed && expose.passed ? 0 : 1, lines, changedFiles: selection.files, testFiles: [], unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests, alwaysIncludeMissing, importerTestsAdded, baseline: { introduced: 0, preexisting: 0, unknown: 0, preconditionUnmet: 0 } };
   }
 
   if (options.shards !== undefined) {
@@ -700,7 +719,7 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
       exitCode: aggregate.status !== 'passed' || !policyPassed || !androidPassed || !iosPassed || !pwaPassed || !expose.passed ? 1 : 0,
       lines, changedFiles: selection.files, testFiles, unverified: scope.unverified,
       documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests,
-      alwaysIncludeMissing, ...(shardBaseline ? { baseline: shardBaseline } : {}),
+      alwaysIncludeMissing, importerTestsAdded, ...(shardBaseline ? { baseline: shardBaseline } : {}),
       ...(unmeasuredReason !== undefined ? { unmeasuredReason } : {}),
     };
   }
@@ -711,7 +730,7 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
     lines.push(formatPartialObservationNote(unrunImporterTotal ?? 0, `tests: pass (${testFiles.length} files)`));
     const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
     logGateCliBaseline(cwd, { ...ZERO_GATE_BASELINE, unrunImporterTotal, lookupFailed: importerLookupFailed });
-    return { exitCode: policyPassed && androidPassed && iosPassed && pwaPassed && expose.passed ? 0 : 1, lines, changedFiles: selection.files, testFiles, unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests, alwaysIncludeMissing, baseline: { introduced: 0, preexisting: 0, unknown: 0, preconditionUnmet: 0 } };
+    return { exitCode: policyPassed && androidPassed && iosPassed && pwaPassed && expose.passed ? 0 : 1, lines, changedFiles: selection.files, testFiles, unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests, alwaysIncludeMissing, importerTestsAdded, baseline: { introduced: 0, preexisting: 0, unknown: 0, preconditionUnmet: 0 } };
   }
 
   if (worktreeLog.includes('deterministic environment setup failed')) lines.push(worktreeLog);
@@ -733,5 +752,5 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
   lines.push(formatPartialObservationNote(unrunImporterTotal ?? 0, formatGateBaselineNote(report, unrunImporterTotal ?? 0)));
   const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
   const exitCode = !androidPassed || !iosPassed || !pwaPassed || !policyPassed || !expose.passed || report.introduced > 0 || report.unknown > 0 || report.preconditionUnmet > 0 ? 1 : 0;
-  return { exitCode, lines, changedFiles: selection.files, testFiles, unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests, alwaysIncludeMissing, baseline: { introduced: report.introduced, preexisting: report.preexisting, unknown: report.unknown, preconditionUnmet: report.preconditionUnmet } };
+  return { exitCode, lines, changedFiles: selection.files, testFiles, unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests, alwaysIncludeMissing, importerTestsAdded, baseline: { introduced: report.introduced, preexisting: report.preexisting, unknown: report.unknown, preconditionUnmet: report.preconditionUnmet } };
 }

package/src/self-implement/gate-remote.ts

@@ -365,6 +365,9 @@ export interface DispatchOptions {
   /** argv for the remote run (the tool re-invoked with `--local` so it never recurses). */
   remoteArgv: RemoteArgv;
   refs?: string[];
+  /** Exact commit to run remotely instead of the repo's HEAD (RELEASE-DAILY-LIGHT-RC ① — light-rc measures origin/main,
+   *  not the seat tree it was started from). */
+  commit?: string;
   installPwa?: boolean;
   payloadFiles?: PayloadFile[];
   json?: boolean;
@@ -413,7 +416,7 @@ export async function dispatchHeavyCheck(opts: DispatchOptions, deps: DispatchDe
   let outcome: RemoteRunOutcome;
   for (;;) {
     try {
-      outcome = runOnRemote({ repo: opts.repo, host, mirror: settings.mirror, argv: opts.remoteArgv, refs: opts.refs, installPwa: opts.installPwa, payloadFiles: opts.payloadFiles, hostCap: settings.hostCap }, deps.runner);
+      outcome = runOnRemote({ repo: opts.repo, host, mirror: settings.mirror, argv: opts.remoteArgv, refs: opts.refs, ...(opts.commit !== undefined ? { commit: opts.commit } : {}), installPwa: opts.installPwa, payloadFiles: opts.payloadFiles, hostCap: settings.hostCap }, deps.runner);
     } catch (error) {
       outcome = { kind: 'infra', reason: `exception: ${error instanceof Error ? error.message : String(error)}` };
     }

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

@@ -50,6 +50,7 @@ import type { HarnessGroundingProvenance } from './context-capsule.js';
 import { hasGoalStepCodeName } from './goal-step-code-name.js';
 import { targetScopedGoalText } from './goal-text-path-scope.js';
 import { parseReleaseNoteSection } from '../release-loop/release-note.js';
+import { declaredNewFilePaths } from './goal-new-paths.js';
 
 // ⭐ `situation`/`complication` 은 **선택**이다 — 안 오면 `scqaNarrative` 가 종전 문면을 쓴다.
 //   ⛔ 필수로 만들지 않는다: 그러면 인핸싱이 폴백으로 떨어진 저작(LLM 실패·`disabled`)이 전부 죽는다.
@@ -371,7 +372,7 @@ function endGoalAuthorPhase(phase: GoalAuthorTimedPhase, startedAt: number, auth
 
 export type GoalFileLintLevel = 'ERROR' | 'WARN';
 
-export type GoalFileLintTag = 'canonical-structure' | 'evidence-section' | 'boundary-size' | 'launch-branch' | 'unanswered-clarification' | 'shell-damage' | 'traced-path' | 'grounding-evidence' | 'empty-result-population' | 'decision-signal-numeric-source' | 'decision-signal-numeric-coverage' | 'decision-signal-proxy-expectation' | 'out-of-target-requirement' | 'heading-form-marker' | 'blanket-invariant' | 'self-question-subject' | 'artifact-launch-declaration' | 'all-negative-signals' | 'unreadable-signals' | 'alternative-signals' | 'count-observation' | 'identifier-name-observation' | 'self-reported-observation' | 'default-invocation-observation' | 'release-note';
+export type GoalFileLintTag = 'canonical-structure' | 'evidence-section' | 'boundary-size' | 'launch-branch' | 'unanswered-clarification' | 'shell-damage' | 'traced-path' | 'traced-path-new' | 'grounding-evidence' | 'empty-result-population' | 'decision-signal-numeric-source' | 'decision-signal-numeric-coverage' | 'decision-signal-proxy-expectation' | 'out-of-target-requirement' | 'heading-form-marker' | 'blanket-invariant' | 'self-question-subject' | 'artifact-launch-declaration' | 'all-negative-signals' | 'unreadable-signals' | 'alternative-signals' | 'count-observation' | 'identifier-name-observation' | 'self-reported-observation' | 'default-invocation-observation' | 'release-note';
 
 type GoalFileLintOrigin =
   | { readonly kind: 'known-incident'; readonly incident: string; readonly reference: string }
@@ -389,6 +390,7 @@ export const GOAL_FILE_LINT_ORIGINS: Record<GoalFileLintTag, GoalFileLintOrigin>
   'unanswered-clarification': { kind: 'known-incident', incident: 'deferred clarifications passed lint and later killed launch', reference: 'git:50dc445cc (#6703)' },
   'shell-damage': { kind: 'known-incident', incident: 'code fences were read as empty inline code', reference: 'git:92937e8f3 (#6403)' },
   'traced-path': { kind: 'known-incident', incident: 'missing files and lines escaped pre-launch validation', reference: 'git:777973f23 (#6423)' },
+  'traced-path-new': { kind: 'known-incident', incident: 'goals declaring a not-yet-existing file as new were still hit with the traced-path missing ERROR, so authors listed nonexistent paths as existing ones and the Pod ended no-result-line (MODEL-BENCH-SCORES twice plus four UX cells)', reference: 'goal cell AUTHOR-NEW-FILE-PATHS (0.2.24)' },
   'grounding-evidence': { kind: 'unknown-origin', label: 'ORIGIN-UNKNOWN' },
   'empty-result-population': { kind: 'unknown-origin', label: 'ORIGIN-UNKNOWN' },
   'decision-signal-numeric-source': { kind: 'known-incident', incident: 'authored Expected result omitted numeric source and coverage', reference: 'git:7e6c02799 (#9847)' },
@@ -1722,13 +1724,21 @@ export function lintGoalFile(document: string, branch: string, deps: GoalFileLin
     });
   }
   if (deps.readReferencedFile) {
+    // AUTHOR-NEW-FILE-PATHS — 문서가 «새로 만들 파일»로 선언한 경로. 실행 쪽 범위 검사와 같은 줄을 읽는다.
+    const declaredNew = new Set(declaredNewFilePaths(document));
     for (const reference of tracedPathReferences(document)) {
       const result = deps.readReferencedFile(reference.path);
       const normalized = typeof result === 'string' ? { kind: 'ok' as const, contents: result }
         : result === null ? { kind: 'missing' as const }
         : result;
       if (normalized.kind === 'missing') {
-        findings.push({ level: 'ERROR', tag: 'traced-path', message: `traced path does not exist: ${reference.path}` });
+        // AUTHOR-NEW-FILE-PATHS — 선언된 새 파일은 저작 시점에 없는 것이 정상이다: ERROR 가 아니라 WARN.
+        if (declaredNew.has(reference.path)) {
+          findings.push({ level: 'WARN', tag: 'traced-path-new', message: `traced path is declared new: ${reference.path}` });
+          debug.log('self-implement.author', 'traced-path-new', { path: reference.path });
+        } else {
+          findings.push({ level: 'ERROR', tag: 'traced-path', message: `traced path does not exist: ${reference.path}` });
+        }
       } else if (normalized.kind === 'outside-repository') {
         findings.push({ level: 'ERROR', tag: 'traced-path', message: `traced path is outside repository: ${reference.path}` });
       } else if (normalized.kind === 'directory') {

package/src/self-implement/goal-new-paths.ts

@@ -0,0 +1,42 @@
+/**
+ * ⭐ AUTHOR-NEW-FILE-PATHS — 저작 골 문서가 «새로 만들 파일»로 선언한 경로.
+ *
+ * 저작(TRACED PATHS 존재 검사)과 실행(orchestrator 범위 검사)이 **같은 줄**을 읽어야
+ * 저작 통과·실행 보류가 다시 갈리지 않는다(TC 13:50). 줄 인식은 실행 쪽
+ * src/self-implement/orchestrator.ts 의 DECLARED_NEW_FILES_LINE 와 같은 꼴을 쓴다.
+ */
+
+// SCOPE-NEW-FILES-LINE — 칸 문면은 새로 만들 파일을 «신설:» 줄로 따로 적는다(OP D칸 규칙).
+//    orchestrator.ts 의 DECLARED_NEW_FILES_LINE 와 같은 정규식이다(한쪽만 읽으면 저작과 실행이 갈린다).
+export const DECLARED_NEW_FILES_LINE = /^\s*(?:신설|new\s*files?)\s*[:：]\s*(.*)$/i;
+
+/** 목록 기호 «- »·굵게 «**» 는 장식이다 — 그것만 벗기고 같은 정규식으로 문는다. */
+function bareDeclarationLine(line: string): string {
+  return line.replace(/^(?:\s*-\s+)+/, '').replace(/\*\*/g, '');
+}
+
+/** 저장소 상대 파일 경로(확장자 있음)만 남긴다 — 디렉토리·절대 경로·「..」는 버린다. */
+function isRepositoryFileCandidate(piece: string): boolean {
+  if (piece === '' || /\s/.test(piece)) return false;
+  if (piece.startsWith('/') || piece.startsWith('~') || /^[A-Za-z]:[\\/]/.test(piece)) return false;
+  if (piece.endsWith('/')) return false;
+  const segments = piece.split('/');
+  if (segments.some((segment) => segment === '' || segment === '.' || segment === '..')) return false;
+  return /\.[^./]+$/.test(segments[segments.length - 1]!);
+}
+
+/** 문서 안 «신설:» 줄의 « · »·쉼표로 나뉜 경로를 모은다. «## NEW FILES» 같은 다른 형식은 읽지 않는다. */
+export function declaredNewFilePaths(document: string): string[] {
+  const paths: string[] = [];
+  for (const rawLine of document.split(/\r?\n/)) {
+    const match = DECLARED_NEW_FILES_LINE.exec(bareDeclarationLine(rawLine));
+    if (!match) continue;
+    for (const fragment of match[1]!.split(/[·,]/)) {
+      // 실행 쪽 범위 검사(parseDeclaredTargetPathsFromAsk)와 같은 정규화 — 등 코드, ./ 접두.
+      const piece = fragment.trim().replace(/^`+|`+$/g, '').replace(/\\/g, '/').replace(/^\.\//, '');
+      if (!isRepositoryFileCandidate(piece)) continue;
+      paths.push(piece);
+    }
+  }
+  return [...new Set(paths)];
+}