elanous 0.2.0 → 0.2.4

package/src/self-implement/dependency-change-gate.ts

@@ -0,0 +1,90 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { pwaReachableSrcFiles } from './pwa-import-graph.js';
+
+export type DependencyChangeGateResult = {
+  ran: boolean;
+  passed: boolean;
+  failures: Array<{ step: 'root-tsc' | 'pwa-build'; lines: string[] }>;
+  skipped?: string;
+  trigger?: 'dependency' | 'pwa-reachable';
+  pwaReachableChanged?: string[];
+  measured?: boolean;
+};
+
+type CommandResult = {
+  status: number | null;
+  stdout?: string;
+  stderr?: string;
+  signal?: NodeJS.Signals | null;
+  error?: Error;
+};
+
+type Run = (command: string, args: readonly string[], options: { cwd: string; timeout: number }) => CommandResult;
+
+const TIMEOUT_MS = 300_000;
+const defaultRun: Run = (command, args, options) => spawnSync(command, [...args], {
+  ...options, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024,
+});
+
+/** A dependency change can invalidate consumers outside the changed-file typecheck scope. */
+export function runDependencyChangeGate({ cwd, changedFiles, run = defaultRun }: {
+  cwd: string;
+  changedFiles: readonly string[];
+  run?: Run;
+}): DependencyChangeGateResult {
+  const normalized = changedFiles.map((file) => file.replace(/^\.\//, ''));
+  const dependency = normalized.some((file) => ['package.json', 'bun.lock', 'apps/pwa/package.json'].includes(file));
+  const reachable = normalized.some((file) => file.startsWith('src/'))
+    ? pwaReachableSrcFiles(cwd) : new Set<string>();
+  const changed = normalized.filter((file) => reachable.has(file));
+  if (!dependency && changed.length === 0) return { ran: false, passed: true, failures: [] };
+  const trigger = dependency ? 'dependency' as const : 'pwa-reachable' as const;
+  const pwaReachableChanged = changed.slice(0, 10);
+  const details = { trigger, pwaReachableChanged };
+  const hasRootConfig = existsSync(join(cwd, 'tsconfig.json'));
+  if (dependency && !hasRootConfig && changed.length === 0) {
+    return { ran: false, passed: true, failures: [], skipped: 'no-tsconfig', ...details };
+  }
+  const pwaPresent = existsSync(join(cwd, 'apps/pwa'));
+  // The build needs `next` resolvable from apps/pwa — its own node_modules or a workspace-hoisted root one.
+  // An empty apps/pwa/node_modules is not «installed», and hoisted deps are not «missing».
+  const missingDeps = !['apps/pwa/node_modules/next/package.json', 'node_modules/next/package.json']
+    .some((path) => existsSync(join(cwd, path)));
+  if (missingDeps && (pwaPresent || !dependency)) {
+    debug.log('self-implement', 'gate.pwa-reachable', { trigger, changed: pwaReachableChanged, skipped: 'pwa-deps-missing' });
+  }
+  if (!dependency && missingDeps) {
+    return { ran: false, passed: true, measured: false, failures: [], skipped: 'pwa-deps-missing', ...details };
+  }
+
+  const failures: DependencyChangeGateResult['failures'] = [];
+  let ran = false;
+  for (const [step, command, args] of [
+    ...(dependency && hasRootConfig ? [['root-tsc', 'bunx', ['tsc', '--noEmit', '-p', 'tsconfig.json']]] : []),
+    ...(pwaPresent && !missingDeps ? [['pwa-build', 'bun', ['bin/elanous.mjs', '--test', 'nexus', 'build']]] : []),
+  ] as Array<['root-tsc' | 'pwa-build', string, string[]]>) {
+    let result: CommandResult;
+    ran = true;
+    try {
+      result = run(command, args, { cwd, timeout: TIMEOUT_MS });
+    } catch (error) {
+      result = { status: null, error: error instanceof Error ? error : new Error(String(error)) };
+    }
+    if (result.status === 0 && !result.error && !result.signal) continue;
+    const output = `${result.stdout ?? ''}\n${result.stderr ?? ''}`;
+    const diagnosticLines = output.split(/\r?\n/).filter((line) => step === 'root-tsc' ? line.includes('error TS') : Boolean(line.trim()));
+    const unmeasured = result.error || result.signal || result.status === null || diagnosticLines.length === 0;
+    const lines = diagnosticLines.slice(0, unmeasured ? 19 : 20);
+    if (unmeasured) {
+      lines.push(`[${step}] ${result.error?.message?.replace(/\s+/g, ' ') ?? (result.signal ? `signal=${result.signal}` : `exit=${result.status}`)} — 검사 실패 또는 측정 불가 (timeout=${TIMEOUT_MS}ms)`);
+    }
+    failures.push({ step, lines });
+  }
+  if (!dependency) debug.log('self-implement', 'gate.pwa-reachable', { trigger, changed: pwaReachableChanged, skipped: undefined });
+  return { ran, passed: failures.length === 0, failures, ...details,
+    ...(pwaPresent && missingDeps ? { skipped: 'pwa-deps-missing', measured: false } : !dependency ? { measured: true } : {}),
+  };
+}

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

@@ -25,6 +25,7 @@ export interface GateTestFailure {
   attribution: GateFailureAttribution;
   /** 기준선 실행 산출과 기존 missingAtBase 입력에서 독립적으로 도출한 파일 존재 상태. */
   baselinePresence: GateBaselinePresence;
+  attributedBy?: 'name-across-files';
   precondition?: GateFailurePrecondition;
   /** 같은 gate 실행 안에서 같은 시험의 통과 기록이 있으면 `may-vary`로 보존한다. 타임아웃은 재실행 결과 변동성도 함께 표현한다. */
   timeoutVariability?: TimeoutVariability;
@@ -474,6 +475,24 @@ export function classifyGateTestFailures(
   };
   const worktreeFailures = extractGateTestFailures(worktreeLog);
   const baselineFailures = baselineLog === undefined ? [] : extractGateTestFailures(baselineLog);
+  const testPath = ({ file, name }: GateTestIdentitySource): string | undefined =>
+    file && name.startsWith(`${file} > `) ? name.slice(file.length + 3) : undefined;
+  // A Bun failure header can point at a newly added file even when the stack still points at the original test.
+  // Names alone are not identities: independent files may declare identically named suites and cases.
+  const testSource = (diagnostic: string | undefined, file: string): string | undefined => {
+    const escaped = escapeRegexSegment(file);
+    const locations = [...(diagnostic ?? '').matchAll(new RegExp(`(?:^|[\\s(])(${escaped}:\\d+:\\d+)(?=[\\s)]|$)`, 'gm'))];
+    return locations.length === 1 ? locations[0]![1] : undefined;
+  };
+  const failuresAcrossFiles = new Map<string, Array<{ file: string; source: string | undefined; diagnostic: string | undefined }>>();
+  for (const failure of baselineFailures) {
+    const path = testPath(failure);
+    if (path && failure.file && !isTimeoutDiagnostic(failure.diagnostic)) {
+      const matches = failuresAcrossFiles.get(path) ?? [];
+      matches.push({ file: failure.file, source: testSource(failure.diagnostic, failure.file), diagnostic: failure.diagnostic });
+      failuresAcrossFiles.set(path, matches);
+    }
+  }
   const baselinePassed = baselinePassedEvidence?.status === 'available'
     ? passedIdentities(baselinePassedEvidence.tests ?? [])
     : baselinePassedEvidence?.status === 'unavailable' || baselineLog === undefined
@@ -534,7 +553,19 @@ export function classifyGateTestFailures(
       ? 'may-vary'
       : undefined;
     if (timeoutVariability) return { ...failure, attribution: 'unknown' as const, baselinePresence, timeoutVariability };
-    if (failure.file && missing.has(failure.file)) return { ...failure, attribution: 'introduced' as const, baselinePresence };
+    if (failure.file && missing.has(failure.file)) {
+      const path = testPath(failure);
+      const matches = path ? failuresAcrossFiles.get(path) : undefined;
+      const baseline = matches?.length === 1 ? matches[0] : undefined;
+      const source = baseline ? testSource(failure.diagnostic, baseline.file) : undefined;
+      if (baseline && path && worktreeFailures.filter((entry) => testPath(entry) === path).length === 1
+        && baseline.file !== failure.file && baseline.source && baseline.source === source
+        && baseline.diagnostic === failure.diagnostic) {
+        debug.log('self-implement.gate', 'attributed-across-files', { name: path, file: failure.file, baselineFile: baseline.file });
+        return { ...failure, attribution: 'preexisting' as const, attributedBy: 'name-across-files' as const, baselinePresence };
+      }
+      return { ...failure, attribution: 'introduced' as const, baselinePresence };
+    }
     if (baselineLog === undefined || !failure.file) return { ...failure, attribution: 'unknown' as const, baselinePresence };
     const attribution = preexisting.has(failure) ? 'preexisting' as const : 'introduced' as const;
     // 재실행 관측이 `pass`일 때만 흔들림으로 강등한다. 관측이 없거나 실패면 원래 귀속을 유지한다.

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

@@ -4,6 +4,7 @@ import { join } from 'node:path/posix';
 import { prepareDeterministicChildEnvironment } from '../../scripts/lib/deterministic-env.js';
 import { runIsolationHardcodeGate } from '../../scripts/ci-isolation-hardcode-gate.js';
 import { runModelHardcodeGate } from '../../scripts/ci-model-hardcode-gate.js';
+import { runDaemonPortGate } from '../../scripts/ci-daemon-port-gate.js';
 import { runAndroidUnitTestGate } from '../../scripts/ci-android-unit-tests.js';
 import { runIosUnitTestGate } from '../../scripts/ci-ios-unit-tests.js';
 import { runMockModuleRestoreGate } from '../../scripts/ci-mock-module-restore-gate.js';
@@ -76,6 +77,8 @@ interface SelfGateCliDeps {
   runMockModuleRestoreGate?: (out: GateOutput) => number;
   /** 모델 이름 하드코딩 래칫(🅕 #20521) — `pr land` 만 물고 하니스 무인 병합은 안 물면 위반이 main 에 들어가 남의 착지를 막는다(🅣 2026-09-25). */
   runModelHardcodeGate?: (out: GateOutput) => number;
+  /** 데몬 포트 리터럴 래칫 — 공용 `runDaemonPortGate` 를 부른다(새 스캐너 금지). */
+  runDaemonPortGate?: (out: GateOutput) => number;
   /** 안드로이드 단위 시험 게이트 심(시험 주입용). */
   runAndroidGate?: (out: GateOutput) => number;
   /** iOS 순수-로직 시험 게이트 심(시험 주입용). */
@@ -101,6 +104,26 @@ interface SelfGateCliResult {
   documentsWithoutDerivedTests: readonly string[];
 }
 
+/** 시험 단계와 독립인 정책 관문 넷. skipTestStep 이든 시험 통과든 같은 함수를 부른다. */
+function runPolicyGates(
+  files: readonly string[],
+  cwd: string,
+  lines: string[],
+  deps: SelfGateCliDeps,
+): boolean {
+  const shouldRunAdditionalGates = deps.runIsolationGate !== undefined
+    || deps.runMockModuleRestoreGate !== undefined
+    || deps.runModelHardcodeGate !== undefined
+    || deps.runDaemonPortGate !== undefined
+    || existsSync(join(cwd, 'scripts'));
+  if (!shouldRunAdditionalGates) return true;
+  const isolationPassed = runAdditionalGate('isolation-gate', deps.runIsolationGate ?? runIsolationHardcodeGate, files, cwd, lines);
+  const mockModuleRestorePassed = runAdditionalGate('mock-module-restore-gate', deps.runMockModuleRestoreGate ?? runMockModuleRestoreGate, files, cwd, lines);
+  const modelHardcodePassed = runAdditionalGate('model-hardcode-gate', deps.runModelHardcodeGate ?? runModelHardcodeGate, files, cwd, lines);
+  const daemonPortPassed = runAdditionalGate('daemon-port-gate', deps.runDaemonPortGate ?? ((out) => runDaemonPortGate({ log: out.log, error: out.error, cwd: out.cwd, args: [] })), files, cwd, lines);
+  return isolationPassed && mockModuleRestorePassed && modelHardcodePassed && daemonPortPassed;
+}
+
 function runAdditionalGate(
   name: string,
   gate: (out: GateOutput) => number,
@@ -598,20 +621,18 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
   const iosPassed = runAdditionalGate('ios-gate', deps.runIosGate ?? runIosUnitTestGate, selection.files, cwd, lines);
 
   if (scope.skipTestStep) {
+    const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
     logGateCliBaseline(cwd, { ...ZERO_GATE_BASELINE, unrunImporterTotal, lookupFailed: importerLookupFailed });
-    return { exitCode: androidPassed && iosPassed ? 0 : 1, lines, changedFiles: selection.files, testFiles: [], unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests };
+    return { exitCode: androidPassed && iosPassed && policyPassed ? 0 : 1, lines, changedFiles: selection.files, testFiles: [], unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests };
   }
 
   const test = (deps.runTests ?? ((dir, files) => (deps.runCommand ?? defaultRunCommand)('bun', ['test', ...files], dir)))(cwd, testFiles);
   const worktreeLog = formatProcessOutput(test);
   if (test.status === 0 && !test.error) {
     lines.push(formatPartialObservationNote(unrunImporterTotal ?? 0, `tests: pass (${testFiles.length} files)`));
-    const shouldRunAdditionalGates = deps.runIsolationGate !== undefined || deps.runMockModuleRestoreGate !== undefined || existsSync(join(cwd, 'scripts'));
-    const isolationPassed = !shouldRunAdditionalGates || runAdditionalGate('isolation-gate', deps.runIsolationGate ?? runIsolationHardcodeGate, selection.files, cwd, lines);
-    const mockModuleRestorePassed = !shouldRunAdditionalGates || runAdditionalGate('mock-module-restore-gate', deps.runMockModuleRestoreGate ?? runMockModuleRestoreGate, selection.files, cwd, lines);
-    const modelHardcodePassed = !shouldRunAdditionalGates || runAdditionalGate('model-hardcode-gate', deps.runModelHardcodeGate ?? runModelHardcodeGate, selection.files, cwd, lines);
+    const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
     logGateCliBaseline(cwd, { ...ZERO_GATE_BASELINE, unrunImporterTotal, lookupFailed: importerLookupFailed });
-    return { exitCode: isolationPassed && mockModuleRestorePassed && modelHardcodePassed && androidPassed && iosPassed ? 0 : 1, lines, changedFiles: selection.files, testFiles, unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests };
+    return { exitCode: policyPassed && androidPassed && iosPassed ? 0 : 1, lines, changedFiles: selection.files, testFiles, unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests };
   }
 
   if (worktreeLog.includes('deterministic environment setup failed')) lines.push(worktreeLog);
@@ -631,6 +652,7 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
     lookupFailed: importerLookupFailed,
   });
   lines.push(formatPartialObservationNote(unrunImporterTotal ?? 0, formatGateBaselineNote(report, unrunImporterTotal ?? 0)));
-  const exitCode = !androidPassed || !iosPassed || report.introduced > 0 || report.unknown > 0 || report.preconditionUnmet > 0 ? 1 : 0;
+  const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
+  const exitCode = !androidPassed || !iosPassed || !policyPassed || 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 };
 }

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

@@ -274,7 +274,7 @@ export function resolveGateScope(
   changed: readonly string[],
   exists: (path: string) => boolean,
   importerTestIndex?: ImporterTestIndex,
-  opts?: { mode?: GateScopeMode },
+  opts?: { mode?: GateScopeMode; isDeleted?: (path: string) => boolean },
 ): GateScopeDecision {
   // ⚠️ **실존 검증(리뷰 must-fix 4R)** — `gitChangedFiles` 는 `git diff --name-only HEAD` 라
   //   **삭제·rename 前 경로도 포함**한다. 그걸 그대로 `testArgs` 로 넘기면 필터가 아무것도 매치하지
@@ -310,8 +310,14 @@ export function resolveGateScope(
    * unverified 에서 빠졌다. **실행되지 않은 테스트는 검증이 아니다.**
    */
   const relatedFor = (f: string): readonly string[] => deriveRelatedTests([f], exists);
+  // 🩸 2026-09-26 실물(run-7dd4cce6): 실패 시험 0 인데 게이트가 두 라운드 «미검증 2»로 실패했다 —
+  //   ① 지운 시험 파일(없는 파일은 돌릴 수 없다 · 자식이 무엇을 해도 «검증»될 수 없다)
+  //   ② 함수만 지운 소스 — 그 파일을 import 하는 시험이 «실제로 돌았는데» 이름 짝(`x.ts`↔`x.test.ts`)만 봐서 커버로 안 셌다.
+  //   ⇒ «지운» 파일은 미검증이 아니다(호출자가 `opts.isDeleted` 로 알린다 · 남은 참조는 tsc·남은 시험이 문다) · 실행 집합의 시험이 import 하면 커버다(importer 색인).
   const coveredBy = (runSet: readonly string[]) => (f: string): boolean => {
     if (runSet.includes(f)) return true;
+    if (opts?.isDeleted?.(f)) return true;
+    if (importerTestIndex && (importerTestIndex.testsBySource.get(f) ?? []).some((t) => runSet.includes(t))) return true;
     const related = relatedFor(f);
     return related.length > 0 && related.every((t) => runSet.includes(t));
   };

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

@@ -4,6 +4,7 @@ import { classifyHeft, adversarialThreshold } from '../harness/harness-seams.js'
 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 type { GoalAuthorDeps } from './goal-author.js';
 
 const GOAL_STEPS_DECOMPOSED_EVENT = 'goal-steps-decomposed';
@@ -63,10 +64,11 @@ export function createGoalAuthorDecomposeSteps(
 ): NonNullable<GoalAuthorDeps['decomposeSteps']> {
   return async (objective, options) => {
     const { streamLLM } = await import('../llm.js');
+    let decompositionRationale: string | undefined;
     const steps = await llmDecomposeSteps(
       objective,
       (input) => streamLLM([{ role: 'user', content: input.prompt }], () => {}, { reasoningEffort: 'high' }).then((text) => ({ text })),
-      { ...(options?.context ? { context: options.context } : {}), maxTasks: GOAL_AUTHOR_COARSE_MAX_SLICES, promptProfile: 'goal-author-coarse', ...(signal ? { signal } : {}) },
+      { ...(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);
     const adversarialReviewSource = config.adversarialReviewSource
@@ -101,7 +103,23 @@ export function createGoalAuthorDecomposeSteps(
       reviewExecuted,
       reviewSkipReason,
     });
-    if (!reviewExecuted) return steps;
+    const finalize = (finalSteps: string[], rationale?: string): string[] => {
+      if (finalSteps.length > 0 && rationale?.trim()) {
+        try {
+          emitDecision({
+            kind: 'PLAN',
+            what: finalSteps.length === 1 ? '분해 안 함(한 조각)' : `골을 조각 ${finalSteps.length}개로 분해`,
+            reason: rationale.trim().split(/\r?\n|(?<=[.!?。])\s+/)[0]!,
+            purpose: '조각마다 독립 런으로 · 실패를 작게 가둔다',
+            target: finalSteps.slice(0, 8).join(' · '),
+            paths: finalSteps.length,
+            ...(options?.runId === undefined ? {} : { runId: options.runId }),
+          });
+        } catch { /* Live detail cannot change the decomposition result. */ }
+      }
+      return finalSteps;
+    };
+    if (!reviewExecuted) return finalize(steps, decompositionRationale);
     const critic = (prompt: string) => streamLLM([{ role: 'user', content: prompt }], () => {}, { reasoningEffort: 'high' });
 
     try {
@@ -118,7 +136,7 @@ export function createGoalAuthorDecomposeSteps(
           byAxis,
           reviewEnabled,
         });
-        return critique.revisedSteps;
+        return finalize(critique.revisedSteps);
       }
 
       debug.log('goal-author', 'adversarial-sound', {
@@ -132,6 +150,6 @@ export function createGoalAuthorDecomposeSteps(
     } catch {
       // The red-team is advisory; authoring must retain the LLM decomposition on failure.
     }
-    return steps;
+    return finalize(steps, decompositionRationale);
   };
 }

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

@@ -82,7 +82,7 @@ export interface GoalAuthorDeps {
   /** Optional externally decomposed plan steps rendered verbatim into the authored goal; the author never generates them. */
   steps?: readonly string[];
   /** Optional injected decomposition seam; omitted means authoring never invokes an LLM or decomposition. */
-  decomposeSteps?: (objective: string, opts?: { context?: string }) => Promise<readonly string[]>;
+  decomposeSteps?: (objective: string, opts?: { context?: string; runId?: string }) => Promise<readonly string[]>;
   /** Optional launch preflight result supplied by the caller; authoring never reads the ledger or logs itself. */
   launchPreflight?: LaunchPreflightResult;
   /** Optional in-process notification for each authored-goal phase transition. */
@@ -3784,6 +3784,26 @@ export function verbatimOriginalAsk(document: string): string | null {
   return extractVerbatimOriginalAsk(document)?.ask ?? null;
 }
 
+/** One header under which a fragment copies its parent document's `경계:` lines verbatim.
+ *  Not a markdown heading: a `##` line inside SCOPE BOUNDARY splits the required-block order. */
+export const PARENT_BOUNDARY_HEADER = 'Parent boundary lines:';
+
+/** `경계:` lines of one document, in source order, with surrounding whitespace removed and nothing else rewritten. */
+export function boundaryLinesVerbatim(document: string): string[] {
+  const ask = verbatimOriginalAsk(document) ?? document;
+  return ask.split(/\r?\n/).flatMap((line) => {
+    const trimmed = line.trim();
+    return trimmed.startsWith('경계:') ? [trimmed] : [];
+  });
+}
+
+/** When a fragment has a parent, one header followed by that parent's `경계:` lines; otherwise nothing. */
+export function parentBoundaryLines(parentDocument: string | undefined): string[] {
+  if (parentDocument === undefined) return [];
+  const lines = boundaryLinesVerbatim(parentDocument);
+  return lines.length === 0 ? [] : [PARENT_BOUNDARY_HEADER, ...lines];
+}
+
 /** 재저작이 «사람의 ask» 를 지켰는지 — 부모 골과 자식 골의 원래 ask 블록을 마주 세운다.
  *
  *  ⭐ 왜 있나(2026-08-11 72차): 되묻기에 답하면 재저작이 «일어나는» 것까지는 관측(`ask-reauthored`)이
@@ -5046,7 +5066,7 @@ async function authorGoalWithSupersededRootIntent(
     const startedAt = Date.now();
     let failed = false;
     try {
-      const decomposed = await deps.decomposeSteps(ask, { context: facts?.context || undefined });
+      const decomposed = await deps.decomposeSteps(ask, { context: facts?.context || undefined, runId: process.env.ELANOUS_RUN_ID?.trim() || authorRunId });
       if (decomposed.length > 0) resolvedSteps = decomposed;
     } catch {
       failed = true;
@@ -5231,6 +5251,7 @@ async function authorGoalWithSupersededRootIntent(
   ];
   const scopeBoundarySection = [
     ...scopeCandidates,
+    ...parentBoundaryLines(deps.parentDocument),
     ...authorBoundaryMatches.flatMap((candidate) => [
       `- Boundary decision: ${candidate.value}`, 
       ...(isNormalizedAskMatch(candidate) ? [`  - Normalized ask marker: original=${JSON.stringify(candidate.original)}; normalized=${JSON.stringify(candidate.normalized)}`] : []),

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

@@ -0,0 +1,65 @@
+const BOUNDARY_LINE = /(?:^|\n)[ \t]*(?:[-*+][ \t]+|>[ \t]*)*경계:[ \t]*([^\n]*)/g;
+const BACKTICK_PATH = /`([^`\n]+)`/g;
+
+function isPathOrGlob(token: string): boolean {
+  const value = token.trim().replace(/^\.\//, '');
+  if (!value || /\s/.test(value) || value === '.') return false;
+  if (value.startsWith('/') || value.includes('..')) return false;
+  return /^(?:[A-Za-z0-9._@~+-]+\/)*[A-Za-z0-9._@~*+-]+$/.test(value);
+}
+
+/** Backtick-wrapped paths and globs on `경계:` lines, in document order. */
+export function boundaryGlobs(goalDocument: string): string[] {
+  const found: string[] = [];
+  for (const line of goalDocument.matchAll(BOUNDARY_LINE)) {
+    const body = line[1] ?? '';
+    for (const wrapped of body.matchAll(BACKTICK_PATH)) {
+      const value = (wrapped[1] ?? '').trim();
+      if (isPathOrGlob(value)) found.push(value);
+    }
+  }
+  return found;
+}
+
+function normalizeBoundaryPath(path: string): string {
+  return path.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');
+}
+
+function escapeBoundaryAtom(atom: string): string {
+  return atom.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/** `*` stays in one segment. `**` crosses segments. A pattern with no wildcard also matches descendants. */
+function boundaryGlobMatches(pattern: string, file: string): boolean {
+  const glob = normalizeBoundaryPath(pattern);
+  const target = normalizeBoundaryPath(file);
+  if (!glob || !target) return false;
+  const doubled = glob.replace(/\/?\*\*(?:\/|$)/g, '\u0000');
+  const expression = doubled
+    .split('\u0000')
+    .map((part) => part.split('/').filter(Boolean).map((segment) => (
+      segment.split('*').map(escapeBoundaryAtom).join('[^/]*')
+    )).join('/'))
+    .join('(?:/[^/]+)*');
+  const anchored = glob.includes('*') ? `^${expression}$` : `^${expression}(?:/.*)?$`;
+  return new RegExp(anchored).test(target);
+}
+
+/**
+ * Changed files that land on a declared `경계:` glob.
+ * Does not decide the run — the caller only reports the names.
+ */
+export function boundaryViolations(globs: readonly string[], changedFiles: readonly string[]): string[] {
+  const patterns = [...new Set(globs.map(normalizeBoundaryPath).filter(Boolean))];
+  if (patterns.length === 0) return [];
+  const hits: string[] = [];
+  const seen = new Set<string>();
+  for (const file of changedFiles) {
+    const normalized = normalizeBoundaryPath(file);
+    if (!normalized || seen.has(normalized)) continue;
+    if (!patterns.some((pattern) => boundaryGlobMatches(pattern, normalized))) continue;
+    seen.add(normalized);
+    hits.push(normalized);
+  }
+  return hits;
+}

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

@@ -308,6 +308,7 @@ function isMissingDeliveryResolver(
 ): boolean {
   return dispatched.absenceReason === 'no-capable-peer'
     || dispatched.absenceReason === 'no-delivery-resolver'
+    || dispatched.absenceReason === 'no-tui-deps-no-resolver'
     // Compatibility for dispatch implementations that predate absenceReason.
     || /requires a HITL resolver, but none is installed in this surface/i.test(dispatched.output);
 }

package/src/self-implement/goal-documents-dir.ts

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { debug } from '../debug/log.js';
+import { excludeProjectDotElanous } from '../instance/project-local-exclude.js';
 import { getUserConfig, type UserConfig } from '../user-config.js';
 
 /** Why `resolveGoalDocumentsDir` picked the directory it returned. */
@@ -19,6 +20,8 @@ export interface ResolveGoalDocumentsDirDeps {
   exists?: (path: string) => boolean;
   /** Resolution observation. Defaults to `debug.log`. */
   log?: (category: string, event: string, data?: unknown) => void;
+  /** `.elanous/` 를 저장소의 로컬 무시 목록에 올린다(시험 seam). 기본 = `excludeProjectDotElanous`. */
+  excludeDotElanous?: (repoRoot: string) => string;
 }
 
 const DOCS_GOALS = ['docs', 'goals'] as const;
@@ -46,7 +49,9 @@ export function resolveGoalDocumentsDir(
       ? { directory: join(root, ...DOCS_GOALS), reason: 'existing-docs-goals' as const }
       : { directory: join(root, '.elanous', 'goals'), reason: 'default-dot-elanous' as const });
 
-  log('harness.goals-dir', 'resolved', { repoRoot: root, directory: resolved.directory, reason: resolved.reason });
+  // 기본 자리(`.elanous/goals`)면 그 저장소의 로컬 무시 목록에 올린다(UX 13 · 사용자 git status 를 더럽히지 않게).
+  const excluded = resolved.reason === 'default-dot-elanous' ? (deps.excludeDotElanous ?? excludeProjectDotElanous)(root) : undefined;
+  log('harness.goals-dir', 'resolved', { repoRoot: root, directory: resolved.directory, reason: resolved.reason, ...(excluded ? { excluded } : {}) });
   return resolved;
 }
 

package/src/self-implement/goal-execution-records.ts

@@ -0,0 +1,58 @@
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { goalRunDbPath } from './goal-run-store.js';
+
+export interface GoalRunRecordFragment {
+  runId: string;
+  path: string;
+  markdown: string;
+}
+
+function safeId(id: string): string {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(id) || id === '..') {
+    throw new Error(`Invalid goal record identifier: ${id}`);
+  }
+  return id;
+}
+
+function fragmentsDir(goalId: string): string {
+  // The goal-run ledger and these fragments share the same instance-scoped state root.
+  return join(dirname(dirname(goalRunDbPath())), 'goal-records', safeId(goalId));
+}
+
+/** Atomically replace this run's complete Markdown fragment (never expose a partial write). */
+export function writeGoalRunRecordFragment(goalId: string, runId: string, markdown: string): string {
+  const directory = fragmentsDir(goalId);
+  const destination = join(directory, `${safeId(runId)}.md`);
+  mkdirSync(directory, { recursive: true });
+  const temporary = join(directory, `.${runId}.${randomUUID()}.tmp`);
+  try {
+    writeFileSync(temporary, markdown, { encoding: 'utf8', flag: 'wx' });
+    renameSync(temporary, destination);
+  } catch (error) {
+    try { unlinkSync(temporary); } catch { /* The temporary file may not have been created. */ }
+    throw error;
+  }
+  return destination;
+}
+
+/** Return complete fragments for one goal, ordered by run ID; absent goals have no records. */
+export function listGoalRunRecordFragments(goalId: string): GoalRunRecordFragment[] {
+  const directory = fragmentsDir(goalId);
+  let entries;
+  try {
+    entries = readdirSync(directory, { withFileTypes: true });
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
+    throw error;
+  }
+  return entries
+    .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .map((entry) => ({
+      runId: entry.name.slice(0, -3),
+      path: join(directory, entry.name),
+      markdown: readFileSync(join(directory, entry.name), 'utf8'),
+    }));
+}

package/src/self-implement/goal-run-store.ts

@@ -362,34 +362,52 @@ export class GoalRunStore {
     }
     if (path !== ':memory:') mkdirSync(dirname(path), { recursive: true });
     this.db = new Database(path);
-    this.db.run('PRAGMA journal_mode = WAL');
-    this.db.run(`CREATE TABLE IF NOT EXISTS goal_run (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      run_id TEXT NOT NULL,
-      goal_id TEXT NOT NULL,
-      goal_file TEXT NOT NULL,
-      doc TEXT NOT NULL,
-      started_at TEXT GENERATED ALWAYS AS (json_extract(doc, '$.startedAt')) VIRTUAL,
-      outcome TEXT GENERATED ALWAYS AS (json_extract(doc, '$.outcome')) VIRTUAL,
-      rounds INTEGER GENERATED ALWAYS AS (json_extract(doc, '$.rounds')) VIRTUAL,
-      executor TEXT GENERATED ALWAYS AS (json_extract(doc, '$.model')) VIRTUAL
-    )`);
-    // RFC 런 출처 O5 — 기계별 집계를 인덱스로. 옛 DB 는 VIRTUAL 생성 열이라 ALTER 로 더할 수 있다(옛 행은 NULL).
-    const columns = this.db.query('PRAGMA table_xinfo(goal_run)').all() as Array<{ name: string }>;
-    if (!columns.some((c) => c.name === 'host_id')) {
-      this.db.run("ALTER TABLE goal_run ADD COLUMN host_id TEXT GENERATED ALWAYS AS (json_extract(doc, '$.hostId')) VIRTUAL");
+    this.db.run('PRAGMA busy_timeout = 5000');
+    const openedAt = Date.now();
+    try {
+      this.db.run('PRAGMA journal_mode = WAL');
+      this.db.run(`CREATE TABLE IF NOT EXISTS goal_run (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        run_id TEXT NOT NULL,
+        goal_id TEXT NOT NULL,
+        goal_file TEXT NOT NULL,
+        doc TEXT NOT NULL,
+        started_at TEXT GENERATED ALWAYS AS (json_extract(doc, '$.startedAt')) VIRTUAL,
+        outcome TEXT GENERATED ALWAYS AS (json_extract(doc, '$.outcome')) VIRTUAL,
+        rounds INTEGER GENERATED ALWAYS AS (json_extract(doc, '$.rounds')) VIRTUAL,
+        executor TEXT GENERATED ALWAYS AS (json_extract(doc, '$.model')) VIRTUAL
+      )`);
+      // RFC 런 출처 O5 — 기계별 집계를 인덱스로. 옛 DB 는 VIRTUAL 생성 열이라 ALTER 로 더할 수 있다(옛 행은 NULL).
+      const columns = this.db.query('PRAGMA table_xinfo(goal_run)').all() as Array<{ name: string }>;
+      if (!columns.some((c) => c.name === 'host_id')) {
+        this.db.run("ALTER TABLE goal_run ADD COLUMN host_id TEXT GENERATED ALWAYS AS (json_extract(doc, '$.hostId')) VIRTUAL");
+      }
+      this.db.run('CREATE INDEX IF NOT EXISTS goal_run_by_host ON goal_run(host_id, started_at)');
+      this.db.run('CREATE INDEX IF NOT EXISTS goal_run_by_goal ON goal_run(goal_id, started_at)');
+      this.db.run('CREATE INDEX IF NOT EXISTS goal_run_by_run ON goal_run(run_id)');
+      this.db.run('CREATE INDEX IF NOT EXISTS goal_run_by_file ON goal_run(goal_file)');
+    } catch (error) {
+      this.db.close();
+      if (/SQLITE_BUSY|SQLITE_LOCKED|database is locked|database is busy/i.test(String(error))) {
+        debug.log('store.sqlite', 'busy-lost', { store: 'goal_run', op: 'open', waitedMs: Date.now() - openedAt });
+      }
+      throw error;
     }
-    this.db.run('CREATE INDEX IF NOT EXISTS goal_run_by_host ON goal_run(host_id, started_at)');
-    this.db.run('CREATE INDEX IF NOT EXISTS goal_run_by_goal ON goal_run(goal_id, started_at)');
-    this.db.run('CREATE INDEX IF NOT EXISTS goal_run_by_run ON goal_run(run_id)');
-    this.db.run('CREATE INDEX IF NOT EXISTS goal_run_by_file ON goal_run(goal_file)');
   }
 
   insert(goalFile: string, record: GoalExecutionRecord, goalId?: string): void {
-    this.db.run(
-      'INSERT INTO goal_run (run_id, goal_id, goal_file, doc) VALUES (?, ?, ?, ?)',
-      [record.runId, goalId ?? goalIdFromDocument(goalFile), normalizeGoalFile(goalFile), serializeGoalExecutionRecord(withRecordOrigin(record))],
-    );
+    const startedAt = Date.now();
+    try {
+      this.db.run(
+        'INSERT INTO goal_run (run_id, goal_id, goal_file, doc) VALUES (?, ?, ?, ?)',
+        [record.runId, goalId ?? goalIdFromDocument(goalFile), normalizeGoalFile(goalFile), serializeGoalExecutionRecord(withRecordOrigin(record))],
+      );
+    } catch (error) {
+      if (/SQLITE_BUSY|SQLITE_LOCKED|database is locked|database is busy/i.test(String(error))) {
+        debug.log('store.sqlite', 'busy-lost', { store: 'goal_run', op: 'insert', waitedMs: Date.now() - startedAt });
+      }
+      throw error;
+    }
   }
 
   byRunId(runId: string): GoalRunRecord[] {