elanous 0.2.42 → 0.2.44

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/draft-sweep.ts

@@ -1,6 +1,6 @@
 import { CLAIM_IDLE_HOURS, PR_LABELS, STALLED_DRAFT_HOURS } from '../github/pr-labels.js';
 import { debug } from '../debug/log.js';
-import { assessDraftTriage, decideDraft, draftClaimComment, draftClaimState, draftReleaseComment, laterMergedTwins, sameGoalPr, PROTECTED_LABELS, type DraftTriageAssessment, type DraftTriagePr, type DraftTriageReviewState } from './draft-triage-rules.js';
+import { assessDraftTriage, decideDraft, draftClaimComment, draftClaimState, draftIntentHoldReason, draftIntentHoldRejection, draftReleaseComment, harvestDeferredMarker, laterMergedTwins, parseDraftIntentHold, sameGoalPr, PROTECTED_LABELS, type DraftTriageAssessment, type DraftTriagePr, type DraftTriageReviewState } from './draft-triage-rules.js';
 import { cellIdFromBody } from '../pr-tool/census.js';
 import { RELEASE_PATH_LABEL } from './release-path-guard.js';
 import { cardPrNumber, draftTaskOwner, type TaskCard } from '../task-agent/task-hand.js';
@@ -659,12 +659,14 @@ export function resolveDraftSweepCloseCap(input: { flag?: unknown; config?: unkn
 export async function supersedeDraftsOnMerge(input: {
   repository: string;
   merged: SweepMergedPr & { createdAt: string; mergedAt: string };
+  now?: Date;
   /** `pr land` and HQ train invoke only the explicit same-cell successor path. */
   onlyExplicitSameCell?: boolean;
   adapters: Pick<DraftSweepAdapters, 'listDrafts' | 'listLiveBranches' | 'getRunStatus' | 'setLabels' | 'closeDraft'>
     & Pick<Partial<DraftSweepAdapters>, 'getLatestFileChanges' | 'getPrFiles' | 'commentDraft' | 'listIssueComments'>;
 }): Promise<{ closed: number[]; kept: number[] }> {
   const { repository, merged, adapters } = input;
+  const now = input.now ?? new Date();
   const closed: number[] = [];
   const kept: number[] = [];
   let drafts: SweepDraft[] = [];
@@ -691,6 +693,7 @@ export async function supersedeDraftsOnMerge(input: {
       const old = drafts.find((draft) => draft.number === explicitOld);
       if (old && cellIdFromBody(old.body ?? '') === mergedCell
         && Date.parse(old.createdAt) < Date.parse(merged.mergedAt)
+        && !parseDraftIntentHold(old.body, now)
         && !old.labels.some((label) => PROTECTED_LABELS.has(label))
         && PR_LABELS.filter((label) => label.axis === 'state' && old.labels.includes(label.name)).length <= 1) {
         const marker = `<!-- elanous:same-cell-superseded #${old.number} -> #${merged.number} -->`;
@@ -745,7 +748,7 @@ export async function supersedeDraftsOnMerge(input: {
         kept.push(draft.number);
         continue;
       }
-      const decision = decideDraft({ draft, runStatus: statuses.get(draft.number),
+      const decision = decideDraft({ draft, now, runStatus: statuses.get(draft.number),
         mergedTwins: [landed], liveBranches, ageHours: NaN });
       if (decision.action !== 'close' || !decision.reason.startsWith(`superseded-by #${merged.number}`)
         || PR_LABELS.filter((entry) => entry.axis === 'state' && draft.labels.includes(entry.name)).length > 1
@@ -1345,6 +1348,16 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       ...(claimWriteFailed ? { error: claimWriteError, ...(claimPartialApplied ? { partialApplied: true } : {}) } : {}) });
       continue;
     }
+    // DRAFT-ZERO's failed-run harvest evidence remains the strongest explicit hold; this intent marker
+    // must not rewrite its reason or mask the harvest classification.
+    if (runStatus === 'failed' && harvestDeferredMarker(draft.body)) {
+      record({ number: draft.number, action: 'keep', reason: 'harvest-deferred', applied: false });
+      continue;
+    }
+    const intentHoldRejection = draftIntentHoldRejection(draft.body, now);
+    if (intentHoldRejection) {
+      try { debug.log('self-dev.draft-sweep', 'intent-hold-rejected', { pr: draft.number, reason: intentHoldRejection }); } catch { /* fail-soft */ }
+    }
     if (draft.labels.includes(releaseHoldLabel ?? '') || draft.labels.includes(RELEASE_PATH_LABEL)
       || (!contradiction && draft.labels.includes(keepLabel ?? ''))) {
       const held = draft.labels.includes(keepLabel ?? '') ? keepLabel
@@ -1352,6 +1365,19 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       record({ number: draft.number, action: 'keep', reason: `label:${held}`, applied: false });
       continue;
     }
+    // Outside-harness drafts keep their established jurisdiction reason, even when they carry a valid marker.
+    if (!contradiction && !states.length && !draft.branch.startsWith('self-impl/')) {
+      record({ number: draft.number, action: 'keep', reason: 'outside-harness', applied: false });
+      continue;
+    }
+    const intentHold = parseDraftIntentHold(draft.body, now);
+    if (intentHold) {
+      const reason = draftIntentHoldReason(intentHold);
+      record({ number: draft.number, action: 'keep', reason, applied: false });
+      try { debug.log('self-dev.draft-sweep', 'intent-hold-kept', { pr: draft.number, owner: intentHold.owner,
+        reason: intentHold.reason, expiresAt: intentHold.expiresAt }); } catch { /* fail-soft */ }
+      continue;
+    }
     const claimState = contradiction ? 'unclaimed' : draftClaimState(draft, now);
     const isClaimed = claimState !== 'unclaimed';
     const ageHours = (now.getTime() - Date.parse(draft.createdAt)) / 3_600_000;
@@ -1368,7 +1394,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     const cellNewer = contradiction || lineageNewer ? undefined : newerSameCellDraft(draft, drafts);
     const duplicateNewer = lineageNewer ?? cellNewer;
     if (duplicateNewer) {
-      const base = decideDraft({ draft, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
+      const base = decideDraft({ draft, now, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
         finalRunResult, ageHours: runStatus ? ageHours : idleHours });
       if (!base.reason.startsWith('label:') && !base.reason.startsWith('superseded-by #') && !base.reason.startsWith('duplicate-of-open #')) {
         const runLive = isLiveDraftRun(runStatus, draft.branch, liveBranches);
@@ -1457,7 +1483,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     }
     // An unobserved claim may still have a merged twin: liveness/holds retain their priority,
     // but a superseded draft must not be hidden by the six-hour claim window.
-    const mergedDecision = isClaimed ? decideDraft({ draft, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
+    const mergedDecision = isClaimed ? decideDraft({ draft, now, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
       finalRunResult, ageHours: idleHours }) : undefined;
     const supersededClaim = mergedDecision?.reason.startsWith('superseded-by #') === true
       || mergedDecision?.reason.startsWith('duplicate-of-open #') === true;
@@ -1509,12 +1535,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       }
       continue;
     }
-    // Unlabelled non-harness drafts are outside the sweeper's jurisdiction.
-    if (!contradiction && !states.length && !draft.branch.startsWith('self-impl/')) {
-      record({ number: draft.number, action: 'keep', reason: 'outside-harness', applied: false });
-      continue;
-    }
-    let decision = supersededClaim ? mergedDecision! : decideDraft({ draft, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
+    let decision = supersededClaim ? mergedDecision! : decideDraft({ draft, now, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
       finalRunResult, ageHours: runStatus ? ageHours : idleHours });
     const fallback = decision.reason === 'unobserved' || decision.reason === 'stale-unobserved'
       || decision.reason === 'recent' || decision.reason.startsWith('recent (') || decision.reason.startsWith('stale-ended-run');

package/src/self-dev/draft-triage-rules.ts

@@ -23,12 +23,64 @@ export function draftClaimRecordLive(at: string, now: Date): boolean {
   return Number.isFinite(updated) && (now.getTime() - updated) / 3_600_000 < CLAIM_IDLE_HOURS;
 }
 
+export interface DraftIntentHold {
+  readonly owner: string;
+  readonly reason: string;
+  readonly expiresAt: string;
+}
+
+function inspectDraftIntentHold(body: string | undefined, now = new Date()): { hold?: DraftIntentHold; rejection?: string } {
+  if (!body || !body.includes('<!-- elanous:draft-intent-hold')) return {};
+  if (!Number.isFinite(now.getTime())) return { rejection: 'invalid-sweep-time' };
+  const matches = [...body.matchAll(/<!-- elanous:draft-intent-hold ([\s\S]*?) -->/g)];
+  const markerStarts = body.match(/<!-- elanous:draft-intent-hold\b/g) ?? [];
+  if (matches.length !== 1 || markerStarts.length !== 1) return { rejection: 'marker-count-or-termination' };
+  const raw = matches[0]![1]!;
+  let value: unknown;
+  try { value = JSON.parse(raw); } catch { return { rejection: 'invalid-json' }; }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return { rejection: 'invalid-shape' };
+  const row = value as Record<string, unknown>;
+  if (Object.keys(row).length !== 3 || !Object.hasOwn(row, 'owner') || !Object.hasOwn(row, 'reason') || !Object.hasOwn(row, 'expiresAt')) {
+    return { rejection: 'invalid-fields' };
+  }
+  const { owner, reason, expiresAt } = row;
+  if (typeof owner !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(owner)
+    || typeof reason !== 'string' || !reason.trim() || reason !== reason.trim() || reason.length > 240
+    || /[\r\n;=]/.test(reason) || reason.includes('-->')
+    || typeof expiresAt !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(expiresAt)) {
+    return { rejection: 'invalid-fields' };
+  }
+  // Compare against the one writer-defined field order. JSON.stringify(parsedObject) alone preserves
+  // incoming key order and would silently accept alternate serializations or duplicate keys.
+  if (JSON.stringify({ owner, reason, expiresAt }) !== raw) return { rejection: 'noncanonical-json' };
+  const expiry = Date.parse(expiresAt);
+  if (!Number.isFinite(expiry) || new Date(expiry).toISOString() !== expiresAt) return { rejection: 'invalid-expiry' };
+  if (expiry <= now.getTime()) return { rejection: 'expired' };
+  return { hold: { owner, reason: reason.trim(), expiresAt } };
+}
+
+/** Only one canonical, complete, unexpired body marker is a hold; malformed or ambiguous markers fail open to normal triage. */
+export function parseDraftIntentHold(body: string | undefined, now = new Date()): DraftIntentHold | undefined {
+  return inspectDraftIntentHold(body, now).hold;
+}
+
+/** Diagnostic for a present but rejected hold marker; absence is not an error. */
+export function draftIntentHoldRejection(body: string | undefined, now = new Date()): string | undefined {
+  return inspectDraftIntentHold(body, now).rejection;
+}
+
+export function draftIntentHoldReason(hold: DraftIntentHold): string {
+  return `intent-hold owner=${hold.owner}; reason=${hold.reason}; expiresAt=${hold.expiresAt}`;
+}
+
 export interface DraftTriagePr {
   number: number;
   title?: string;
   branch: string;
   labels?: readonly string[];
   body?: string;
+  /** Last PR update (push, label, comment); absence is not an expiry timestamp. */
+  updatedAt?: string;
   mergeCommitMessage?: string;
   landingVerifiedComments?: readonly string[];
   createdAt?: string;
@@ -109,7 +161,8 @@ export function assessDraftTriage(input: DraftTriageAssessmentInput): DraftTriag
   const clock = now.getTime();
   const ageHours = Number.isFinite(latestCommit) && Number.isFinite(clock) ? (clock - latestCommit) / 3_600_000 : NaN;
   const protectedLabel = (draft.labels ?? []).find((name) => CLOSE_PROTECTED_LABELS.has(name));
-  const protectedState = Boolean(protectedLabel);
+  const intentHold = parseDraftIntentHold(draft.body, now);
+  const protectedState = Boolean(protectedLabel || intentHold);
   const running = input.runStatus === 'running' || input.runStatus === 'probable-running'
     || (draft.labels ?? []).includes('elanous:running');
   const cellComplete = input.cellStatus === 'green' || input.cellStatus === 'done';
@@ -146,7 +199,8 @@ export function assessDraftTriage(input: DraftTriageAssessmentInput): DraftTriag
       : { state: 'unknown', evidence: '현재 adapter는 같은 칸 병합 PR과 이 초안의 대체 관계를 증명하지 않음; follow-up 필요' },
     'newer-same-card': { state: input.newerSameCellSameCard === undefined ? 'unknown' : input.newerSameCellSameCard ? 'yes' : 'no', evidence: `${input.newerSameCellSameCard === undefined ? '같은 칸·카드 새 draft 관계 미관측' : `same-cell-same-card-newer=${input.newerSameCellSameCard}`}; 관측 표지이며 대체 증거가 아님` },
     'idle-48h': { state: Number.isFinite(ageHours) ? (idle48h ? 'yes' : 'no') : 'unknown', evidence: Number.isFinite(ageHours) ? `head age=${ageHours.toFixed(1)}h` : 'head commit 시각 미관측' },
-    protected: { state: protectedState ? 'yes' : 'no', evidence: protectedLabel ? `보호 표지=${protectedLabel}` : '보호 표지 없음' },
+    protected: { state: protectedState ? 'yes' : 'no', evidence: protectedLabel ? `보호 표지=${protectedLabel}`
+      : intentHold ? draftIntentHoldReason(intentHold) : '보호 표지 없음' },
     'recent-commit': { state: Number.isFinite(latestCommit) ? (recentCommit ? 'yes' : 'no') : 'unknown', evidence: Number.isFinite(latestCommit) ? `last commit=${draft.latestCommitAt}; cutoff=09:30 KST` : 'head commit 시각 미관측' },
     running: { state: running ? 'yes' : runNotRunning ? 'no' : 'unknown', evidence: running ? `run=${input.runStatus ?? 'elanous:running'}` : runNotRunning ? `종결 run=${input.runStatus}` : `run 상태 미관측${input.runStatus ? ` (${input.runStatus})` : ''}` },
     'owner-confirmed': { state: input.ownerConfirmed === undefined ? 'unknown' : input.ownerConfirmed ? 'yes' : 'no', evidence: input.ownerConfirmed === undefined ? '소유자 출처 미관측' : input.ownerConfirmed ? '고유 카드 또는 활성 claim owner 확인' : '고유 소유자 없음' },
@@ -161,6 +215,7 @@ export function assessDraftTriage(input: DraftTriageAssessmentInput): DraftTriag
 
 export interface DraftTriageInput {
   draft: DraftTriagePr;
+  now?: Date;
   runStatus: string | undefined;
   mergedTwins: readonly DraftTriagePr[];
   openDrafts?: readonly DraftTriagePr[];
@@ -251,10 +306,12 @@ export function harvestDeferredMarker(body: string | undefined): boolean {
     && rows.length > 0 && rows.every((value) => value === HARVEST_DEFERRED_MARKER_VALUE);
 }
 
-export function decideDraft({ draft, runStatus, mergedTwins, openDrafts, ageHours, liveBranches, finalRunResult }: DraftTriageInput): DraftDecision {
+export function decideDraft({ draft, runStatus, mergedTwins, openDrafts, ageHours, liveBranches, finalRunResult, now = new Date() }: DraftTriageInput): DraftDecision {
   // DRAFT-ZERO — a verified harvest-deferred marker is the strongest hold: it outranks protected labels
   // and every close rule, so a failed run's harvestable draft survives the sweep for harvest.
   if (runStatus === 'failed' && harvestDeferredMarker(draft.body)) return { action: 'keep', reason: 'harvest-deferred' };
+  const intentHold = parseDraftIntentHold(draft.body, now);
+  if (intentHold) return { action: 'keep', reason: draftIntentHoldReason(intentHold) };
   const held = draft.labels?.find((label) => PROTECTED_LABELS.has(label));
   if (held) return { action: 'keep', reason: `label:${held}` };
   if (runStatus !== 'self-implement.result final' && draft.branch && liveBranches.has(draft.branch)

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.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[] = [];

package/src/self-dev/orchestrate.ts

@@ -1185,7 +1185,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
     const taskId = [...spaceIdByTask.entries()].find(([, id]) => id === input.spaceId)?.[0];
     const goal = taskId ? taskByGoal.get(taskId) : undefined;
     if (cancelling) throw new Error('orchestration cancelled by signal');
-    const started = baseSpawn({ ...input, feature: dependencyOutputFeature(input.spaceId, input.feature) });
+    const started = baseSpawn({ ...input, ...(taskId ? { taskId } : {}), feature: dependencyOutputFeature(input.spaceId, input.feature) });
     if (goal && taskId) {
       try { opts.onTaskLaunched?.(goal, taskId, priorByResumeKey.get(resumeKey(goal.feature))?.taskId); }
       catch { /* observation must not interrupt execution */ }