elanous 0.2.41 → 0.2.43

package/src/self-dev/decompose.ts

@@ -107,7 +107,7 @@ export interface SelfDevDecompositionMeta {
    *  `authored-empty`           Fabric 저작이 분해할 arc를 만들지 못했다
    *  `llm-failed`               LLM 호출 자체가 «실패»했다(타임아웃·제공자 장애) ⇒ 분해를 «못 한» 것이다
    *  ⛔ 「쪼갤 필요가 없었다」와 Fabric 사전분해 실패는 다른 값이다. */
-  outcome: 'decomposed' | 'single-no-subtasks' | 'missing-research-context' | 'grounding-empty' | 'authored-empty' | 'llm-failed';
+  outcome: 'decomposed' | 'single-no-subtasks' | 'slice-rejected' | 'missing-research-context' | 'grounding-empty' | 'authored-empty' | 'llm-failed';
   /** `llm-failed` 일 때만 실린다 — 문면의 «머리»를 자르지 않는다. */
   error?: string;
   /** Present for Fabric decomposition, including zero, to distinguish no omissions from no report. */
@@ -399,6 +399,10 @@ export function buildSelfDevDecomposePrompt(feature: string, maxTasks = DEFAULT_
     '- SEPARATE DEFINE FROM WIRE: adding a new function/type/export is a SEPARATE task from wiring it into an existing runtime call site. A task that both defines a new symbol AND integrates it across modules tends to leave dead-code (defined but never called) that fails integration gates. Pattern: (a) add the function + its unit test; then (b) a dependent task that wires it into the specific existing call site — name the exact `file.ts:function` to modify.',
     '- Exception to SEPARATE DEFINE FROM WIRE: Keep a definition and its registration/wiring in the same sub-feature — a handler with its route, a command with its CLI registration, a node with its graph/recipe entry.',
     '- Each sub-feature must be a self-contained, mergeable unit of work.',
+    '- LANDABLE SLICE CONTRACT: every sub-feature must state a completionBoundary that can be implemented and verified without a later sub-feature, future component, or unwired operational path. If it cannot stand alone, split it further or omit it.',
+    '- Every sub-feature must name one existing mock scenario as mockScenario.id (MS-01, MS-02, ...), plus a concrete mockScenario.injection and mockScenario.observation. Describe the event or input injected and the output/event that proves the slice works.',
+    '- List every required earlier slice explicitly in dependsOn. An empty list means this slice has no predecessor; never rely on implicit order or a future capability.',
+    '- Declare futureAssumptions as an array. If the slice needs any future component, later slice, or unwired operational path, list it there; that slice will be rejected with a decompose.slice-rejected event containing its id and reason, and must be split or omitted.',
     '- `dependsOn`: list the `id`s of sub-features that MUST land first (e.g. a shared',
     '  type/interface before its consumers). Independent sub-features share NO dependency',
     '  so they run in parallel. No cycles.',
@@ -410,8 +414,10 @@ export function buildSelfDevDecomposePrompt(feature: string, maxTasks = DEFAULT_
     '',
     '## Output (STRICT JSON — no prose, no code fence)',
     '{"subtasks":[{"id":"<short-slug>","feature":"<imperative sub-feature text>",',
-    '  "dependsOn":["<id>",...],"hotPaths":["<path>",...],',
-    '  "goalType":"<implement|research|document|operate>"}]}',
+    '  "completionBoundary":"<standalone change and observable outcome>",',
+    '  "mockScenario":{"id":"MS-01","injection":"<input/event injected>","observation":"<output/event observed>"},',
+    '  "futureAssumptions":[],"dependsOn":["<explicit predecessor id>",...],',
+    '  "hotPaths":["<path>",...],"goalType":"<implement|research|document|operate>"}]}',
   ].join('\n');
 }
 
@@ -421,6 +427,19 @@ interface RawSubtask {
   dependsOn?: unknown;
   hotPaths?: unknown;
   goalType?: unknown;
+  completionBoundary?: unknown;
+  mockScenario?: unknown;
+  futureAssumptions?: unknown;
+}
+
+interface RejectedDecompositionSlice {
+  id: string | null;
+  reasons: string[];
+}
+
+interface ValidatedDecomposition {
+  goals: SelfDevGoal[];
+  rejected: RejectedDecompositionSlice[];
 }
 
 const SELF_DEV_GOAL_TYPES = new Set(['implement', 'research', 'document', 'operate'] as const);
@@ -625,6 +644,90 @@ export function parseSelfDevDecomposition(
   return goals;
 }
 
+/** Parse the production decomposition contract and keep a reason for each rejected slice. */
+function parseValidatedSelfDevDecomposition(
+  subtasks: readonly unknown[],
+  defaults: { base?: string; autoMerge?: boolean },
+): ValidatedDecomposition {
+  const goals: SelfDevGoal[] = [];
+  const rejected: RejectedDecompositionSlice[] = [];
+  const allIds = new Set(subtasks.flatMap((value) => isRawSubtask(value)
+    && typeof value.id === 'string' && value.id.trim() ? [value.id.trim()] : []));
+  const seenIds = new Set<string>();
+
+  subtasks.forEach((value, index) => {
+    if (!isRawSubtask(value)) {
+      rejected.push({ id: null, reasons: ['slice must be an object'] });
+      return;
+    }
+    const feature = typeof value.feature === 'string' ? value.feature.trim() : '';
+    const id = typeof value.id === 'string' && value.id.trim() ? value.id.trim() : String(index);
+    const reasons: string[] = [];
+    const completionBoundary = typeof value.completionBoundary === 'string' ? value.completionBoundary.trim() : '';
+    if (!feature) reasons.push('feature is missing');
+    if (!completionBoundary) reasons.push('completionBoundary is missing');
+
+    const mock = value.mockScenario as { id?: unknown; injection?: unknown; observation?: unknown } | undefined;
+    const scenarioId = typeof mock?.id === 'string' ? mock.id.trim() : '';
+    const injection = typeof mock?.injection === 'string' ? mock.injection.trim() : '';
+    const observation = typeof mock?.observation === 'string' ? mock.observation.trim() : '';
+    if (!/^MS-[A-Z0-9][A-Z0-9-]*$/i.test(scenarioId)) reasons.push('mockScenario.id must be an MS id');
+    if (!injection) reasons.push('mockScenario.injection is missing');
+    if (!observation) reasons.push('mockScenario.observation is missing');
+
+    if (!Array.isArray(value.futureAssumptions)) reasons.push('futureAssumptions must be declared as an array');
+    else if (value.futureAssumptions.length > 0) reasons.push('future assumptions require split or omission');
+
+    if (value.dependsOn === undefined) reasons.push('dependsOn is missing; declare an explicit id array');
+    else if (!Array.isArray(value.dependsOn)) reasons.push('dependsOn must be an explicit id array');
+    const dependsOn = Array.isArray(value.dependsOn)
+      ? value.dependsOn.filter((dependency): dependency is string => typeof dependency === 'string' && dependency.trim().length > 0)
+      : [];
+    if (Array.isArray(value.dependsOn) && dependsOn.length !== value.dependsOn.length) reasons.push('dependsOn contains an invalid predecessor id');
+    for (const dependency of dependsOn) {
+      if (dependency === id || !allIds.has(dependency)) reasons.push(`dependsOn references a missing or self predecessor: ${dependency}`);
+    }
+
+    let uniqueId = id;
+    if (seenIds.has(uniqueId)) uniqueId = `${uniqueId}-${index}`;
+    seenIds.add(uniqueId);
+    if (reasons.length) {
+      rejected.push({ id, reasons: [...new Set(reasons)] });
+      return;
+    }
+
+    const llmHot = Array.isArray(value.hotPaths)
+      ? value.hotPaths.filter((path): path is string => typeof path === 'string')
+      : [];
+    const hotPaths = [...new Set([...llmHot, ...inferHotPaths(feature)])];
+    goals.push({
+      id: uniqueId,
+      feature,
+      completionBoundary,
+      mockScenario: { id: scenarioId, injection, observation },
+      ...(dependsOn.length ? { dependsOn } : {}),
+      ...(hotPaths.length ? { hotPaths } : {}),
+      ...(isSelfDevGoalType(value.goalType) ? { goalType: value.goalType } : {}),
+      ...defaults,
+    });
+  });
+
+  // A dependent slice cannot stay independently landable when its predecessor was rejected.
+  let removedDependent = true;
+  while (removedDependent) {
+    removedDependent = false;
+    const validIds = new Set(goals.map((goal) => goal.id));
+    for (const goal of [...goals]) {
+      const missing = (goal.dependsOn ?? []).filter((dependency) => !validIds.has(dependency));
+      if (missing.length === 0) continue;
+      goals.splice(goals.indexOf(goal), 1);
+      rejected.push({ id: goal.id ?? null, reasons: [`dependsOn references a rejected predecessor: ${missing.join(', ')}`] });
+      removedDependent = true;
+    }
+  }
+  return { goals, rejected };
+}
+
 /**
  * Decompose a feature into a self-dev DAG via the LLM seam. Falls back to
  * a single goal (the whole feature) when decomposition yields nothing —
@@ -710,10 +813,21 @@ export async function decomposeSelfDevGoal(
   const rawSubtasks = extractRawSubtasks(raw);
   const actualTaskCount = rawSubtasks.length;
   const decomposition: SelfDevDecompositionMeta = { recommendedMaxTasks: maxTasks, actualTaskCount, truncatedAtHardMax: actualTaskCount > hardMaxTasks, exceededRecommendedMax: actualTaskCount > maxTasks, outcome: actualTaskCount === 0 ? 'single-no-subtasks' : 'decomposed' };
-  const parsedGoals = parseSelfDevDecomposition(JSON.stringify({ subtasks: rawSubtasks.slice(0, hardMaxTasks) }), defaults);
+  const validated = parseValidatedSelfDevDecomposition(rawSubtasks.slice(0, hardMaxTasks), defaults);
+  for (const rejection of validated.rejected) {
+    debug.log(opts.observation?.category ?? 'self-dev.decompose', 'decompose.slice-rejected', {
+      ...observationIdentity(opts.observation ?? {}),
+      sliceId: rejection.id,
+      reasons: rejection.reasons,
+    }, { level: 'warn' });
+  }
+  const parsedGoals = validated.goals;
   const foldedGoals = foldRegistrationOnlyGoals(parsedGoals);
   const goals = parsedGoals.length > 0 ? pruneDanglingDependencies(foldedGoals) : [single];
-  return finalizeDecomposition(feature, goals, decomposition, opts, parsedGoals.length > 0 ? arcHint : undefined, parsedGoals.length - foldedGoals.length);
+  const finalDecomposition = parsedGoals.length === 0 && validated.rejected.length > 0
+    ? { ...decomposition, outcome: 'slice-rejected' as const }
+    : decomposition;
+  return finalizeDecomposition(feature, goals, finalDecomposition, opts, parsedGoals.length > 0 ? arcHint : undefined, parsedGoals.length - foldedGoals.length);
 }
 
 /** Where the decompose model came from — `'explicit'` is the caller's `model` argument layer. */

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

@@ -67,6 +67,7 @@ import { BEDROCK_DEFAULT_MODEL, BEDROCK_MODELS, findBedrockModel, resolveBedrock
 import { ZAI_CODING_DEFAULT_MODEL, ZAI_CODING_MODELS } from '../llm/zai-coding-plan.js';
 import { isVerifiedOpenGatewayModel, OPENGATEWAY_DEFAULT_MODEL, OPENGATEWAY_VERIFIED_MODELS } from '../llm/opengateway-models.js';
 import { DEV_PLAN_REPLACEMENT } from './cli-help-text.js';
+import { DEFAULT_TUI_TEST_READY_TIMEOUT_MS } from '../self-implement/elanous-tui-spawn.js';
 export { DEV_PLAN_REPLACEMENT, formatDevPlanOptionHelp } from './cli-help-text.js';
 
 /** dev CLI 옵션(commander) — `--no-*` 는 false 로 도착. input/executor 는 액션이 빌드해 별도 전달. */
@@ -2187,7 +2188,9 @@ export function buildDevCliSpec(
       ...spec,
       elanous: {
         ...(opts.hold ? { hold: true } : {}),
-        ...(opts.readyTimeoutMs !== undefined ? { readyTimeoutMs: parsePositiveInt(opts.readyTimeoutMs, '--ready-timeout-ms') } : {}),
+        ...(opts.readyTimeoutMs !== undefined
+          ? { readyTimeoutMs: parsePositiveInt(opts.readyTimeoutMs, '--ready-timeout-ms') }
+          : opts.hold ? { readyTimeoutMs: DEFAULT_TUI_TEST_READY_TIMEOUT_MS } : {}),
         ...(opts.json ? { json: true } : {}),
         ...(opts.goal !== undefined ? { goal: opts.goal } : {}),
         ...(opts.maxSteps !== undefined ? { maxSteps: parsePositiveInt(opts.maxSteps, '--max-steps') } : {}),

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

@@ -68,6 +68,8 @@ export interface DevMissionOpts {
   resources?: 'on' | 'off';
   backendExplicit?: string;
   headless?: boolean;
+  /** Optional second user turn resumed in the same Claude/Codex CLI session. */
+  followUp?: string;
   evidence?: EvidenceMode;
   maxRounds?: number;
   commit?: boolean;
@@ -643,6 +645,7 @@ export function toAgentMissionSpec(
     evidence: m.evidence ?? { kind: 'tsc' }, // 기본 tsc(mission 옵션 미지정 시)
     agent: resolveBackend(plan.executor.backend),
     ...(m.headless === true ? { headless: true } : {}),
+    ...(m.followUp !== undefined ? { followUp: m.followUp } : {}),
     ...(m.chain ? { chain: m.chain } : {}),
     ...(m.plugin ? { plugin: m.plugin } : {}),
     ...(m.resources !== undefined ? { resources: m.resources } : {}),
@@ -670,6 +673,7 @@ export function buildAgentMissionDevSpec(o: {
   branch: string;
   base?: string;
   headless?: boolean;
+  followUp?: string;
   chain?: readonly ('codex' | 'claude' | 'elanous')[];
   plugin?: { plugin: string; marketplace: string };
   resources?: 'on' | 'off';
@@ -691,6 +695,7 @@ export function buildAgentMissionDevSpec(o: {
     mission: {
       evidence: o.evidence,
       ...(o.headless === true ? { headless: true } : {}),
+      ...(o.followUp !== undefined ? { followUp: o.followUp } : {}),
       ...(o.chain ? { chain: o.chain } : {}),
       ...(o.plugin ? { plugin: o.plugin } : {}),
       ...(o.resources !== undefined ? { resources: o.resources } : {}),

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

@@ -3,7 +3,7 @@ import { readdirSync, readFileSync, existsSync } from 'node:fs';
 import { gunzipSync } from 'node:zlib';
 import { basename, dirname, join } from 'node:path';
 import { findGitDir } from '../git-fs/locate.js';
-import { debug } from '../debug/log.js';
+import { debug, redactSecretText } from '../debug/log.js';
 import { PR_LABELS, PR_LABEL_NAMES } from '../github/pr-labels.js';
 import { appendRunLedgerEntry, listRunLedgers, loadRunLedger, runLedgerDir, type RunLedgerEntry } from '../self-implement/run-ledger.js';
 import { queryRunningRuns } from '../self-implement/running-runs.js';
@@ -161,9 +161,42 @@ const GH_MAX_BUFFER = 64 * 1024 * 1024;
  *  several times larger than this projection, so the listing asks gh to project each page down to these fields. */
 const OPEN_DRAFT_FIELDS = '[.[] | {number, title, headRefName: .head.ref, createdAt: .created_at, body, labels: [.labels[] | {name}], draft}]';
 
+interface GhFailureEvidence {
+  args: readonly string[];
+  status: number | null;
+  signal: NodeJS.Signals | null;
+  errorCode?: string;
+  stderr: string;
+  capturedStderrBytes: number;
+  stdoutBytes: number;
+}
+
+class GhCommandError extends Error {
+  constructor(message: string, readonly evidence: GhFailureEvidence) {
+    super(message);
+    this.name = 'GhCommandError';
+  }
+}
+
+function executionSha(): string | undefined {
+  const sha = process.env.ELANOUS_EXECUTION_SHA?.trim();
+  return sha && /^[a-f0-9]{40}$/i.test(sha) ? sha : undefined;
+}
+
 function gh(args: string[]): string {
-  const result = spawnSync('gh', args, { cwd: findGitDir(process.cwd())?.root ?? process.cwd(), encoding: 'utf8', timeout: 60_000, maxBuffer: GH_MAX_BUFFER });
-  if (result.status !== 0) throw new Error((result.stderr || result.error?.message || `gh exited ${result.status}`).trim().slice(0, 200));
+  const cwd = findGitDir(process.cwd())?.root ?? process.cwd();
+  const result = spawnSync('gh', args, { cwd, encoding: 'utf8', timeout: 60_000, maxBuffer: GH_MAX_BUFFER });
+  if (result.status !== 0) {
+    const spawnError = result.error as NodeJS.ErrnoException | undefined;
+    const stderr = result.stderr ?? '';
+    const reason = (stderr || spawnError?.message || `gh exited ${result.status}`).trim().slice(0, 200);
+    throw new GhCommandError(reason, {
+      args: [...args], status: result.status, signal: result.signal,
+      ...(spawnError?.code ? { errorCode: spawnError.code } : {}),
+      stderr: redactSecretText(stderr).replace(/[\r\n\t\x00-\x1f\x7f]+/g, ' ').slice(0, 4_000), capturedStderrBytes: Buffer.byteLength(stderr),
+      stdoutBytes: Buffer.byteLength(result.stdout ?? ''),
+    });
+  }
   return result.stdout.trim();
 }
 function ghPr(row: { number: number; title: string; headRefName: string; headRefOid?: string; isDraft?: boolean; createdAt: string; body: string; labels: Array<{ name: string }>; comments?: Array<{ body: string }>; state?: string }): ResiduePr {
@@ -233,8 +266,9 @@ export function defaultAdapters(sources: ResidueRunStatusSources = defaultRunSta
     },
     listOpenDrafts: (repository) => {
       const rows: ResiduePr[] = [];
+      let page = 0;
       try {
-        for (let page = 1; page <= 100; page++) {
+        for (page = 1; page <= 100; page++) {
           const result = JSON.parse(gh(['api', `repos/${repository}/pulls?state=open&per_page=100&page=${page}`, '--jq', OPEN_DRAFT_FIELDS])) as Array<{
             number: number; title: string; headRefName: string; createdAt: string; body: string;
             labels: Array<{ name: string }>; draft: boolean;
@@ -246,7 +280,32 @@ export function defaultAdapters(sources: ResidueRunStatusSources = defaultRunSta
         throw new Error('Open PR inventory exceeded pagination limit');
       } catch (error) {
         // «못 셌음»: a failed (or truncated) listing is unmeasurable — it must never surface as a counted zero.
-        debug.log('draft.residue', 'list-open-drafts-unobserved', { repository, reason: error instanceof Error ? error.message : String(error) });
+        const ghEvidence = error instanceof GhCommandError ? error.evidence : undefined;
+        const reason = error instanceof Error ? error.message : String(error);
+        const isEnobufs = ghEvidence?.errorCode === 'ENOBUFS' || /ENOBUFS/.test(reason);
+        const runSha = executionSha();
+        const responseBytes = !ghEvidence
+          ? { status: 'unmeasured', complete: false,
+            reason: /pagination limit/.test(reason) ? 'pagination limit reached; aggregate page response bytes were not retained'
+              : 'the failed inventory response byte count was not retained' }
+          : isEnobufs || ghEvidence.errorCode || ghEvidence.status === null || ghEvidence.signal !== null
+            ? { status: 'unmeasured', capturedBytes: ghEvidence.stdoutBytes, complete: false,
+              reason: isEnobufs ? 'spawnSync ENOBUFS truncates child output before the complete REST response length is known'
+                : ghEvidence.signal ? `child process was terminated by ${ghEvidence.signal}`
+                  : ghEvidence.status === null ? 'child exit status is unavailable, so response completeness is unknown'
+                    : 'the child process ended with an error before response completeness could be established' }
+            : { status: 'measured', bytes: ghEvidence.stdoutBytes, complete: true };
+        debug.log('draft.residue', 'list-open-drafts-unobserved', {
+          repository, reason: redactSecretText(reason), requestedPage: page <= 100 ? page : null,
+          paginationLimitExceeded: page > 100, request: ghEvidence?.args ?? null,
+          exitStatus: ghEvidence?.status ?? null, signal: ghEvidence?.signal ?? null,
+          errorCode: ghEvidence?.errorCode ?? null,
+          stderr: ghEvidence?.stderr ?? null, capturedStderrBytes: ghEvidence?.capturedStderrBytes ?? null,
+          responseBytes,
+          executionSha: runSha ? { status: 'measured', value: runSha } : {
+            status: 'unmeasured', reason: 'ELANOUS_EXECUTION_SHA is absent or invalid for this process invocation',
+          },
+        });
         return undefined;
       }
     },

package/src/self-dev/graph-front-nodes.ts

@@ -220,7 +220,8 @@ export function observeFrontNodeExit(exit: FrontNodeExit, data: FrontNodeExitDat
     const graphRoute: JourneyRoute = { ...route, to: budget.to };
     const taken = data.taken ?? budget.to ?? exit.outcome;
     const reason = [budget.budgetReason, data.reason].filter((part): part is string => part !== undefined).join(' · ');
-    recordJourneyEdge(graphRoute, taken, reason.length > 0 ? reason : undefined);
+    recordJourneyEdge(graphRoute, taken, reason.length > 0 ? reason : undefined,
+      data.runId === undefined ? {} : { runId: data.runId });
     recorded = graphRoute;
     const payload = {
       graphId: 'self-implement',

package/src/self-dev/graph-journey-route.ts

@@ -4,6 +4,8 @@ import { applyGraphOverlays, defaultOverlaysDir, loadGraphOverlays, selectOverla
 import { L1_PROTECTED_ROUTE_NODES, type GraphTemplateSpec } from '../self-implement/graph-yaml.js';
 import { evaluateOverlayCondition } from '../self-implement/graph-overlay-condition.js';
 import { journeyJoinFields } from './graph-journey-nodes.js';
+import { defaultProfilesDir, loadGraphProfiles, selectGraphProfiles, type GraphProfileSpec } from '../self-implement/graph-profile-yaml.js';
+import { appendRunLedgerEntry, runLedgerDir } from '../self-implement/run-ledger.js';
 
 /** ⭐ HARNESS-FULL-GRAPH 2판 — 「다음 노드」를 코드가 아니라 «그래프»가 정한다.
  *
@@ -29,11 +31,14 @@ export interface JourneyRoute {
   readonly skippedNode?: string;
   readonly skipCondition?: string;
   readonly skippedNodes?: readonly { readonly node: string; readonly condition: string }[];
+  readonly profileIds?: readonly string[];
+  readonly profileRejections?: readonly string[];
 }
 
 /** ⛔ 캐시하지 않는다 — 여러 런을 처리하는 프로세스(데몬·대기열 tick)가 다음 발사에서 오버레이 변경을 봐야 한다.
  *  여정 판정은 발사당 몇 번뿐이라 디렉터리 한 번 읽기가 싸다. */
 let overlaysForTesting: readonly GraphOverlaySpec[] | undefined;
+let profilesForTesting: readonly GraphProfileSpec[] | undefined;
 function launchOverlays(): readonly GraphOverlaySpec[] {
   if (overlaysForTesting !== undefined) return overlaysForTesting;
   try { return loadGraphOverlays(defaultOverlaysDir()).overlays; }
@@ -45,21 +50,50 @@ export function setJourneyOverlaysForTesting(overlays: readonly GraphOverlaySpec
   overlaysForTesting = overlays;
 }
 
+/** Test seam for a stable profile set; undefined reads the profile directory beside the graph sources. */
+export function setJourneyProfilesForTesting(profiles: readonly GraphProfileSpec[] | undefined): void {
+  profilesForTesting = profiles;
+}
+
+function launchProfiles(): { readonly profiles: readonly GraphProfileSpec[]; readonly errors: readonly string[] } {
+  if (profilesForTesting !== undefined) return { profiles: profilesForTesting, errors: [] };
+  const loaded = loadGraphProfiles(defaultProfilesDir());
+  return { profiles: loaded.profiles, errors: loaded.errors.map((issue) => `${issue.path}: ${issue.message}`) };
+}
+
 /** 상태 값으로 고른 «이 런의 여정 선언» — 기준 YAML ⊕ 조건이 맞는 launch 오버레이. */
 export function journeySpec(
   state: Readonly<Record<string, unknown>>,
   base: GraphTemplateSpec | undefined = GRAPH_SPECS['self-implement'],
   overlays: readonly GraphOverlaySpec[] = launchOverlays(),
-): { readonly spec: GraphTemplateSpec | undefined; readonly applied: readonly string[] } {
-  if (base === undefined) return { spec: undefined, applied: [] };
+  profiles: readonly GraphProfileSpec[] = launchProfiles().profiles,
+  profileLoadErrors: readonly string[] = [],
+): { readonly spec: GraphTemplateSpec | undefined; readonly applied: readonly string[]; readonly profileIds: readonly string[]; readonly profileRejections: readonly string[] } {
+  if (base === undefined) return { spec: undefined, applied: [], profileIds: [], profileRejections: [] };
   try {
-    const { applied } = selectOverlays(overlays, { graphId: base.graphId, stage: 'launch', state });
-    if (applied.length === 0) return { spec: base, applied: [] };
+    const selection = selectGraphProfiles(profiles, state);
+    const profileIds = selection.applied.map((profile) => profile.profileId);
+    const profileOverlayIds = new Set(selection.applied.flatMap((profile) => profile.overlays));
+    const overlayRejections = [...profileOverlayIds].flatMap((id) => {
+      const overlay = overlays.find((candidate) => candidate.overlayId === id);
+      if (!overlay) return [`profile overlay not found: ${id}`];
+      if (overlay.target !== base.graphId) return [`profile overlay target mismatch: ${id} (${overlay.target})`];
+      if (overlay.stage !== 'launch') return [`profile overlay wrong stage: ${id} (${overlay.stage})`];
+      return [];
+    });
+    const profileRejections = [...profileLoadErrors, ...selection.errors, ...overlayRejections];
+    if (profileRejections.length > 0) return { spec: base, applied: [], profileIds: [], profileRejections };
+    const { applied: candidates } = selectOverlays(overlays, { graphId: base.graphId, stage: 'launch', state: selection.state });
+    const ownedState = Object.assign({}, ...selection.applied.map((profile) => profile.state));
+    const applied = candidates.filter((overlay) => !profileOverlayIds.has(overlay.overlayId)
+      || evaluateOverlayCondition(overlay.appliesWhen, ownedState).kind === 'applies');
+    if (applied.length === 0) return { spec: base, applied: [], profileIds, profileRejections: [] };
     const result = applyGraphOverlays(base, applied);
     // ⛔ 거절된 오버레이는 길을 바꾸지 않는다 — 기준 선언으로 간다.
-    return result.ok ? { spec: result.template, applied: result.overlayIds } : { spec: base, applied: [] };
+    return result.ok ? { spec: result.template, applied: result.overlayIds, profileIds, profileRejections: [] }
+      : { spec: base, applied: [], profileIds: [], profileRejections: result.rejections.map((item) => `${item.kind}: ${item.overlayId}`) };
   } catch {
-    return { spec: base, applied: [] };
+    return { spec: base, applied: [], profileIds: [], profileRejections: ['profile selection failed'] };
   }
 }
 
@@ -69,10 +103,11 @@ export function readJourneyEdge(
   from: string,
   label: string,
   state: Readonly<Record<string, unknown>> = {},
-  deps: { readonly base?: GraphTemplateSpec; readonly overlays?: readonly GraphOverlaySpec[] } = {},
+  deps: { readonly base?: GraphTemplateSpec; readonly overlays?: readonly GraphOverlaySpec[]; readonly profiles?: readonly GraphProfileSpec[] } = {},
 ): JourneyRoute {
-  const { spec, applied } = journeySpec(state, deps.base ?? GRAPH_SPECS['self-implement'], deps.overlays ?? launchOverlays());
-  let route: JourneyRoute = { from, on: null, label, to: null, source: 'code-default', overlays: applied };
+  const profileSet = deps.profiles === undefined ? launchProfiles() : { profiles: deps.profiles, errors: [] as readonly string[] };
+  const { spec, applied, profileIds, profileRejections } = journeySpec(state, deps.base ?? GRAPH_SPECS['self-implement'], deps.overlays ?? launchOverlays(), profileSet.profiles, profileSet.errors);
+  let route: JourneyRoute = { from, on: null, label, to: null, source: 'code-default', overlays: applied, profileIds, profileRejections };
   const outgoing = (spec?.edges ?? []).filter(edge => edge.from === from);
   const protectedFrom = L1_PROTECTED_ROUTE_NODES.has(from) || spec?.nodes.some(node => node.nodeId === from && node.kind === 'gate') ||
     spec?.terminalNodes.includes(from);
@@ -80,14 +115,14 @@ export function readJourneyEdge(
   const matching = conditions.filter(({ verdict }) => verdict.kind === 'applies').map(({ edge }) => edge);
   const unobservedConditions = conditions.filter(({ verdict }) => verdict.kind === 'key-absent').map(({ edge }) => edge.when!);
   if (matching.length === 1 && unobservedConditions.length === 0 && matching[0]!.to !== undefined) {
-    route = { from, on: null, label, to: matching[0]!.to!, source: 'graph', overlays: applied,
+    route = { ...route, from, on: null, label, to: matching[0]!.to!, source: 'graph', overlays: applied,
       via: 'when', condition: matching[0]!.when };
   } else {
     const mapped = outgoing.find(edge => edge.when === undefined && edge.map !== undefined && Object.hasOwn(edge.map, label));
     const defaultEdge = mapped ?? outgoing.find(edge => edge.when === undefined && edge.to !== undefined);
-    if (defaultEdge?.map !== undefined) route = { from, on: defaultEdge.on ?? null, label,
+    if (defaultEdge?.map !== undefined) route = { ...route, from, on: defaultEdge.on ?? null, label,
       to: defaultEdge.map[label]!, source: 'graph', overlays: applied, via: 'outcome' };
-    else if (defaultEdge?.to !== undefined) route = { from, on: null, label,
+    else if (defaultEdge?.to !== undefined) route = { ...route, from, on: null, label,
       to: defaultEdge.to, source: 'graph', overlays: applied, via: 'outcome' };
     if (matching.length > 1) route = { ...route, ambiguousConditions: matching.map(edge => edge.when!) };
     if (unobservedConditions.length > 0) route = { ...route, unobservedConditions };
@@ -129,31 +164,51 @@ export interface JourneyEdgeFields {
   readonly [key: string]: unknown;
 }
 
+function recordGraphPathEvent(event: string, data: Record<string, unknown>, runId?: string): void {
+  try { debug.log('graph.path', event, data); } catch { /* fail-soft */ }
+  if (!runId) return;
+  try { appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId, event: 'graph.path', data: { event, ...data } }, runLedgerDir()); }
+  catch { /* path observation must not change execution */ }
+}
+
 /** 실제로 탄 간선을 남긴다 — `taken` 은 실제 다음 노드(그래프 답과 다르면 `honored: false` · 그 이유를 `reason` 에). */
 export function recordJourneyEdge(route: JourneyRoute, taken: string, reason?: string, data: JourneyEdgeFields = {}): void {
   try {
+    const runId = typeof data.runId === 'string' ? data.runId : undefined;
+    for (const rejection of route.profileRejections ?? []) recordGraphPathEvent('profile-rejected', {
+      graphId: 'self-implement', reason: rejection, profileIds: route.profileIds ?? [],
+      ...(runId === undefined ? {} : { runId }), ...journeyJoinFields(),
+    }, runId);
     if (route.ambiguousConditions?.length) debug.log('self-implement', 'edge-ambiguous', {
       graphId: 'self-implement', from: route.from, conditions: route.ambiguousConditions,
       fallback: taken, ...journeyJoinFields(),
     });
+    if (route.ambiguousConditions?.length) recordGraphPathEvent('edge-ambiguous', {
+      graphId: 'self-implement', from: route.from, conditions: route.ambiguousConditions,
+      fallback: taken, profileIds: route.profileIds ?? [], ...(runId === undefined ? {} : { runId }), ...journeyJoinFields(),
+    }, runId);
     if (route.unobservedConditions?.length) debug.log('self-implement', 'edge-unobserved', {
       graphId: 'self-implement', from: route.from, conditions: route.unobservedConditions,
       fallback: taken, ...journeyJoinFields(),
     });
-    if (route.to === taken) for (const skipped of route.skippedNodes ?? []) debug.log('self-implement', 'node-skipped', {
-      graphId: 'self-implement', node: skipped.node, reason: 'condition', condition: skipped.condition,
-      ...journeyJoinFields(),
-    });
+    if (route.to === taken) for (const skipped of route.skippedNodes ?? []) {
+      const skippedData = { graphId: 'self-implement', node: skipped.node, reason: 'condition', condition: skipped.condition,
+        profileIds: route.profileIds ?? [], ...(runId === undefined ? {} : { runId }), ...journeyJoinFields() };
+      debug.log('self-implement', 'node-skipped', skippedData);
+      recordGraphPathEvent('node-skipped', skippedData, runId);
+    }
     // Evidence never overrides an edge field: the later spread wins. Explicit repair join keys win over ambient context.
     const { reason: _reservedReason, journeyKey: _reservedJourney, queueLaunchId: _reservedLaunch,
-      runId, card, pr, head, moveId, ...evidence } = data ?? {};
-    debug.log('self-implement', 'graph-edge-taken', {
+      runId: _reservedRunId, card, pr, head, moveId, ...evidence } = data ?? {};
+    const edgeData = {
       ...evidence, graphId: 'self-implement', ...route, taken, honored: route.to === null || route.to === taken,
       ...(reason === undefined ? {} : { reason }), ...journeyJoinFields(),
       ...(runId === undefined ? {} : { runId }), ...(card === undefined ? {} : { card }),
       ...(pr === undefined ? {} : { pr }), ...(head === undefined ? {} : { head }),
       ...(moveId === undefined ? {} : { moveId }),
-    });
+    };
+    debug.log('self-implement', 'graph-edge-taken', edgeData);
+    recordGraphPathEvent('edge-taken', edgeData, runId);
   } catch { /* 관측은 fail-soft */ }
 }
 
@@ -162,10 +217,10 @@ export function routeJourneyEdge(
   from: string,
   label: string,
   state: Readonly<Record<string, unknown>> = {},
-  deps: { readonly base?: GraphTemplateSpec; readonly overlays?: readonly GraphOverlaySpec[] } = {},
+  deps: { readonly base?: GraphTemplateSpec; readonly overlays?: readonly GraphOverlaySpec[]; readonly profiles?: readonly GraphProfileSpec[]; readonly runId?: string } = {},
 ): JourneyRoute {
   const route = readJourneyEdge(from, label, state, deps);
-  recordJourneyEdge(route, route.to ?? label);
+  recordJourneyEdge(route, route.to ?? label, undefined, deps.runId === undefined ? {} : { runId: deps.runId });
   return route;
 }
 

package/src/self-dev/launch-preflight-text.ts

@@ -1,3 +1,5 @@
+import { parseTargetPathHintLine } from '../release-loop/checklist-target-path-hint.js';
+
 export type WorktreePathTouchAxis = 'touched' | 'untouched' | 'unreadable';
 
 /** 겹친 경로가 실제로 손대어졌는지의 읽기 전용 관측. */
@@ -534,15 +536,12 @@ export interface AskTargetPathHintsParseResult {
 }
 
 export function parseAskTargetPathHintsResult(askText: string): AskTargetPathHintsParseResult {
-  // ⛔ 첫 «비어 있지 않은» 줄만 본다 — 본문 전체를 훑으면 산문 속 경로까지 끌려와 오탐이 된다.
-  const firstLine = askText.split(/\r?\n/).find((line) => line.trim() !== '');
-  if (firstLine === undefined) return { paths: [], rejected: [], labelMissing: true };
-  const match = /^\s*(?:대상\s*경로|target\s*paths?)\s*[:：]\s*(.*)$/i.exec(firstLine);
-  if (!match) return { paths: [], rejected: [], labelMissing: true };
+  const parsed = parseTargetPathHintLine(askText);
+  if (parsed.labelMissing) return { paths: [], rejected: [], labelMissing: true };
 
   const paths: string[] = [];
   const rejected: AskTargetPathHintRejection[] = [];
-  for (const fragment of match[1]!.split(/[·,]/)) {
+  for (const fragment of parsed.fragments) {
     const piece = fragment.trim().replace(/^`+|`+$/g, '');
     if (piece === '') rejected.push({ fragment, reason: 'empty' });
     // ⛔ 「경로처럼 생긴 것」만 남긴다 — 확장자나 디렉터리 구분자가 있어야 한다.

package/src/self-dev/launch-preflight.ts

@@ -340,6 +340,64 @@ export interface LaunchPreflightInput {
 /** AUTO-TARGET: blocker name for a NOT-GROUNDED goal whose only target paths were machine-suggested (a scope card). */
 export const NOT_GROUNDED_SCOPE_CARD_BLOCKER = '(NOT-GROUNDED 범위 카드)';
 
+/** CARD-TARGET-PATHS 가 읽기 전용으로 제공하는 같은-경로 카드 맥락. */
+export interface SiblingContextCard {
+  readonly cardId: string;
+  readonly runId?: string;
+  readonly overlapPaths: readonly string[];
+}
+
+function siblingContextPaths(result: LaunchPreflightResult, warning: LaunchPreflightBlocker): readonly string[] {
+  return warning.overlapPaths?.map(({ path }) => path)
+    ?? result.paths.filter((path) => warning.detail.includes(path));
+}
+
+function siblingContextAxis(
+  label: string,
+  status: PreflightAxisStatus,
+  entries: readonly string[],
+): string {
+  if (status.state === 'unknown') return `[sibling-context] ${label}: 못 쟀다 (${status.reason})`;
+  if (entries.length === 0) return `[sibling-context] ${label}: 없음`;
+  const partial = status.state === 'truncated' ? ` · 부분 측정(상한 ${status.limit})` : '';
+  return `[sibling-context] ${label}: ${entries.join(' · ')}${partial}`;
+}
+
+/** 같은 대상 경로의 비차단 형제 관측을 골 문서 머리에 넣을 정확히 세 줄로 렌더한다. */
+export function renderSiblingContextLines(
+  result: LaunchPreflightResult,
+  cards: readonly SiblingContextCard[] = [],
+): readonly [string, string, string] {
+  const liveRuns = result.warnings
+    .filter((warning) => warning.kind === 'live-run')
+    .map((warning) => {
+      const paths = siblingContextPaths(result, warning);
+      const cardIds = cards
+        .filter((card) => card.runId === warning.name && card.overlapPaths.some((path) => paths.includes(path)))
+        .map((card) => card.cardId);
+      return [warning.name, ...cardIds.map((cardId) => `카드 ${cardId}`), ...paths].join(' · ');
+    });
+  const openPrs = result.warnings
+    .filter((warning) => warning.kind === 'open-pr' || warning.kind === 'sibling-pr')
+    .map((warning) => {
+      const draft = /\bdraft\b|초안/u.test(warning.detail) ? ' (draft)' : '';
+      const paths = siblingContextPaths(result, warning);
+      return `${warning.name}${draft}${paths.length > 0 ? ` · ${paths.join(', ')}` : ''}`;
+    });
+  const recentLanded = result.warnings
+    .filter((warning) => warning.kind === 'recent-change' && result.paths.includes(warning.name))
+    .map((warning) => {
+      const count = /최근 \d+일 안에 (\d+)건 변경됨/u.exec(warning.detail)?.[1];
+      return `sha·PR 미상 · ${warning.name}${count === undefined ? '' : ` ${count}건`}`;
+    });
+
+  return [
+    siblingContextAxis('같은 경로 도는 런', result.liveRuns, liveRuns),
+    siblingContextAxis('같은 경로 열린 PR', result.openPrs, openPrs),
+    siblingContextAxis(`같은 경로 최근 ${result.recentChangeWindowDays}일 착지`, result.recentChanges, recentLanded),
+  ];
+}
+
 export function evaluateLaunchPreflight(input: LaunchPreflightInput): LaunchPreflightResult {
   const paths = [...new Set(input.paths.filter((path) => path.trim().length > 0))];
   const blockers: LaunchPreflightBlocker[] = [];