elanous 0.2.24 → 0.2.27

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

@@ -9,7 +9,8 @@ import { recordSelfDevRunSupervisorStop, selfDevRunsDir } from './run-store.js';
 import { debug } from '../debug/log.js';
 import { sweepFrozenMerges } from '../self-implement/frozen-merges.js';
 import { routeSupervisorVerdict } from './supervisor-verdict-edges.js';
-import { recordTaskAgentShadowMove, type TaskAgentShadowInput } from '../task-agent/shadow.js';
+import { recordTaskAgentShadowMove, runCardFor, type TaskAgentShadowInput } from '../task-agent/shadow.js';
+import { cardPrNumber, taskAgentStatePath } from '../task-agent/task-hand.js';
 
 export interface SupervisorRound {
   round: number;
@@ -39,6 +40,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 +478,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 +588,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 +617,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 } : {}),
   }];
 }
 
@@ -611,6 +642,12 @@ export interface SuperviseRunOptions {
    * `false` 면 끈다. 던져도 런의 결말은 바뀌지 않는다(fail-soft).
    */
   taskAgentShadow?: ((input: TaskAgentShadowInput) => unknown) | false;
+  /** TA-LAND-AFTER-REVIEW — false disables the hook; function replaces only the final rejudge for isolated tests. */
+  taskAgentRejudge?: ((cardId: string, statePath: string) => Promise<unknown>) | false;
+  /** Test-only external I/O for the real completion rejudge. The decision and shadow gate remain production code. */
+  taskAgentRejudgeExternal?: Parameters<typeof import('../task-agent/rejudge-on-head.js').rejudgeAsyncResultCard>[2];
+  /** Isolated state ledger for the terminal rejudge test; production uses the active instance. */
+  taskAgentStatePath?: string;
   observeDeliverables?: () => Promise<{
     readonly deployFindings: ReadonlyMap<string, { target: string; findings?: readonly DeployVerifyFinding[] | readonly unknown[] }>;
     readonly unmeasured: readonly unknown[];
@@ -628,6 +665,23 @@ function resolveSupervisorStopStorage(runStore: SuperviseRunOptions['runStore'])
   return { path: selfDevRunsDir(), source: 'process-default' };
 }
 
+/** The supervisor's terminal hook, limited to a uniquely run-bound TA land card. */
+export async function rejudgeTerminalTaskCard(runId: string | null, deps: {
+  statePath?: string;
+  env?: NodeJS.ProcessEnv;
+  rejudgeCard?: (cardId: string, statePath: string) => Promise<unknown>;
+  external?: Parameters<typeof import('../task-agent/rejudge-on-head.js').rejudgeAsyncResultCard>[2];
+} = {}): Promise<void> {
+  const statePath = deps.statePath ?? taskAgentStatePath();
+  const card = runCardFor(runId, { statePath, ...(deps.env ? { env: deps.env } : {}) });
+  if (!card || card.status !== 'launched' || card.taLand !== true || cardPrNumber(card) === undefined) return;
+  const { rejudgeAsyncResultCard } = await import('../task-agent/rejudge-on-head.js');
+  const result = await (deps.rejudgeCard ?? ((id, path) => rejudgeAsyncResultCard(id, path, deps.external)))(card.id, statePath);
+  const { requireSuccessfulRejudge } = await import('../task-agent/rejudge-on-head.js');
+  requireSuccessfulRejudge(result);
+  try { debug.log('task-agent', 'terminal-rejudge', { runId, card: card.id }); } catch { /* fail-soft */ }
+}
+
 export async function superviseRun(opts: SuperviseRunOptions): Promise<SupervisorJobResult[]> {
   let results = [...opts.initial];
   let history: SupervisorRound[] = [];
@@ -778,6 +832,16 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
         } catch (error) {
           try { debug.log('task-agent', 'shadow-move-failed', { runId, stopReason: decision.stopReason, error: String(error) }); } catch { /* fail-open */ }
         }
+        if (opts.taskAgentRejudge !== false) {
+          const rejudgeOptions = { ...(opts.taskAgentStatePath ? { statePath: opts.taskAgentStatePath } : {}), ...(opts.taskAgentRejudge ? { rejudgeCard: opts.taskAgentRejudge } : {}), ...(opts.taskAgentRejudgeExternal ? { external: opts.taskAgentRejudgeExternal } : {}) };
+          try { await rejudgeTerminalTaskCard(runId, rejudgeOptions); }
+          catch (error) {
+            try { await rejudgeTerminalTaskCard(runId, rejudgeOptions); }
+            catch (retryError) {
+              try { debug.log('task-agent', 'terminal-rejudge-failed', { runId, stopReason: decision.stopReason, error: String(retryError), firstError: String(error), attempts: 2 }); } catch { /* fail-open */ }
+            }
+          }
+        }
       }
       return results;
     }

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,10 @@ 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';
+import { classifyGoalCommandExecution, type GoalCommandExecutionResult } from './goal-command-execution.js';
+export { classifyGoalCommandExecution } from './goal-command-execution.js';
+export type { GoalCommandExecutionKind, GoalCommandExecutionResult, GoalCommandExecutionClassification } from './goal-command-execution.js';
 
 // ⭐ `situation`/`complication` 은 **선택**이다 — 안 오면 `scqaNarrative` 가 종전 문면을 쓴다.
 //   ⛔ 필수로 만들지 않는다: 그러면 인핸싱이 폴백으로 떨어진 저작(LLM 실패·`disabled`)이 전부 죽는다.
@@ -371,7 +375,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 +393,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)' },
@@ -437,33 +442,6 @@ export function canonicalStructureFinding(
   return finding;
 }
 
-export type GoalCommandExecutionKind = 'success' | 'missing-command' | 'argument-problem' | 'execution-failure';
-
-export interface GoalCommandExecutionResult {
-  readonly status: number | null;
-  readonly stderr: string;
-}
-
-export interface GoalCommandExecutionClassification {
-  readonly kind: GoalCommandExecutionKind;
-  readonly log: string;
-}
-
-/** Classifies an already-observed Commander result without executing a command. */
-export function classifyGoalCommandExecution(result: GoalCommandExecutionResult): GoalCommandExecutionClassification {
-  // A clean exit is authoritative: stderr text from a successful command is not a failure signal.
-  if (result.status === 0) return { kind: 'success', log: 'command completed successfully' };
-
-  const stderr = result.stderr;
-  if (stderr.includes('unknown command') || stderr.includes('unknown option')) {
-    return { kind: 'missing-command', log: 'command is not recognized; this may be not yet implemented rather than a defect' };
-  }
-  if (stderr.includes('missing required argument') || stderr.includes('required option')) {
-    return { kind: 'argument-problem', log: 'command requires a missing argument or option' };
-  }
-  return { kind: 'execution-failure', log: `command execution failed with code ${String(result.status)}` };
-}
-
 /** Optional repository-bounded source reader. Legacy null means the referenced path is missing. */
 export interface GoalFileLintDeps {
   readReferencedFile?: (repositoryRelativePath: string) => string | null | ReferencedFileReadResult;
@@ -1722,13 +1700,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-command-execution.ts

@@ -0,0 +1,26 @@
+export type GoalCommandExecutionKind = 'success' | 'missing-command' | 'argument-problem' | 'execution-failure';
+
+export interface GoalCommandExecutionResult {
+  readonly status: number | null;
+  readonly stderr: string;
+}
+
+export interface GoalCommandExecutionClassification {
+  readonly kind: GoalCommandExecutionKind;
+  readonly log: string;
+}
+
+/** Classifies an already-observed Commander result without executing a command. */
+export function classifyGoalCommandExecution(result: GoalCommandExecutionResult): GoalCommandExecutionClassification {
+  // A clean exit is authoritative: stderr text from a successful command is not a failure signal.
+  if (result.status === 0) return { kind: 'success', log: 'command completed successfully' };
+
+  const stderr = result.stderr;
+  if (stderr.includes('unknown command') || stderr.includes('unknown option')) {
+    return { kind: 'missing-command', log: 'command is not recognized; this may be not yet implemented rather than a defect' };
+  }
+  if (stderr.includes('missing required argument') || stderr.includes('required option')) {
+    return { kind: 'argument-problem', log: 'command requires a missing argument or option' };
+  }
+  return { kind: 'execution-failure', log: `command execution failed with code ${String(result.status)}` };
+}

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)];
+}