elanous 0.2.23 → 0.2.25

package/src/self-implement/child-context-composition.ts

@@ -0,0 +1,139 @@
+import { debug } from '../debug/log.js';
+
+export const SMALL_CHILD_CONTEXT_TOKEN_BUDGET = 32_000;
+
+export const CHILD_CONTEXT_COMPONENT_NAMES = [
+  'systemPrompt',
+  'agentsMd',
+  'claudeMd',
+  'toolSchemas',
+  'goal',
+  'ledger',
+] as const;
+
+export type ChildContextComponentName = typeof CHILD_CONTEXT_COMPONENT_NAMES[number];
+export type ChildContextProfile = 'default' | 'small';
+
+export interface ChildContextComponents {
+  readonly systemPrompt?: string;
+  readonly agentsMd?: string;
+  readonly claudeMd?: string;
+  readonly toolSchemas?: string;
+  readonly goal?: string;
+  readonly ledger?: string;
+}
+
+export interface ChildContextComponentMeasurement {
+  readonly inputBytes: number;
+  readonly includedBytes: number;
+  readonly truncated: boolean;
+}
+
+export interface ChildContextComposition {
+  readonly text: string;
+  readonly profile: ChildContextProfile;
+  readonly budgetTokens: number | null;
+  /** UTF-8 bytes are a conservative upper bound on tokenizer tokens. */
+  readonly tokenUpperBound: number;
+  readonly components: Readonly<Record<ChildContextComponentName, ChildContextComponentMeasurement>>;
+}
+
+export interface ComposeChildContextOptions {
+  readonly profile?: ChildContextProfile;
+  readonly log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+const JOINER = '\n\n';
+
+function utf8Bytes(value: string): number {
+  return Buffer.byteLength(value, 'utf8');
+}
+
+function prefixWithinUtf8Budget(value: string, byteBudget: number): string {
+  if (byteBudget <= 0) return '';
+  let included = '';
+  let bytes = 0;
+  for (const character of value) {
+    const characterBytes = utf8Bytes(character);
+    if (bytes + characterBytes > byteBudget) break;
+    included += character;
+    bytes += characterBytes;
+  }
+  return included;
+}
+
+function emptyMeasurements(): Record<ChildContextComponentName, ChildContextComponentMeasurement> {
+  return {
+    systemPrompt: { inputBytes: 0, includedBytes: 0, truncated: false },
+    agentsMd: { inputBytes: 0, includedBytes: 0, truncated: false },
+    claudeMd: { inputBytes: 0, includedBytes: 0, truncated: false },
+    toolSchemas: { inputBytes: 0, includedBytes: 0, truncated: false },
+    goal: { inputBytes: 0, includedBytes: 0, truncated: false },
+    ledger: { inputBytes: 0, includedBytes: 0, truncated: false },
+  };
+}
+
+function emitCompositionEvent(
+  log: ((event: string, data: Record<string, unknown>) => void) | undefined,
+  data: Record<string, unknown>,
+): void {
+  try {
+    if (log) log('child.context-composition', data);
+    else debug.log('self-implement', 'child.context-composition', data);
+  } catch {
+    // Context composition must not fail because an observation sink is unavailable.
+  }
+}
+
+/**
+ * Composes the implementation child's first-turn context and records the byte
+ * contribution of every input component. The small profile spends its hard cap
+ * on executable context first and trims repository instruction files last.
+ */
+export function composeChildContext(
+  components: ChildContextComponents,
+  options: ComposeChildContextOptions = {},
+): ChildContextComposition {
+  const profile = options.profile ?? 'default';
+  const budgetBytes = profile === 'small' ? SMALL_CHILD_CONTEXT_TOKEN_BUDGET : null;
+  const measurements = emptyMeasurements();
+  const included: Partial<Record<ChildContextComponentName, string>> = {};
+  const order: readonly ChildContextComponentName[] = profile === 'small'
+    ? ['systemPrompt', 'toolSchemas', 'goal', 'ledger', 'agentsMd', 'claudeMd']
+    : CHILD_CONTEXT_COMPONENT_NAMES;
+  let usedBytes = 0;
+  let includedCount = 0;
+
+  for (const name of order) {
+    const value = components[name] ?? '';
+    const inputBytes = utf8Bytes(value);
+    const separatorBytes = includedCount > 0 && value.length > 0 ? utf8Bytes(JOINER) : 0;
+    const availableBytes = budgetBytes === null ? Number.POSITIVE_INFINITY : Math.max(0, budgetBytes - usedBytes - separatorBytes);
+    const includedValue = inputBytes <= availableBytes ? value : prefixWithinUtf8Budget(value, availableBytes);
+    const includedBytes = utf8Bytes(includedValue);
+    measurements[name] = { inputBytes, includedBytes, truncated: includedBytes < inputBytes };
+    if (includedValue.length === 0) continue;
+    included[name] = includedValue;
+    usedBytes += separatorBytes + includedBytes;
+    includedCount += 1;
+  }
+
+  const text = CHILD_CONTEXT_COMPONENT_NAMES
+    .flatMap((name) => included[name] === undefined ? [] : [included[name]!])
+    .join(JOINER);
+  const tokenUpperBound = utf8Bytes(text);
+  const result: ChildContextComposition = {
+    text,
+    profile,
+    budgetTokens: budgetBytes === null ? null : SMALL_CHILD_CONTEXT_TOKEN_BUDGET,
+    tokenUpperBound,
+    components: measurements,
+  };
+  emitCompositionEvent(options.log, {
+    profile,
+    budgetTokens: result.budgetTokens,
+    tokenUpperBound,
+    components: measurements,
+  });
+  return result;
+}

package/src/self-implement/child-llm-preference.ts

@@ -11,9 +11,12 @@ import type {
 import { DEFAULT_BUDGET_GATE } from '../user-config.js';
 import { debug } from '../debug/log.js';
 
+/** 체인 한 칸. `codexCredits` = `llm.fallbackChain` 의 `codex-credits` 칸(codex 를 선불 크레딧으로 · 마지막 수단). */
+export type ChildLlmChainSlot = ChildLlmChainEntry & { readonly codexCredits?: true };
+
 export interface ResolvedChildLlmPreference {
   mode: ChildLlmPreferenceMode;
-  chain: ChildLlmChainEntry[];
+  chain: ChildLlmChainSlot[];
   budgetGate: {
     minHeadroomPercent: number;
     onShortfall: BudgetGateOnShortfall;
@@ -27,6 +30,8 @@ export type ChildLlmPreferenceInput = Pick<UserConfig, 'tools' | 'llm'> & Partia
 const FALLBACK_NAME_TO_PROVIDER: Readonly<Record<string, string>> = {
   'codex-rotate': 'openai-codex',
   grok: 'grok',
+  // CODEX-CREDITS-STEP — provider 는 같은 codex 지만 «크레딧 칸»이라 따로 센다(아래 중복 판정).
+  'codex-credits': 'openai-codex',
 };
 
 function warnPreference(detail: string): void {
@@ -39,15 +44,18 @@ function warnPreference(detail: string): void {
 }
 
 /** `llm.fallbackChain` 이름을 자식 프로바이더 칸으로 옮긴다. 모르는 이름은 경고하고 건너뛴다. */
-export function chainFromFallbackNames(names: readonly string[] | undefined): ChildLlmChainEntry[] {
-  const chain: ChildLlmChainEntry[] = [];
+export function chainFromFallbackNames(names: readonly string[] | undefined): ChildLlmChainSlot[] {
+  const chain: ChildLlmChainSlot[] = [];
   for (const name of names ?? []) {
     const provider = FALLBACK_NAME_TO_PROVIDER[name];
     if (!provider) {
       warnPreference(`llm.fallbackChain 의 모르는 이름 '${name}' 을 건너뜀`);
       continue;
     }
-    if (!chain.some((entry) => entry.provider === provider)) chain.push({ provider });
+    const codexCredits = name === 'codex-credits';
+    if (!chain.some((entry) => entry.provider === provider && (entry.codexCredits === true) === codexCredits)) {
+      chain.push(codexCredits ? { provider, codexCredits: true } : { provider });
+    }
   }
   return chain;
 }
@@ -60,7 +68,7 @@ export function resolveChildLlmPreference(config: ChildLlmPreferenceInput): Reso
   const mode: ChildLlmPreferenceMode = explicitMode ?? (provider ? 'pinned' : 'auto');
   const modeSource: ResolvedChildLlmPreference['source']['mode'] = explicitMode ? 'explicit' : 'inferred';
 
-  let chain: ChildLlmChainEntry[];
+  let chain: ChildLlmChainSlot[];
   let chainSource: ResolvedChildLlmPreference['source']['chain'];
   if (mode === 'pinned') {
     // 계정 회전은 여기 없다. provider 없는 model 은 pinned 가 아니다.

package/src/self-implement/claude-acp-implement.ts

@@ -0,0 +1,67 @@
+// ── CLAUDE-IMPL-LANE — `--child-llm-provider claude-acp` 의 구현 실행 (호스트 레인 · 구독 ACP) ──
+//
+// claude-acp 는 «LLM provider» 가 아니라 구현 실행기 선택이다. 이 갈래는 implement seam 이 PTY 자식
+// (`elanous chat` · getProvider) 대신 부른다 — PTY 자식으로 보내면 getProviderForConfig 가 모델 이름(claude-…)을
+// 보고 anthropic(API 키 provider)으로 풀어 «구독» 런이 API 로 과금된다(10-11 #26277 보류 판독).
+//
+// fail-closed: 구독 확인 실패 · 사용률 미측정 · 상한(기본 85%) 이상 · 프록시 주소 없음이면 거부하고
+// 다른 공급자로 조용히 새지 않는다(거부 사유는 관측 `self-implement.claude-acp` `refused`).
+import { debug } from '../debug/log.js';
+import { makeAcpImplementer, type AcpImplementerOpts, type AcpImplementerResult } from '../agent-substrate/acp-implementer.js';
+import { subscriptionReviewerAvailability, type SubscriptionReviewerDeps } from '../self-dev/review-provider-fallback.js';
+
+/** 구현 레인의 구독 사용률 상한(%) — 대표 10-11 «Claude 구독(ACP) = 계정 둘 · 85 까지». 리뷰어 상한(95)과 별개 값. */
+export const CLAUDE_ACP_IMPLEMENT_CAP_DEFAULT = 85;
+export const CLAUDE_ACP_PROVIDER = 'claude-acp';
+
+export function isClaudeAcpChild(childLlm: { provider?: string } | undefined): boolean {
+  return childLlm?.provider?.trim().toLowerCase() === CLAUDE_ACP_PROVIDER;
+}
+
+/** 상한은 `ELANOUS_CLAUDE_ACP_CAP`(0~100)로만 바꾼다 — 잘못된 값은 기본 85(올려 잡지 않는다). */
+export function claudeAcpImplementCap(env: NodeJS.ProcessEnv = process.env): number {
+  const raw = env.ELANOUS_CLAUDE_ACP_CAP?.trim();
+  const n = raw ? Number(raw) : Number.NaN;
+  return Number.isFinite(n) && n >= 0 && n <= 100 ? n : CLAUDE_ACP_IMPLEMENT_CAP_DEFAULT;
+}
+
+export type ClaudeAcpImplementOutcome =
+  | { kind: 'refused'; reason: string }
+  | { kind: 'ran'; result: AcpImplementerResult };
+
+export interface ClaudeAcpImplementInput {
+  cwd: string;
+  prompt: string;
+  model?: string;
+  runId?: string;
+  env?: NodeJS.ProcessEnv;
+  /** 시험 주입 — 구독 확인·상태 읽기. */
+  availabilityDeps?: SubscriptionReviewerDeps;
+  /** 시험 주입 — ACP 에이전트 생성기(makeAcpImplementer 로 그대로 넘긴다). */
+  createAgent?: AcpImplementerOpts['createAgent'];
+  timeoutMs?: number;
+}
+
+export async function runClaudeAcpImplement(input: ClaudeAcpImplementInput): Promise<ClaudeAcpImplementOutcome> {
+  const env = input.env ?? process.env;
+  const cap = claudeAcpImplementCap(env);
+  const availability = subscriptionReviewerAvailability({ provider: CLAUDE_ACP_PROVIDER }, cap, env, input.availabilityDeps ?? {});
+  if (!availability.spawn) {
+    const reason = availability.reason ?? 'Claude subscription unavailable';
+    debug.log('self-implement.claude-acp', 'refused', { reason, cap, ...(input.runId ? { runId: input.runId } : {}) }, { level: 'warn' });
+    return { kind: 'refused', reason };
+  }
+  const proxyBaseUrl = availability.spawn.env.ANTHROPIC_BASE_URL;
+  debug.log('self-implement.claude-acp', 'start', { cap, proxy: proxyBaseUrl !== undefined, model: input.model ?? '(default)', ...(input.runId ? { runId: input.runId } : {}) });
+  const implement = makeAcpImplementer({
+    worktree: input.cwd,
+    env,
+    ...(proxyBaseUrl ? { proxyBaseUrl } : {}),
+    ...(input.model ? { model: input.model } : {}),
+    ...(input.timeoutMs !== undefined ? { timeoutMs: input.timeoutMs } : {}),
+    ...(input.createAgent ? { createAgent: input.createAgent } : {}),
+  });
+  const result = await implement(input.prompt);
+  debug.log('self-implement.claude-acp', 'done', { chars: result.text.length, allowed: result.allowed, denied: result.denied, ...(input.runId ? { runId: input.runId } : {}) });
+  return { kind: 'ran', result };
+}

package/src/self-implement/flex-signals.ts

@@ -0,0 +1,59 @@
+/**
+ * 재작업 라운드 관측 신호 넷 — 관측 전용 순수 계산(FLEX-RFC §A-①).
+ *
+ * ⛔ 판정·분기·오버레이 상태를 만들지 않는다. 호출자는 결과를 원장에 «남기기만» 한다.
+ * ⛔ 모르는 값은 0 으로 지어내지 않고 키를 뺀다(key-absent) — 0 은 «측정했더니 없었다»의 값이다.
+ */
+
+export interface FlexSignalsInput {
+  /** 오래된 라운드 → 최신 라운드 순의 게이트 실패 id 목록. `undefined`·빈 목록은 «실패 id 를 못 쟀다». */
+  gateFailedIdsByRound: readonly (readonly string[] | undefined)[];
+  /** 최신 게이트 실패들의 base 귀속(`preexisting`·`introduced`·`unknown` …). 못 쟀으면 `undefined`. */
+  failureAttributions?: readonly string[] | undefined;
+  /** 지금 orchestrator 가 알고 있는 review_repeat 값 그대로. */
+  reviewRepeat?: number | undefined;
+  /** 지금까지 쓴 라운드 수. */
+  round: number;
+  /** 계획된 라운드 상한(effectiveMax). 모르면 `undefined`. */
+  plannedRounds?: number | undefined;
+}
+
+export interface FlexSignals {
+  fail_signature_repeat?: number;
+  base_reproduce?: number;
+  review_repeat?: number;
+  budget_burn?: number;
+}
+
+function failureKey(ids: readonly string[] | undefined): string | undefined {
+  return ids?.length ? JSON.stringify([...new Set(ids)].sort()) : undefined;
+}
+
+/** 최신 라운드의 실패 id 집합이 그 이전 라운드들에서 «같은 집합»으로 나온 횟수. 최신 집합을 모르면 `undefined`. */
+function failSignatureRepeat(rounds: FlexSignalsInput['gateFailedIdsByRound']): number | undefined {
+  if (rounds.length === 0) return undefined;
+  const latest = failureKey(rounds[rounds.length - 1]);
+  if (latest === undefined) return undefined;
+  return rounds.slice(0, -1).filter((ids) => failureKey(ids) === latest).length;
+}
+
+/** base 에서도 재현된(`preexisting`) 실패 수. 귀속이 비었거나 하나라도 `unknown` 이면 `undefined`. */
+function baseReproduce(attributions: FlexSignalsInput['failureAttributions']): number | undefined {
+  if (attributions === undefined || attributions.length === 0) return undefined;
+  if (attributions.includes('unknown')) return undefined;
+  return attributions.filter((attribution) => attribution === 'preexisting').length;
+}
+
+export function computeFlexSignals(input: FlexSignalsInput): FlexSignals {
+  const repeat = failSignatureRepeat(input.gateFailedIdsByRound);
+  const reproduce = baseReproduce(input.failureAttributions);
+  const burn = input.plannedRounds !== undefined && input.plannedRounds > 0
+    ? input.round / input.plannedRounds
+    : undefined;
+  return {
+    ...(repeat === undefined ? {} : { fail_signature_repeat: repeat }),
+    ...(reproduce === undefined ? {} : { base_reproduce: reproduce }),
+    ...(input.reviewRepeat === undefined ? {} : { review_repeat: input.reviewRepeat }),
+    ...(burn === undefined ? {} : { budget_burn: burn }),
+  };
+}

package/src/self-implement/frozen-merges.ts

@@ -5,7 +5,7 @@ import { dirname, join, resolve } from 'node:path';
 import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
 import { debug } from '../debug/log.js';
 import { enterJourneyNode, exitJourneyNode, passJourneyNode, withJourneyNodeSync } from '../self-dev/graph-journey-nodes.js';
-import { routeJourneyEdge } from '../self-dev/graph-journey-route.js';
+import { freezeCheckHolds, routeJourneyEdge } from '../self-dev/graph-journey-route.js';
 import { beginLandingMerge, type LandingFreeze } from '../release-loop/landing-freeze.js';
 
 /** `manual`: the owning repository could not be determined — a sweep never resumes it; a person does. */
@@ -194,8 +194,13 @@ export function admitLandingMerge(
     () => admitLandingMergeUnobserved(heldEntry, root, hooks, claimKey, opts));
   const freezeLabel = admission.kind === 'merge' ? 'open' : admission.kind === 'held' ? 'frozen' : 'taken';
   exitJourneyNode('freeze-check', { provenance: 'admit-landing-merge', outcome: freezeLabel, ...(pr === undefined ? {} : { data: { pr } }) });
-  // 2판: 간선 판독을 남긴다(관측). 승인 요구(open→hold) 강제는 0.2.22 — 보류 사유 값이 먼저다(RFC §3).
-  routeJourneyEdge('freeze-check', freezeLabel, { freeze: freezeLabel });
+  const route = routeJourneyEdge('freeze-check', freezeLabel, { freeze: freezeLabel });
+  // 그래프가 열린 병합을 hold 로 보내면(launch 오버레이의 «승인 요구») 병합하지 않고 보류한다. 답이 없으면 오늘 판정 그대로.
+  if (admission.kind === 'merge' && freezeCheckHolds(freezeLabel, route)) {
+    admission.end();
+    passJourneyNode('hold', { provenance: 'admit-landing-merge', outcome: 'graph-hold', ...(pr === undefined ? {} : { data: { pr } }) });
+    return { kind: 'held', freeze: { reason: 'graph freeze-check → hold', startedAt: new Date().toISOString(), until: null, by: 'graph' } };
+  }
   return admission;
 }
 

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-decompose.ts

@@ -5,6 +5,7 @@ import { llmDecomposeSteps } from '../harness/llm-decompose.js';
 import { GOAL_AUTHOR_COARSE_MAX_SLICES } from '../task-orchestrator/generator-prompt.js';
 import { getDefaultLogStore } from '../mss/logging/log-store.js';
 import { emitDecision } from '../live/detail-switch.js';
+import { selectPlanningLlm } from '../prompt-enhance/enhance.js';
 import type { GoalAuthorDeps } from './goal-author.js';
 
 const GOAL_STEPS_DECOMPOSED_EVENT = 'goal-steps-decomposed';
@@ -64,10 +65,17 @@ export function createGoalAuthorDecomposeSteps(
 ): NonNullable<GoalAuthorDeps['decomposeSteps']> {
   return async (objective, options) => {
     const { streamLLM } = await import('../llm.js');
+    // ⭐ AUTHOR-DECOMPOSE-KNOB(0.2.24 · G7 #25848) — 쪼개기·적대 비평의 두 streamLLM 호출이 인핸서와
+    //   «같은 규칙»으로 planning 노브(roleLlm.planning ⊕ ELANOUS_PROMPT_ENHANCE_MODEL/EFFORT)를 따른다.
+    //   미설정이면 종전 그대로 — model 은 아예 전달하지 않는다(streamLLM 기본 모델) ⊕ effort 는 high.
+    const { model, effort } = selectPlanningLlm();
+    const llmOpts: { model?: string; reasoningEffort: 'low' | 'medium' | 'high' } = model === undefined
+      ? { reasoningEffort: effort }
+      : { model, reasoningEffort: effort };
     let decompositionRationale: string | undefined;
     const steps = await llmDecomposeSteps(
       objective,
-      (input) => streamLLM([{ role: 'user', content: input.prompt }], () => {}, { reasoningEffort: 'high' }).then((text) => ({ text })),
+      (input) => streamLLM([{ role: 'user', content: input.prompt }], () => {}, llmOpts).then((text) => ({ text })),
       { ...(options?.context ? { context: options.context } : {}), maxTasks: GOAL_AUTHOR_COARSE_MAX_SLICES, promptProfile: 'goal-author-coarse', ...(signal ? { signal } : {}), onRationale: (rationale) => { decompositionRationale = rationale; } },
     );
     const heft = classifyHeft(objective);
@@ -120,7 +128,7 @@ export function createGoalAuthorDecomposeSteps(
       return finalSteps;
     };
     if (!reviewExecuted) return finalize(steps, decompositionRationale);
-    const critic = (prompt: string) => streamLLM([{ role: 'user', content: prompt }], () => {}, { reasoningEffort: 'high' });
+    const critic = (prompt: string) => streamLLM([{ role: 'user', content: prompt }], () => {}, llmOpts);
 
     try {
       const critique = await adversarialPlanCritique(objective, steps, critic, options?.context);

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)' },
@@ -1233,6 +1235,21 @@ function countAddressableLines(contents: string): number {
 }
 
 const TRACED_PATH_LIST_ITEM = /^\s*(?:[-*+]|\d+[.)])\s+(.+)$/;
+const TRACED_PATH_LEADING_LIST_MARKERS = /^(?:\s*(?:[-*+]|\d+[.)])\s+)+/;
+const TRACED_PATH_EVIDENCE_TAG = /^\[(?:code|skill|memory|doc|pty|unknown)\]\s+/;
+// 2026-10-11 — 저작기가 «목록 기호 두 겹»(`- - src/x.ts` · `- 1. src/x.ts` · `- [code] - src/x.ts`)을 쓰면
+//   한 겹만 벗긴 남은 «- src/…» 를 경로로 읽어 `traced path does not exist: - src/…` ERROR 를 냈다
+//   (Pod 저작에서 자식이 결과 줄 없이 죽음 · 오늘 no-result-line 18건의 공용 원인). 기호·태그를 반복해서 벗긴다.
+function tracedPathListItem(line: string): string | undefined {
+  const item = TRACED_PATH_LIST_ITEM.exec(line)?.[1];
+  if (item === undefined) return undefined;
+  let evidence = item;
+  for (;;) {
+    const next = evidence.replace(TRACED_PATH_LEADING_LIST_MARKERS, '').replace(TRACED_PATH_EVIDENCE_TAG, '');
+    if (next === evidence) return evidence;
+    evidence = next;
+  }
+}
 // ⛔⭐⭐⭐ 2026-08-11 — 이 문면은 «통하지 않는 처방»을 첫 번째로 권하고 있었다.
 //   옛 문면: *"Re-authoring the same input may produce different evidence; **retry before changing the ask**."*
 //   📏 실측(두 트랙 합산): 그 말대로 «재저작»만 반복했더니 ***0/4***. ask 에 «식별자 앵커»를 넣자 ***2/2***.
@@ -1355,9 +1372,8 @@ export function tracedPathReferences(document: string): TracedPathReference[] {
   if (!section) return [];
   const references: TracedPathReference[] = [];
   for (const line of section.split(/\r?\n/)) {
-    const item = TRACED_PATH_LIST_ITEM.exec(line)?.[1];
-    if (!item) continue;
-    const evidence = item.replace(/^\[(?:code|skill|memory|doc|pty|unknown)\]\s+/, '');
+    const evidence = tracedPathListItem(line);
+    if (!evidence) continue;
     if (isTracedPathsEvidenceUnavailable(evidence) || isTracedPathExclusionDescription(evidence)) continue;
     // 설명 구분자는 **공백으로 둘러싼** em dash 또는 hyphen 뿐이다 — 파일명 안의 dash 를 설명 구분자로 오인하지 않는다.
     // 경로 칸 안의 복수 경로는 **공백으로 둘러싼** 가운뎃점만 본다 — 파일명 안의 `·` 를 가르지 않는다.
@@ -1367,10 +1383,12 @@ export function tracedPathReferences(document: string): TracedPathReference[] {
     for (const fragment of pathField.split(' · ')) {
       const trimmed = fragment.trim();
       if (!trimmed) continue;
-      const unwrapped = stripInlineCode(trimmed);
+      // 10-11 재발 — 저작기가 «`- src/…`» 처럼 목록 기호를 백틱 «안»에 쓰면 바깥 기호만 벗긴 뒤 백틱을 벗겨
+      //   «- src/…» 가 경로로 남았다(AUTHOR-DECOMPOSE-KNOB · MODEL-BENCH-SCORES 부검). 백틱을 벗긴 뒤 한 번 더 벗긴다.
+      const unwrapped = stripInlineCode(trimmed).replace(TRACED_PATH_LEADING_LIST_MARKERS, '');
       const match = TRACED_PATH_LINE.exec(unwrapped);
       // 두 번 벗긴다 — 줄번호가 백틱 **안**(`p:42`)일 수도 **밖**(`p`:42)일 수도 있다.
-      const path = match ? stripInlineCode(match[1].trim()) : undefined;
+      const path = match ? stripInlineCode(match[1].trim()).replace(TRACED_PATH_LEADING_LIST_MARKERS, '') : undefined;
       if (!path) continue;
       references.push({ path, line: match?.[2] ? Number(match[2]) : null, endLine: match?.[3] ? Number(match[3]) : null });
     }
@@ -1461,9 +1479,8 @@ export function lintGoalFile(document: string, branch: string, deps: GoalFileLin
   const { prohibitionSymbolStartingLineCount, permissionSymbolStartingLineCount, mixedSymbolLineCount } = symbolStartingLineCounts(document);
   const { exhaustiveRequestWordingCount, blanketBehaviorPreservationCount, namedPreservationTargetCount, removalFormDecisionConditionCount } = goalAuthorKnownShapeCounts(ask);
   const tracedPathExclusionCount = (markdownSection(document, 'TRACED PATHS')?.split(/\r?\n/) ?? [])
-    .map((line) => TRACED_PATH_LIST_ITEM.exec(line)?.[1])
-    .filter((item): item is string => item !== undefined
-      && isTracedPathExclusionDescription(item.replace(/^\[(?:code|skill|memory|doc|pty|unknown)\]\s+/, ''))).length;
+    .map((line) => tracedPathListItem(line))
+    .filter((item): item is string => item !== undefined && isTracedPathExclusionDescription(item)).length;
   const selfQuestionSubjectViolations = detectSelfQuestionSubjectViolations(document);
   const launchDeclarationClassification = artifactLaunchDeclarationClassification(document);
   const headings = canonicalBlocks(document);
@@ -1694,7 +1711,7 @@ export function lintGoalFile(document: string, branch: string, deps: GoalFileLin
     });
   }
   const unavailableTracedPathEvidence = markdownSection(document, 'TRACED PATHS')?.split(/\r?\n/)
-    .map((line) => TRACED_PATH_LIST_ITEM.exec(line)?.[1])
+    .map((line) => tracedPathListItem(line))
     .find((item): item is string => item !== undefined && isTracedPathsEvidenceUnavailable(item));
   if (unavailableTracedPathEvidence) {
     const requiresTracedPaths = goalType === null || goalType === 'implement';
@@ -1707,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') {