elanous 0.2.11 → 0.2.12

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

@@ -27,6 +27,10 @@ export interface DraftSweepAdapters {
   closeDraft(repository: string, number: number, comment: string): Promise<void>;
   /** Resolve the latest claim comment owner; a failed lookup must not authorize a close. */
   getClaimOwner?(repository: string, number: number): Promise<string | undefined>;
+  /** Whether the current owned run has a self-implement.result final observation, even if its worktree remains. */
+  hasFinalRunResult?(draft: SweepDraft, repository: string): Promise<boolean | undefined>;
+  /** Per-file last change on the draft branch; undefined means file coverage is unverified. */
+  getLatestFileChanges?(draft: SweepDraft, repository: string): Promise<Readonly<Record<string, string>> | undefined>;
 }
 
 export interface DraftSweepOptions {
@@ -120,9 +124,23 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     return finish();
   }
   let statuses: Map<number, string | undefined>;
+  let finality: Map<number, boolean | undefined>;
+  let latestFileChanges: Map<number, Readonly<Record<string, string>> | undefined>;
   try {
     statuses = new Map<number, string | undefined>();
-    for (const draft of drafts) statuses.set(draft.number, await adapters.getRunStatus(draft, repository));
+    finality = new Map<number, boolean | undefined>();
+    latestFileChanges = new Map<number, Readonly<Record<string, string>> | undefined>();
+    for (const draft of drafts) {
+      const status = await adapters.getRunStatus(draft, repository);
+      // A prior final cannot terminate a new active run on the same draft.
+      const active = status === 'running' || status === 'probable-running';
+      const final = active ? false : await adapters.hasFinalRunResult?.(draft, repository);
+      finality.set(draft.number, final);
+      statuses.set(draft.number, final ? 'self-implement.result final' : status);
+      if (draft.changedFiles?.length && adapters.getLatestFileChanges) {
+        latestFileChanges.set(draft.number, await adapters.getLatestFileChanges(draft, repository));
+      }
+    }
   } catch (error) {
     result.error = String(error);
     return finish();
@@ -132,8 +150,10 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
   let unobserved = 0;
   let claimed = 0;
   let claimExpired = 0;
-  for (const draft of drafts) {
+  for (const listedDraft of drafts) {
+    const draft = { ...listedDraft, latestFileChanges: latestFileChanges.get(listedDraft.number) };
     const runStatus = statuses.get(draft.number);
+    const finalRunResult = finality.get(draft.number);
     const states = stateLabels.filter((state) => draft.labels.includes(state.name));
     const contradiction = states.length > 1 || draft.labels.includes(approvalLabel ?? '');
     if (draft.labels.includes(releaseHoldLabel ?? '') || (!contradiction && draft.labels.includes(keepLabel ?? ''))) {
@@ -147,8 +167,14 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       ? (now.getTime() - Date.parse(draft.updatedAt)) / 3_600_000 : NaN;
     // 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, liveBranches, ageHours: idleHours }) : undefined;
-    const supersededClaim = mergedDecision?.reason.startsWith('superseded-by #') === true;
+    const mergedDecision = isClaimed ? decideDraft({ draft, 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;
+    if (!contradiction && mergedDecision?.reason === 'branch-finality-unobserved') {
+      record({ number: draft.number, action: 'keep', reason: mergedDecision.reason, applied: false });
+      continue;
+    }
     // Without an observed update time, neither expiration nor a fallback to creation time can authorize mutation —
     // but a merged twin does not need the update time, so superseded keeps its priority over the unobserved claim.
     if (isClaimed && !supersededClaim && (typeof draft.updatedAt !== 'string' || !Number.isFinite(Date.parse(draft.updatedAt)))) {
@@ -162,13 +188,21 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     }
     if (isClaimed && !supersededClaim && Number.isFinite(idleHours) && idleHours >= CLAIM_IDLE_HOURS) {
       claimExpired += 1;
-      if (runStatus === 'running' || runStatus === 'probable-running' || liveBranches.has(draft.branch)) {
+      if (liveBranches.has(draft.branch) && finalRunResult === undefined
+        && runStatus !== 'running' && runStatus !== 'probable-running') {
+        record({ number: draft.number, action: 'keep', reason: 'branch-finality-unobserved', applied: false });
+        continue;
+      }
+      if (runStatus === 'running' || runStatus === 'probable-running' ||
+        (runStatus !== 'self-implement.result final' && liveBranches.has(draft.branch))) {
         record({ number: draft.number, action: 'keep', reason: 'claim-expired-but-live', applied: false });
         continue;
       }
       const action = closes >= DRAFT_SWEEP_CLOSE_CAP ? 'keep' : 'close';
       if (action === 'close') closes += 1;
-      const entry: DraftSweepEntry = { number: draft.number, action, reason: action === 'close' ? 'claim-expired' : 'close-cap',
+      const entry: DraftSweepEntry = { number: draft.number, action,
+        reason: action === 'close' ? runStatus === 'self-implement.result final'
+          ? 'claim-expired (self-implement.result final; worktree is not live)' : 'claim-expired' : 'close-cap',
         ...(action === 'close' ? { statusLabel: stalledLabel } : {}), applied: false };
       record(entry);
       if (!apply || action !== 'close') continue;
@@ -178,7 +212,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
         await adapters.setLabels(repository, draft.number, { add: stalledLabel, remove: [runningLabel] });
         labelsChanged = true;
         await adapters.closeDraft(repository, draft.number,
-          `Draft sweep: 처리 중 표식이 ${CLAIM_IDLE_HOURS}시간 갱신 없음 — 런·워크트리 없음 · 주인 ${owner}. Closed as stalled. Branch preserved; reopen to restore.`);
+          `Draft sweep: 처리 중 표식이 ${CLAIM_IDLE_HOURS}시간 갱신 없음 — ${runStatus === 'self-implement.result final' ? 'self-implement.result final · 남은 워크트리는 live 아님' : '런·워크트리 없음'} · 주인 ${owner}. Closed as stalled. Branch preserved; reopen to restore.`);
         entry.applied = true;
       } catch (error) {
         if (labelsChanged) entry.partialApplied = true;
@@ -191,8 +225,8 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       record({ number: draft.number, action: 'keep', reason: 'outside-harness', applied: false });
       continue;
     }
-    let decision = supersededClaim ? mergedDecision! : decideDraft({ draft, runStatus, mergedTwins: merged, liveBranches,
-      ageHours: runStatus ? ageHours : idleHours });
+    let decision = supersededClaim ? mergedDecision! : decideDraft({ draft, runStatus, mergedTwins: merged, openDrafts: drafts, liveBranches,
+      finalRunResult, ageHours: runStatus ? ageHours : idleHours });
     if (!runStatus && (decision.reason === 'unobserved' || decision.reason === 'stale-unobserved')) unobserved += 1;
     if (!contradiction && decision.action === 'close') {
       if (closes >= DRAFT_SWEEP_CLOSE_CAP) decision = { action: 'keep', reason: 'close-cap' };
@@ -204,7 +238,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       : decision.reason;
     const isLive = decision.reason === 'live';
     const target = action === 'report' ? undefined : action === 'close'
-      ? decision.reason.startsWith('superseded-by #') ? supersededLabel : stalledLabel
+      ? decision.reason.startsWith('superseded-by #') || decision.reason.startsWith('duplicate-of-open #') ? supersededLabel : stalledLabel
       : isLive ? (states.length ? runningLabel : undefined) : runStatus && (states[0]?.name === runningLabel || states.length === 0) ? stalledLabel : undefined;
     const entry: DraftSweepEntry = { number: draft.number, action, reason, ...(target ? { statusLabel: target } : {}), applied: false };
     record(entry);

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

@@ -6,14 +6,25 @@ export interface DraftTriagePr {
   title?: string;
   branch: string;
   labels?: readonly string[];
+  body?: string;
+  mergeCommitMessage?: string;
+  landingVerifiedComments?: readonly string[];
+  createdAt?: string;
+  mergedAt?: string;
+  changedFiles?: readonly string[];
+  /** Latest change to each draft file, from the draft branch's commit history. Missing is not creation time. */
+  latestFileChanges?: Readonly<Record<string, string>>;
 }
 
 export interface DraftTriageInput {
   draft: DraftTriagePr;
   runStatus: string | undefined;
   mergedTwins: readonly DraftTriagePr[];
+  openDrafts?: readonly DraftTriagePr[];
   ageHours: number;
   liveBranches: ReadonlySet<string>;
+  /** false only when the current run's final result has actually been checked and ruled out. */
+  finalRunResult?: boolean;
 }
 
 export type DraftDecision = { action: 'close' | 'keep'; reason: string };
@@ -25,11 +36,22 @@ const PROTECTED_LABELS: ReadonlySet<string> = new Set<string>([...PR_LABELS
   .map((label) => label.name), RELEASE_PATH_LABEL]);
 
 const goalId = (branch: string): string | undefined => /(?:^|[-/])goalid-([a-f0-9]+)(?=-|\/|$)/i.exec(branch)?.[1]?.toLowerCase();
+export const branchStem = (branch: string): string | undefined => /^self-impl\/(.+)-[a-f0-9]{8}-r[a-f0-9]+$/i.exec(branch)?.[1];
+const slot = (body?: string): string | undefined => /^칸:\s*(.+?)\s*$/m.exec(body ?? '')?.[1];
+const referencesDraft = (text: string, number: number): boolean =>
+  new RegExp(`(?:\\(수확\\s*#${number}\\s*\\)|\\bsuperseded\\s*#${number}(?!\\d))`, 'i').test(text);
+const landingCommentReferencesDraft = (text: string, number: number): boolean =>
+  new RegExp(`\\blanding-verified\\s*:\\s*(?:draft|superseded|수확)\\s*#${number}(?!\\d)\\b`, 'i').test(text);
 
-export function decideDraft({ draft, runStatus, mergedTwins, ageHours, liveBranches }: DraftTriageInput): DraftDecision {
+export function decideDraft({ draft, runStatus, mergedTwins, openDrafts, ageHours, liveBranches, finalRunResult }: DraftTriageInput): DraftDecision {
   const held = draft.labels?.find((label) => PROTECTED_LABELS.has(label));
   if (held) return { action: 'keep', reason: `label:${held}` };
-  if (runStatus === 'running' || runStatus === 'probable-running' || (draft.branch && liveBranches.has(draft.branch))) {
+  if (runStatus !== 'self-implement.result final' && draft.branch && liveBranches.has(draft.branch)
+    && finalRunResult === undefined && runStatus !== 'running' && runStatus !== 'probable-running') {
+    return { action: 'keep', reason: 'branch-finality-unobserved' };
+  }
+  if (runStatus === 'running' || runStatus === 'probable-running' ||
+    (runStatus !== 'self-implement.result final' && draft.branch && liveBranches.has(draft.branch))) {
     return { action: 'keep', reason: 'live' };
   }
   const lineage = goalId(draft.branch);
@@ -37,9 +59,39 @@ export function decideDraft({ draft, runStatus, mergedTwins, ageHours, liveBranc
     (draft.title && pr.title === draft.title) || (lineage && goalId(pr.branch) === lineage)
   ));
   if (twin) return { action: 'close', reason: `superseded-by #${twin.number}` };
+  const stem = branchStem(draft.branch);
+  const createdAt = Date.parse(draft.createdAt ?? '');
+  const newer = stem && draft.title && Number.isFinite(createdAt) ? openDrafts
+    ?.filter((pr) => pr.number !== draft.number && pr.title === draft.title && branchStem(pr.branch) === stem
+      && Number.isFinite(Date.parse(pr.createdAt ?? '')) && Date.parse(pr.createdAt!) > createdAt)
+    .sort((a, b) => Date.parse(b.createdAt!) - Date.parse(a.createdAt!) || b.number - a.number)[0] : undefined;
+  if (newer) return { action: 'close', reason: `duplicate-of-open #${newer.number}` };
+  const harvest = mergedTwins.find((pr) => pr.number !== draft.number && (
+    [pr.mergeCommitMessage, pr.body].some((text) => text && referencesDraft(text, draft.number))
+    || pr.landingVerifiedComments?.some((text) => landingCommentReferencesDraft(text, draft.number))
+  ));
+  if (harvest) return { action: 'close', reason: `superseded-by #${harvest.number} (harvest #${draft.number})` };
+  const created = Date.parse(draft.createdAt ?? '');
+  const files = draft.changedFiles;
+  const draftSlot = slot(draft.body);
+  const later = mergedTwins.filter((pr) => pr.number !== draft.number && Number.isFinite(created)
+    && Number.isFinite(Date.parse(pr.mergedAt ?? '')) && Date.parse(pr.mergedAt!) > created
+    && ((lineage && goalId(pr.branch) === lineage) || (draftSlot && slot(pr.body) === draftSlot)));
+  if (files?.length && files.every((file) => {
+    const changed = Date.parse(draft.latestFileChanges?.[file] ?? '');
+    return Number.isFinite(changed) && changed >= created && later.some((pr) =>
+      pr.changedFiles?.includes(file) && Date.parse(pr.mergedAt!) > changed);
+  })) {
+    const covering = later.filter((pr) => pr.changedFiles?.some((file) => files.includes(file)
+      && Date.parse(pr.mergedAt!) > Date.parse(draft.latestFileChanges![file]!)));
+    return { action: 'close', reason: `superseded-by #${covering.map((pr) => pr.number).join(', #')} (all-files-landed)` };
+  }
   if (!runStatus) return Number.isFinite(ageHours) && ageHours >= STALLED_DRAFT_HOURS
     ? { action: 'close', reason: 'stale-unobserved' }
     : { action: 'keep', reason: 'unobserved' };
+  if (runStatus === 'self-implement.result final') return Number.isFinite(ageHours) && ageHours >= STALLED_DRAFT_HOURS
+    ? { action: 'close', reason: 'stale-ended-run (self-implement.result final; worktree is not live)' }
+    : { action: 'keep', reason: 'recent (self-implement.result final; worktree is not live)' };
   if (Number.isFinite(ageHours) && ageHours >= STALLED_DRAFT_HOURS) return { action: 'close', reason: 'stale-ended-run' };
   return { action: 'keep', reason: 'recent' };
 }

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

@@ -101,21 +101,27 @@ function codexCandidateUsable(candidate: BudgetCodexCandidate, cap: number | und
 function slotUsable(
   provider: string,
   input: DecideBudgetInput,
-): { usable: boolean; reason: string } {
+  allowUnmeasured = false,
+): { usable: boolean; reason: string; unmeasured?: boolean } {
   if (provider === CODEX_PROVIDER) {
     const cap = capFor(input.maxUsedPercent, CODEX_PROVIDER);
-    const usable = input.codexCandidates.some((candidate) => codexCandidateUsable(candidate, cap));
-    return { usable, reason: formatCodexReason(input.codexCandidates, cap) };
+    const measuredUsable = input.codexCandidates.some((candidate) => codexCandidateUsable(candidate, cap));
+    const unmeasured = allowUnmeasured && !measuredUsable && (input.codexCandidates.length === 0
+      || input.codexCandidates.some((candidate) => candidate.reached !== true
+        && (typeof candidate.usedPercent !== 'number' || !Number.isFinite(candidate.usedPercent))));
+    return { usable: measuredUsable || unmeasured, reason: formatCodexReason(input.codexCandidates, cap), ...(unmeasured ? { unmeasured: true } : {}) };
   }
   if (provider === GROK_PROVIDER) {
     const cap = capFor(input.maxUsedPercent, GROK_PROVIDER);
     const known = typeof input.grokUsedPercent === 'number' && Number.isFinite(input.grokUsedPercent);
-    const usable = cap === undefined
+    const unmeasured = allowUnmeasured && !known;
+    const usable = unmeasured || (cap === undefined
       ? known
-      : known && (input.grokUsedPercent as number) < cap;
+      : known && (input.grokUsedPercent as number) < cap);
     return {
       usable,
       reason: formatGrokReason(input.grokUsedPercent, cap),
+      ...(unmeasured ? { unmeasured: true } : {}),
     };
   }
   return { usable: false, reason: `${provider}: 예산 판정 없음` };
@@ -127,6 +133,15 @@ function slotUsable(
  * 아무것도 못 쓰면 onShortfall 이 wait-reset 일 때만 wait-reset, 아니면 stop.
  */
 export function decideBudget(input: DecideBudgetInput): BudgetDecision {
+  return decideBudgetWithPolicy(input, false).decision;
+}
+
+/** Only the harness launch gate treats an unmeasured provider as launchable. */
+export function decideLaunchBudget(input: DecideBudgetInput): { decision: BudgetDecision; unmeasuredProvider?: string } {
+  return decideBudgetWithPolicy(input, true);
+}
+
+function decideBudgetWithPolicy(input: DecideBudgetInput, allowUnmeasured: boolean): { decision: BudgetDecision; unmeasuredProvider?: string } {
   const reasons: string[] = [];
   if (input.preference.chain.length === 0) {
     reasons.push('chain: 비었음 — tools.selfImplement.childLlm.chain 도 llm.fallbackChain 도 없다');
@@ -134,7 +149,7 @@ export function decideBudget(input: DecideBudgetInput): BudgetDecision {
   let firstUnusable = false;
   for (let index = 0; index < input.preference.chain.length; index++) {
     const slot = input.preference.chain[index]!;
-    const judged = slotUsable(slot.provider, input);
+    const judged = slotUsable(slot.provider, input, allowUnmeasured);
     reasons.push(judged.reason);
     if (!judged.usable) {
       if (index === 0) firstUnusable = true;
@@ -142,16 +157,18 @@ export function decideBudget(input: DecideBudgetInput): BudgetDecision {
     }
     const action: BudgetAction = index === 0 || !firstUnusable ? 'proceed' : 'next-provider';
     return {
-      action,
-      provider: slot.provider,
-      ...(slot.model !== undefined ? { model: slot.model } : {}),
-      reasons,
+      decision: {
+        action,
+        provider: slot.provider,
+        ...(slot.model !== undefined ? { model: slot.model } : {}),
+        reasons,
+      },
+      ...(judged.unmeasured ? { unmeasuredProvider: slot.provider } : {}),
     };
   }
   const onShortfall = input.preference.budgetGate.onShortfall;
   return {
-    action: onShortfall === 'wait-reset' ? 'wait-reset' : 'stop',
-    reasons,
+    decision: { action: onShortfall === 'wait-reset' ? 'wait-reset' : 'stop', reasons },
   };
 }
 

package/src/self-implement/gate-candidate-ranking.ts

@@ -0,0 +1,60 @@
+import type { GateCallerReason } from './gate-scope.js';
+
+export interface GateCallerCandidate {
+  readonly file: string;
+  readonly reasons: readonly GateCallerReason[];
+}
+
+/** Path segments between `file` and the nearest changed path's directory (0 = same directory). */
+function directoryDistance(file: string, changedPaths: readonly string[]): number {
+  const dir = file.split('/').slice(0, -1);
+  let best = Infinity;
+  for (const changed of changedPaths) {
+    const other = changed.split('/').slice(0, -1);
+    let shared = 0;
+    while (shared < dir.length && shared < other.length && dir[shared] === other[shared]) shared += 1;
+    best = Math.min(best, dir.length - shared + other.length - shared);
+  }
+  return best;
+}
+
+/**
+ * Rank gate caller tests by closeness to the change, nearest first (GATE-CALLERS2 — the cap keeps the head).
+ * A `route` candidate names a route on a changed diff line, so it ranks with touched tests (distance 0);
+ * otherwise the distance is the shortest reverse-import path from a changed file (direct importer = 1,
+ * unreachable = after every reachable candidate). Equal distances prefer the test nearest a changed file
+ * in the directory tree, then numeric-aware path order. Inputs are not modified.
+ * `importersByFile` maps each imported file to its immediate importers (tests or sources).
+ */
+export function rankGateCallerCandidates<T extends GateCallerCandidate>(
+  changedPaths: readonly string[],
+  candidates: readonly T[],
+  importersByFile: ReadonlyMap<string, readonly string[]>,
+): T[] {
+  const distances = new Map<string, number>();
+  const queue: string[] = [];
+  for (const path of changedPaths) {
+    if (distances.has(path)) continue;
+    distances.set(path, 0);
+    queue.push(path);
+  }
+  for (let index = 0; index < queue.length; index += 1) {
+    const source = queue[index]!;
+    const nextDistance = distances.get(source)! + 1;
+    for (const importer of importersByFile.get(source) ?? []) {
+      if (distances.has(importer)) continue;
+      distances.set(importer, nextDistance);
+      queue.push(importer);
+    }
+  }
+  const keys = new Map(candidates.map((candidate) => [candidate, {
+    distance: candidate.reasons.includes('route') ? 0 : distances.get(candidate.file) ?? Infinity,
+    directory: directoryDistance(candidate.file, changedPaths),
+  }]));
+  return [...candidates].sort((left, right) => {
+    const a = keys.get(left)!;
+    const b = keys.get(right)!;
+    return (a.distance - b.distance || 0) || (a.directory - b.directory || 0)
+      || left.file.localeCompare(right.file, undefined, { numeric: true });
+  });
+}

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

@@ -30,6 +30,7 @@
 
 import { importerTestsNotInRunSet, type ImporterTestIndex } from './importer-test-index.js';
 import type { RouteConsumerTestIndex } from './route-consumer-test-index.js';
+import { rankGateCallerCandidates } from './gate-candidate-ranking.js';
 
 export const GATE_CALLER_TEST_LIMIT = 30;
 export type GateCallerReason = 'import' | 'route';
@@ -249,11 +250,7 @@ interface GateScopeDecision {
   readonly unverified: readonly string[];
   /** elanous 자체가 남긴 런타임 산출물. 미검증 사용자 변경에서 제외하되 경로를 보존한다. */
   readonly elanousRuntimeArtifacts: readonly string[];
-  /** ⭐ **편집되지 않았는데 함께 끌어와 돌린** 연관 테스트(`changed-tests` 분기 전용).
-   *  ⚠️ 직전 판본은 이 자리에 `unrunRelatedTests`(=실행집합에 없는 연관 테스트)를 뒀는데,
-   *  실행집합이 연관 테스트를 **전부 포함**하도록 바뀌었으므로 그 값은 **정의상 항상 빈 배열**이었다.
-   *  빈 배열을 보고 *"안 돈 게 없다"* 고 읽게 되지만 그건 사실 확인이 아니라 계산의 결과였다
-   *  (관측이 사실 아닌 값을 나르는 형태). ⇒ **실제로 일어난 일**을 센다: 합집합이 구제한 파일들. */
+  /** ⭐ 편집되지 않았는데 함께 끌어와 돌린 연관 테스트(`changed-tests` 분기) — 합집합이 실제로 구제한 파일들. */
   readonly pulledInRelatedTests: readonly string[];
   /** 실행 집합에 없는, 변경 소스를 상대 import 하는 테스트. 색인이 주입되지 않으면 null. */
   readonly importerTestsNotRun: {
@@ -352,8 +349,9 @@ export function resolveGateScope(
       }
     }
   }
-  const candidates = [...callers].sort(([a], [b]) => a.localeCompare(b, undefined, { numeric: true }))
-    .map(([file, reasons]) => ({ file, reasons: [...reasons] }));
+  // GATE-CALLERS2 — the cap keeps the candidates closest to the change, not the alphabetically first.
+  const candidates = rankGateCallerCandidates(userChanged, [...callers].map(([file, reasons]) => ({ file, reasons: [...reasons] })),
+    importerTestIndex?.testsBySource ?? new Map());
   const callerTests = candidates.slice(0, GATE_CALLER_TEST_LIMIT);
   const callerTestsOverflow = candidates.slice(GATE_CALLER_TEST_LIMIT);
   const runWithCallers = (tests: readonly string[]) => [...new Set([...tests, ...callerTests.map(({ file }) => file)])];
@@ -364,11 +362,14 @@ export function resolveGateScope(
   });
 
   if (testFiles.length > 0) {
+    // Edited tests ⊕ every related test of the changed sources ⊕ capped callers (restored 10-04: #23467 narrowed this
+    // to edited tests only, so a co-located sibling of a changed source stopped running — 0.2.12 gate introduced).
     const allRelatedTests = conventional;
     const runSet = runWithCallers([...testFiles, ...allRelatedTests]);
     // 편집된 테스트만 돌렸다면 빠졌을 것들 — 이 목록이 비어있지 않다는 것은 합집합이 실제로 구제했다는 뜻이다.
     const pulledInRelatedTests = allRelatedTests.filter((f) => !testFiles.includes(f));
-    return { ...base, ...withDocumentNonContribution(runSet), testArgs: runSet, unverified: unverifiedFor(runSet), pulledInRelatedTests, importerTestsNotRun: observationFor(runSet), skipTestStep: false, reason: 'changed-tests' };
+    return { ...base, ...withDocumentNonContribution(runSet), testArgs: runSet, unverified: unverifiedFor(runSet), pulledInRelatedTests,
+      importerTestsNotRun: observationFor(runSet), skipTestStep: false, reason: 'changed-tests' };
   }
   if (userChanged.length === 0) {
     // postsync 빈 범위는 기존 no-changes(깨끗함)와 다른 값이다. 일반 호출자는 계속 no-changes를 읽는다.

package/src/self-implement/headless-elanous-driver.ts

@@ -1170,11 +1170,16 @@ export interface HeadlessGoalLoopPtyResult {
 
 export function pickImplementRoleForGoal(document: string): ReturnType<typeof resolveRoleLlm> | undefined {
   try {
-    const role = resolveRoleLlm('implement');
+    const config = getUserConfig();
+    const role = resolveRoleLlm('implement', { config });
+    if (config.harness?.difficultyPlacement !== true || role.source !== 'default') return role;
     const signals = goalDifficultySignals(document);
     const level = classifyGoalDifficulty(signals);
     const picked = resolveImplementDifficulty(role, level);
-    try { debug.log('llm.difficulty', 'pick', { level, tier: picked.tier ?? null, signals }); } catch { /* observation is fail-soft */ }
+    try {
+      debug.log('llm.difficulty', 'pick', { level, tier: picked.tier ?? null, signals });
+      debug.log('harness.role-llm', 'difficulty-placement', { difficulty: level, tier: picked.tier, source: role.source });
+    } catch { /* observation is fail-soft */ }
     return picked;
   } catch { return undefined; }
 }

package/src/self-implement/orchestrator.ts

@@ -63,6 +63,7 @@ import { GoalRunStore, insertGoalRunRecord, type GoalPriorRuns } from './goal-ru
 import { writeGoalRunRecordFragment } from './goal-execution-records.js';
 import { getUserConfig } from '../user-config.js';
 import { appendRunLedgerEntry, loadRunLedger, parseRunShardIdentity, queryRunChain, type RunChainShardSibling, type RunLedgerEntry, type RunLedgerWriter, type RunOriginData, type RunShardIdentity } from './run-ledger.js';
+import { emitSessionEvent, type SessionEventInput } from '../context-bus/session-events.js';
 import { decideLineageSupersede, lineageSupersedeCloseComment, type LineageSupersedeOpenDraft } from './lineage-supersede.js';
 import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { enqueueControlMemo, readSoftStopRequestStatus, type SoftStopRequestRead } from '../harness/control-inbox.js';
@@ -874,6 +875,8 @@ export type ImplementTerminalStatus = {
 export interface SelfImplementSeams {
   /** Run-observer ledger sink. Tests inject an in-memory sink to avoid touching user state. */
   writeRunLedger?: RunLedgerWriter;
+  /** Optional context-journal sink for isolated runs. */
+  emitContextEvent?: (input: SessionEventInput) => void;
   /** Registers this run as an ephemeral loop-agent asset; failures are observed but never affect execution. */
   registerLoopAgent?: (input: LoopAgentInput) => void;
   /** Wraps implementation and gate promises with their effective wall-clock timeout; tests observe the actual stage budgets. */
@@ -3384,6 +3387,16 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
       detail: 'observe-only: SelfImplement execution skipped before child boot',
     };
   }
+  const emitContext = (kind: 'task-claimed' | 'task-done', text: string, pr?: number): void => {
+    try {
+      (opts.seams.emitContextEvent ?? emitSessionEvent)({ kind, seat: 'TC', text,
+        ref: `runId=${runId}${pr === undefined ? '' : ` PR=#${pr}`}` });
+    } catch (error) {
+      try { logRunAwareFailSoft(runId, 'context-event-failed', { kind, error: safeErrorDescription(error) }); }
+      catch { /* context publication never changes the run result */ }
+    }
+  };
+  emitContext('task-claimed', `Self-implement claimed: ${opts.feature.split(/\r?\n/, 1)[0]}`);
   const parentHarnessSpaceId = getHarnessSpace()?.id || undefined;
   const configRoot = getElanousConfigDir() || undefined;
   const stateRoot = elanousStateRoot() || undefined;
@@ -4091,6 +4104,8 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
         }, { level: 'warn' });
       } catch { /* fail-soft — 종결 기록 실패가 원래 예외를 덮으면 안 된다 */ }
     }
+    emitContext('task-done', `Self-implement ${terminalResult?.stage ?? 'crashed'}: ${opts.feature.split(/\r?\n/, 1)[0]}`,
+      terminalResult?.prNumber ?? capturedPrNumber);
     finalizeTraversal();
     try { unregisterProviderErrorSink(); } catch { /* fail-soft — cleanup must not change the terminal result */ }
   }

package/src/self-implement/test-seams.ts

@@ -21,6 +21,7 @@ export function seams(over: Partial<SelfImplementSeams> & { gateResults?: boolea
     //   ⭐ 실제 경로는 그것을 «의도한» 전용 테스트에서만 탄다(그 테스트가 심을 명시로 준다).
     refreshCodexQuotaSignals: async () => ({ accounts: [] }),
     writeRunLedger: () => {},
+    emitContextEvent: () => {},
     registerLoopAgent: () => {},
     createWorktree: async ({ branch, base }) => ({ path: `/wt/${branch}`, branch, base, resolvedBase: 'a'.repeat(40), invokedHead: 'a'.repeat(40) }),
     implement: async ({ feature }) => { features.push(feature); return { ok: true, summary: 'impl' }; },

package/src/task-orchestrator/surfaces/pod-command-job.ts

@@ -304,13 +304,15 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
 
   let member: PodPoolMember | null = null;
   let pool = options.poolScheduler;
-  if (!pool && options.pool) {
-    const spec = resolvePodPoolSpec(options.pool, env);
-    if (!spec) throw new Error('pod command: 풀 스펙이 비었다');
-    const members = parsePodPool(spec);
-    const checked = (options.checkPool ?? checkPodPool)(members, baseKubectl as PoolKubectl);
-    if (!checked.ok) throw new Error('pod command: 풀의 노드가 하나도 준비되지 않았다');
-    pool = new PodPoolScheduler(checked.ready);
+  if (!pool) {
+    const spec = resolvePodPoolSpec(options.pool, env, () => options.kubectl ? undefined : getUserConfig().pod?.pool);
+    if (options.pool && !spec) throw new Error('pod command: 풀 스펙이 비었다');
+    if (spec) {
+      const members = parsePodPool(spec);
+      const checked = (options.checkPool ?? checkPodPool)(members, baseKubectl as PoolKubectl);
+      if (!checked.ok) throw new Error('pod command: 풀의 노드가 하나도 준비되지 않았다');
+      pool = new PodPoolScheduler(checked.ready);
+    }
   }
   if (pool) {
     for (;;) {
@@ -357,6 +359,8 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       if (synced && !synced.ok) throw new Error(`pod command: 이미지 판을 못 맞췄다: ${synced.detail}`);
       if (synced?.imageRef) member = { ...member, imageRef: synced.imageRef };
     }
+    const imageRef = member?.imageRef;
+    if (!imageRef) log('pod.command-job', 'image-fallback-local', { reason: !member ? 'no-pool-member' : !imageCommit ? 'image-commit-unavailable' : 'registry-tag-unavailable' });
     const ghToken = options.clone ? (options.ghToken ?? defaultGhToken)() : undefined;
     const secret = commandJobSecret({ name, namespace, launch, skills, skillEnvText, ...(grokAuth !== undefined ? { grokAuth } : {}), ...(ghToken !== undefined ? { ghToken } : {}) });
     if (secret) {
@@ -364,8 +368,8 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       if (applied.status !== 0) throw new Error(applied.stderr.trim() || 'pod command: Secret 적용 실패');
     }
     const manifest = podCommandJobManifest({
-      name, namespace, launch, image: member?.imageRef ?? image,
-      ...(member?.imageRef ? { imagePullPolicy: 'IfNotPresent' as const } : {}),
+      name, namespace, launch, image: imageRef ?? image,
+      ...(imageRef ? { imagePullPolicy: 'IfNotPresent' as const } : {}),
       repoUrl, command, skills, ...(llm ? { llm } : {}), ...(options.clone ? { clone: true } : {}),
       ...(options.source ? { source: options.source } : {}), ...(hostMirror ? { hostMirror } : {}), ...(bunCache ? { bunCache } : {}), ...(memoryLimit ? { memoryLimit } : {}), deadlineSeconds,
       ...(options.runId ? { runId: options.runId } : {}),
@@ -398,7 +402,7 @@ export async function runPodCommand(options: RunPodCommandOptions): Promise<PodC
       llm: llm ?? null,
       command: command.join(' ').slice(0, COMMAND_LOG_CHARS),
     });
-    return { exitCode, artifactsDir, job: name, image: member?.imageRef ?? image };
+    return { exitCode, artifactsDir, job: name, image: imageRef ?? image };
   } catch (err) {
     cleanupSecret();
     throw err;

package/src/task-orchestrator/surfaces/self-implement-pod.ts

@@ -436,6 +436,12 @@ export function goalTouchesPwa(feature: string): boolean {
   return PWA_PATH.test(feature);
 }
 
+/** A launch-time warning, not a memory-tier override or a test-command parser. */
+export function broadPodTestWarning(goal: string): string | null {
+  const broad = /(?:전체\s*(?:시험|테스트)|(?:full|whole|entire|all)\s+(?:test|suite)|(?:전체|모든)\s*(?:test|suite)|\bbun\s+test\s+(?:[\w./-]+\/|[\w./-]+(?<!\.[cm]?[jt]sx?))(?:\s|$)|\bbun\s+test\s*(?:$|[;&|]))/imu.test(goal);
+  return broad ? '[pod] 넓은 시험 골 경고: 10-04 W10b 32Gi OOM — 넓은 bun test 한 프로세스가 16GB+ 사용; 바꾼 시험 파일만 지정해 실행하세요.' : null;
+}
+
 export function parsePodMemoryTier(v: string | undefined): PodMemoryTier | null {
   const t = v?.trim().toLowerCase();
   return t && (POD_MEMORY_TIERS as readonly string[]).includes(t) ? (t as PodMemoryTier) : null;
@@ -660,6 +666,8 @@ export function podSelfImplementSpawn(options: PodSpawnOptions = {}): SelfImplem
         debug.log('self-implement.pod', 'memory-directive-ignored', { spaceId: input.spaceId, where, reason }, { level: 'warn' });
       }
     }
+    const broadTestWarning = broadPodTestWarning(`${input.feature}\n${parentGoal ?? ''}`);
+    if (broadTestWarning) console.warn(broadTestWarning);
     let memoryLimit = selectedMemoryLimit;
     const after = input.after ?? podPredecessorFor(input.feature, env, parentGoal);
     if (after !== undefined) debug.log('self-implement.pod', 'predecessor', { spaceId: input.spaceId, after, source: input.after !== undefined ? 'input' : 'goal-or-option' });

package/src/telegram-commands.ts

@@ -46,6 +46,9 @@ import { classifyIntake } from './ad-pipeline/intake.js';
 import { createAdPipelineDeps, runAdPipeline } from './ad-pipeline/run.js';
 import { projectCommand } from './telegram-project-command.js';
 import { telegramNowSlash } from './context-bus/context-now-surfaces.js';
+import { createWishCard } from './intake-plane/wish-card.js';
+import { telegramDecisionOwner } from './decisions/telegram-decision-cards.js';
+import { CardStore } from './task-cards/card-store.js';
 import type { ContextNowDeps } from './context-bus/context-now.js';
 
 /** How many prior user/assistant turns to pass into `executeSkill` as
@@ -155,6 +158,7 @@ export interface TgCommandContext {
   userConfig: UserConfig;
   /** All registered commands — used by `/help` to enumerate. */
   allCommands: TgSlashCommand[];
+  sendButtons?: (text: string, buttons: Array<Array<{ text: string; data: string }>>) => Promise<void>;
   /** When the caller posted a placeholder for a streaming command,
    *  the streamer edits it in-place as the handler accumulates
    *  output. Undefined for instant commands. Handlers must tolerate
@@ -590,6 +594,23 @@ export function defaultTelegramCommands(nowDeps?: ContextNowDeps): TgSlashComman
       },
     },
     projectCommand(),
+    {
+      name: 'wish',
+      description: '소원을 카드로 남기기',
+      handler: async (args, ctx, { userConfig }) => {
+        if (String(ctx.userId) !== telegramDecisionOwner(userConfig) || ctx.chatId !== ctx.userId || !ctx.isDm) {
+          return '대표만 쓸 수 있습니다';
+        }
+        if (args.length === 0) return '/wish <소원 한 줄>';
+        const store = new CardStore();
+        try {
+          const card = createWishCard({ text: args.join(' '), source: 'telegram', ref: `${ctx.chatId}:${ctx.messageId}` }, store);
+          return `소원 카드로 남겼습니다 — ${card.title} (카드 ${card.cardId.slice(0, 8)})`;
+        } finally {
+          store.close();
+        }
+      },
+    },
     {
       name: 'fork',
       description: 'Fork the current chat session (or /fork <prefix>) and continue HERE on the fork · time-travel: /fork before:N',