elanous 0.2.19 → 0.2.21

package/src/self-implement/run-ttl.ts

@@ -0,0 +1,258 @@
+/**
+ * RUN-TTL (0.2.21 P1 · first piece · FINDING #24712) — an open harness PR has a «time to landing».
+ *
+ * Open self-impl PRs linger for days while main moves (~80 merges/day), so an old draft rots silently.
+ * Past `tools.selfImplement.runTtlHours` (default 24) since its last commit, the sweep makes one pre-emptive move:
+ *   · live owning run → one resync memo in its control inbox (same path as SIBLING-RESYNC #24893/#24899),
+ *                       at most once per (PR, head sha) — a rebase moves the head and re-arms it
+ *   · no live run     → the registered `elanous:needs-rebase` label, once (QUIET-PR-COMMENTS: never a comment)
+ *
+ * Mode `tools.selfImplement.runTtl.mode`: `shadow` (default) only logs what it would do; `live` writes.
+ * Cost bound: a PR opened inside the TTL is still inside its own time-to-landing and is never fetched
+ * (`freshByCreation`), already-marked PRs without a live run are skipped before any fetch, at most `maxFetch` last-commit lookups per sweep with `concurrency` in flight, and at most `cap` actions.
+ *
+ * Pure core: every side effect is an injected adapter so tests never touch GitHub or the inbox.
+ */
+import { debug } from '../debug/log.js';
+import type { ControlMemoPayload } from '../harness/control-inbox.js';
+import { SIBLING_RESYNC_MARKER_LABEL, type SiblingRunTarget } from './sibling-resync.js';
+
+export const RUN_TTL_CATEGORY = 'self-implement.run-ttl';
+export const RUN_TTL_DEFAULT_HOURS = 24;
+export const RUN_TTL_DEFAULT_CAP = 30;
+export const RUN_TTL_DEFAULT_MAX_FETCH = 60;
+export const RUN_TTL_DEFAULT_CONCURRENCY = 6;
+export const RUN_TTL_MARKER_LABEL = SIBLING_RESYNC_MARKER_LABEL;
+const HARNESS_BRANCH_PREFIX = 'self-impl/';
+const KEEP_LABEL = 'elanous:keep';
+
+export type RunTtlMode = 'shadow' | 'live';
+
+export interface RunTtlCandidate {
+  readonly number: number;
+  readonly branch: string;
+  readonly labels: readonly string[];
+  readonly createdAt: string;
+  readonly headSha: string;
+}
+
+export interface RunTtlAdapters {
+  /** Open PRs against the default branch. A rejection is not an empty list. */
+  listOpenPrs(): Promise<readonly RunTtlCandidate[]>;
+  /** ISO time of the head commit; `undefined` (or a rejection) means unknown and the PR is left alone. */
+  lastCommitAt(pr: RunTtlCandidate): Promise<string | undefined>;
+  resolveRun(pr: RunTtlCandidate): Promise<SiblingRunTarget>;
+  sendMemo(target: { runId: string; spaceId: string }, memo: ControlMemoPayload): Promise<void> | void;
+  addLabel(prNumber: number, label: string): Promise<void> | void;
+  /** Memo dedupe by `<pr>:<headSha>`. Omitted ⇒ no dedupe. */
+  memoSent?(key: string): boolean;
+  recordMemoSent?(key: string): void;
+}
+
+export interface RunTtlResult {
+  readonly mode: RunTtlMode;
+  readonly ttlHours: number;
+  /** Open self-impl PRs considered (keep-labelled excluded). */
+  readonly considered: number;
+  readonly freshByCreation: number;
+  readonly fetched: number;
+  readonly fresh: number;
+  readonly unknown: readonly number[];
+  readonly stale: readonly number[];
+  /** Memo sent (live) or would be sent (shadow). */
+  readonly memo: readonly number[];
+  /** Label added (live) or would be added (shadow). */
+  readonly label: readonly number[];
+  readonly alreadyMarked: readonly number[];
+  readonly alreadyMemoed: readonly number[];
+  /** Owning run lookup failed — left alone (a failed lookup is not a dead run). */
+  readonly unresolved?: readonly number[];
+  readonly skippedOverCap: readonly number[];
+  readonly skippedFetchCap: readonly number[];
+  readonly failed: readonly number[];
+  readonly durationMs: number;
+  readonly reason?: string;
+}
+
+export function runTtlMemo(ageHours: number, ttlHours: number): ControlMemoPayload {
+  return {
+    version: 1,
+    kind: 'run-ttl-resync',
+    urgency: 'normal',
+    body: `[run-ttl] This PR's last commit is ${Math.floor(ageHours)}h old (time-to-landing ${ttlHours}h) while main keeps moving. `
+      + 'Before continuing: git fetch origin main, rebase this branch onto origin/main (resolve conflicts keeping both intents), then re-run the gate on your changed files.',
+  };
+}
+
+async function mapBounded<T, R>(items: readonly T[], limit: number, work: (item: T) => Promise<R>): Promise<R[]> {
+  const results = new Array<R>(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, async () => {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await work(items[index]!);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
+const nonNegativeInt = (value: number | undefined, fallback: number): number =>
+  value !== undefined && Number.isSafeInteger(value) && value >= 0 ? value : fallback;
+
+export async function runRunTtlSweep(input: {
+  adapters: RunTtlAdapters;
+  mode?: RunTtlMode;
+  ttlHours?: number;
+  cap?: number;
+  maxFetch?: number;
+  concurrency?: number;
+  now?: () => number;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}): Promise<RunTtlResult> {
+  const { adapters } = input;
+  const now = input.now ?? Date.now;
+  const startedAt = now();
+  const mode: RunTtlMode = input.mode === 'live' ? 'live' : 'shadow';
+  const ttlHours = typeof input.ttlHours === 'number' && Number.isFinite(input.ttlHours) && input.ttlHours > 0
+    ? input.ttlHours : RUN_TTL_DEFAULT_HOURS;
+  const cap = nonNegativeInt(input.cap, RUN_TTL_DEFAULT_CAP);
+  const maxFetch = nonNegativeInt(input.maxFetch, RUN_TTL_DEFAULT_MAX_FETCH);
+  const concurrency = Math.max(1, nonNegativeInt(input.concurrency, RUN_TTL_DEFAULT_CONCURRENCY));
+  const ttlMs = ttlHours * 3_600_000;
+  const log = input.log ?? ((category, event, data) => debug.log(category, event, data));
+  const emit = (event: string, data: Record<string, unknown>) => {
+    try { log(RUN_TTL_CATEGORY, event, { mode, ...data }); } catch { /* fail-soft */ }
+  };
+  let considered = 0;
+  let freshByCreation = 0;
+  let fetched = 0;
+  let fresh = 0;
+  const unknown: number[] = [];
+  const stale: number[] = [];
+  const memo: number[] = [];
+  const label: number[] = [];
+  const alreadyMarked: number[] = [];
+  const alreadyMemoed: number[] = [];
+  const unresolved: number[] = [];
+  const skippedOverCap: number[] = [];
+  const skippedFetchCap: number[] = [];
+  const failed: number[] = [];
+  const result = (reason?: string): RunTtlResult => ({
+    mode, ttlHours, considered, freshByCreation, fetched, fresh, unknown, stale, memo, label, alreadyMarked,
+    alreadyMemoed, unresolved, skippedOverCap, skippedFetchCap, failed, durationMs: Math.max(0, now() - startedAt),
+    ...(reason ? { reason } : {}),
+  });
+  const summary = (out: RunTtlResult): RunTtlResult => {
+    emit('summary', {
+      ttlHours, cap, maxFetch, concurrency, considered, freshByCreation, fetched, fresh,
+      unknown: unknown.length, stale: stale.length, memo: memo.length, label: label.length,
+      alreadyMarked: alreadyMarked.length, alreadyMemoed: alreadyMemoed.length, unresolved: unresolved.length,
+      skippedOverCap: skippedOverCap.length, skippedFetchCap: skippedFetchCap.length, failed: failed.length,
+      memoPrs: memo, labelPrs: label, durationMs: out.durationMs, ...(out.reason ? { reason: out.reason } : {}),
+    });
+    return out;
+  };
+
+  let open: readonly RunTtlCandidate[];
+  try {
+    open = await adapters.listOpenPrs();
+  } catch (error) {
+    emit('skipped', { reason: 'inventory-failed', error: String(error) });
+    return summary(result('inventory-failed'));
+  }
+  const nowMs = now();
+  const pending: { pr: RunTtlCandidate; target: SiblingRunTarget }[] = [];
+  for (const pr of open) {
+    if (!pr.branch.startsWith(HARNESS_BRANCH_PREFIX) || pr.labels.includes(KEEP_LABEL)) continue;
+    considered += 1;
+    const created = Date.parse(pr.createdAt);
+    // A PR opened inside the TTL is inside its own time-to-landing — no fetch needed.
+    if (Number.isFinite(created) && nowMs - created < ttlMs) { freshByCreation += 1; continue; }
+    let target: SiblingRunTarget;
+    try { target = await adapters.resolveRun(pr); } catch (error) {
+      // A failed lookup is not proof the run is gone — never label (or memo) an unresolved PR.
+      unresolved.push(pr.number);
+      emit('run-unresolved', { pr: pr.number, error: String(error) });
+      continue;
+    }
+    // Dead run + marker already present: the quiet signal is in place («once»), nothing to fetch.
+    if (!target.alive && pr.labels.includes(RUN_TTL_MARKER_LABEL)) { alreadyMarked.push(pr.number); continue; }
+    pending.push({ pr, target });
+  }
+  // Oldest PR first: the most likely to have rotted.
+  pending.sort((a, b) => (Date.parse(a.pr.createdAt) || 0) - (Date.parse(b.pr.createdAt) || 0) || a.pr.number - b.pr.number);
+  const toFetch = pending.slice(0, maxFetch);
+  skippedFetchCap.push(...pending.slice(maxFetch).map(({ pr }) => pr.number));
+  const dated = await mapBounded(toFetch, concurrency, async (entry) => {
+    let at: string | undefined;
+    try { at = await adapters.lastCommitAt(entry.pr); } catch { at = undefined; }
+    fetched += 1;
+    const ms = at ? Date.parse(at) : NaN;
+    return { ...entry, ageMs: Number.isFinite(ms) ? nowMs - ms : undefined };
+  });
+  const stalePrs: (typeof dated[number] & { ageMs: number })[] = [];
+  for (const entry of dated) {
+    if (entry.ageMs === undefined) { unknown.push(entry.pr.number); continue; }
+    if (entry.ageMs < ttlMs) { fresh += 1; continue; }
+    stale.push(entry.pr.number);
+    stalePrs.push({ ...entry, ageMs: entry.ageMs });
+  }
+  stalePrs.sort((a, b) => b.ageMs - a.ageMs || a.pr.number - b.pr.number);
+  let actions = 0;
+  for (const { pr, target, ageMs } of stalePrs) {
+    const ageHours = ageMs / 3_600_000;
+    const key = `${pr.number}:${pr.headSha}`;
+    if (target.alive) {
+      let already: boolean | undefined;
+      try { already = adapters.memoSent?.(key) ?? false; } catch (error) {
+        // Without the journal «once» cannot be proven — skip rather than risk a repeat memo.
+        failed.push(pr.number);
+        emit('memo-journal-failed', { pr: pr.number, stage: 'read', error: String(error) });
+        continue;
+      }
+      if (already) { alreadyMemoed.push(pr.number); continue; }
+    }
+    if (!target.alive && pr.labels.includes(RUN_TTL_MARKER_LABEL)) { alreadyMarked.push(pr.number); continue; }
+    if (actions >= cap) { skippedOverCap.push(pr.number); continue; }
+    actions += 1;
+    if (target.alive) {
+      if (mode === 'shadow') {
+        memo.push(pr.number);
+        emit('would-memo', { pr: pr.number, runId: target.runId, spaceId: target.spaceId, ageHours: Math.floor(ageHours) });
+        continue;
+      }
+      // Journal first: a memo that cannot be recorded is not sent, so «once per (PR, head sha)» holds.
+      try { adapters.recordMemoSent?.(key); } catch (error) {
+        failed.push(pr.number);
+        emit('memo-journal-failed', { pr: pr.number, stage: 'write', error: String(error) });
+        continue;
+      }
+      try {
+        await adapters.sendMemo({ runId: target.runId, spaceId: target.spaceId }, runTtlMemo(ageHours, ttlHours));
+        memo.push(pr.number);
+        emit('memo', { pr: pr.number, runId: target.runId, spaceId: target.spaceId, ageHours: Math.floor(ageHours) });
+        continue;
+      } catch (error) {
+        // A live run we could not reach still needs to be visible — fall through to the quiet marker.
+        emit('memo-failed', { pr: pr.number, runId: target.runId, error: String(error) });
+        if (pr.labels.includes(RUN_TTL_MARKER_LABEL)) { alreadyMarked.push(pr.number); continue; }
+      }
+    }
+    const reason = target.alive ? 'memo-failed' : target.reason;
+    if (mode === 'shadow') {
+      label.push(pr.number);
+      emit('would-label', { pr: pr.number, label: RUN_TTL_MARKER_LABEL, reason, ageHours: Math.floor(ageHours) });
+      continue;
+    }
+    try {
+      await adapters.addLabel(pr.number, RUN_TTL_MARKER_LABEL);
+      label.push(pr.number);
+      emit('label', { pr: pr.number, label: RUN_TTL_MARKER_LABEL, reason, ageHours: Math.floor(ageHours) });
+    } catch (error) {
+      failed.push(pr.number);
+      emit('label-failed', { pr: pr.number, error: String(error) });
+    }
+  }
+  return summary(result());
+}

package/src/self-implement/salvage-retention.ts

@@ -0,0 +1,123 @@
+/**
+ * SALVAGE-RETENTION (RFC-draft-pr-accumulation-root-fix R1 다음 조각) — 원격 `salvage/*` 가지의 보존 규칙.
+ *
+ * S: DRAFT-NOT-ARCHIVE 로 멈춘 런은 PR 대신 수확 가지를 남긴다. 가지는 이미 1,000개를 넘었다.
+ * C: 가지가 지워지지 않고 쌓이면 draft 재고가 «수확 가지 재고»로 옮겨 갈 뿐이다.
+ * Q: 어느 가지를 지워도 되나?
+ * A: 14일보다 오래됐고, 열린 PR 도(head·본문) 카드도(런 키·본문) 가리키지 않는 가지. 지금은 «그림자»로 수만 낸다.
+ *    `tools.selfImplement.salvageRetention.mode` = 'shadow'(기본) | 'live'. ⛔ 이 조각은 live 여도 지우지 않는다(다음 조각).
+ *
+ * 순수 판정 + 주입된 조회. ⛔ 나이를 못 읽은 가지는 «오래됨»으로 세지 않는다(`unknownAge`).
+ */
+import { execFileSync } from 'node:child_process';
+import { branchMatchesRun, runSuffixKey } from './salvage-branches.js';
+
+export type SalvageRetentionMode = 'shadow' | 'live';
+export const SALVAGE_RETENTION_MAX_AGE_DAYS = 14;
+
+export interface DatedSalvageRef {
+  readonly branch: string;
+  readonly committedAt: string | null;
+}
+
+export interface SalvageReferenceSources {
+  /** 열린 PR — head 가지 ⊕ 본문(본문에 가지 이름이 적혀 있으면 참조로 센다). */
+  readonly openPrs: ReadonlyArray<{ number: number; headRefName: string; body?: string | null }>;
+  /** 과제 카드 — 런 id(가지의 `-r<6hex>` 와 맞추기) ⊕ 카드 직렬화 본문. */
+  readonly cards: ReadonlyArray<{ id: string; runId?: string; text: string }>;
+}
+
+export interface SalvageRetentionReport {
+  readonly mode: SalvageRetentionMode;
+  readonly maxAgeDays: number;
+  readonly total: number;
+  readonly older: number;
+  readonly unknownAge: number;
+  readonly referenced: number;
+  /** 지울 후보 — 오래됐고 참조 0. 그림자에서는 수만 보고한다. */
+  readonly candidates: number;
+  readonly sample: readonly string[];
+  readonly deleted: 0;
+}
+
+/** 가지를 가리키는 것이 있나 — 열린 PR head/본문 · 카드 런 키/본문. */
+export function salvageBranchReferenced(branch: string, sources: SalvageReferenceSources): boolean {
+  if (sources.openPrs.some((pr) => pr.headRefName === branch || (pr.body ?? '').includes(branch))) return true;
+  return sources.cards.some((card) => {
+    if (card.text.includes(branch)) return true;
+    const key = card.runId ? runSuffixKey(card.runId) : null;
+    return key !== null && branchMatchesRun(branch, key);
+  });
+}
+
+export function classifySalvageRetention(input: {
+  refs: readonly DatedSalvageRef[];
+  sources: SalvageReferenceSources;
+  now: Date;
+  mode: SalvageRetentionMode;
+  maxAgeDays?: number;
+}): SalvageRetentionReport {
+  const maxAgeDays = input.maxAgeDays ?? SALVAGE_RETENTION_MAX_AGE_DAYS;
+  const cutoff = input.now.getTime() - maxAgeDays * 86_400_000;
+  let older = 0;
+  let unknownAge = 0;
+  let referenced = 0;
+  const candidates: string[] = [];
+  for (const ref of input.refs) {
+    const at = ref.committedAt ? Date.parse(ref.committedAt) : NaN;
+    if (!Number.isFinite(at)) { unknownAge += 1; continue; }
+    if (at >= cutoff) continue;
+    older += 1;
+    if (salvageBranchReferenced(ref.branch, input.sources)) { referenced += 1; continue; }
+    candidates.push(ref.branch);
+  }
+  return { mode: input.mode, maxAgeDays, total: input.refs.length, older, unknownAge, referenced, candidates: candidates.length, sample: candidates.slice(0, 5), deleted: 0 };
+}
+
+export function formatSalvageRetention(report: SalvageRetentionReport): string {
+  return `수확 가지 보존(${report.mode}): 전체 ${report.total} · ${report.maxAgeDays}일 초과 ${report.older} · 그중 참조 있음 ${report.referenced} · 지울 후보(참조 0) ${report.candidates}`
+    + `${report.unknownAge ? ` · 나이 모름 ${report.unknownAge}` : ''} · 지운 것 0${report.mode === 'live' ? '(live 삭제는 다음 조각)' : ''}`;
+}
+
+type GhExecute = (args: string[]) => string;
+const executeGh: GhExecute = (args) => execFileSync('gh', args, {
+  encoding: 'utf8', timeout: 60_000, maxBuffer: 64 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'], env: process.env,
+});
+
+const REFS_QUERY = `query($owner:String!,$name:String!,$after:String){repository(owner:$owner,name:$name){refs(refPrefix:"refs/heads/salvage/",first:100,after:$after){pageInfo{hasNextPage endCursor} nodes{name target{... on Commit{committedDate}}}}}}`;
+
+/** GitHub GraphQL 로 `salvage/*` 가지 ⊕ 마지막 커밋 시각(100개씩). ⛔ 페이지가 깨지면 던진다(부분 목록을 «전체»로 읽지 않는다). */
+export function listDatedSalvageRefs(repository: string, execute: GhExecute = executeGh): DatedSalvageRef[] {
+  const [owner, name] = repository.split('/');
+  if (!owner || !name) throw new Error(`repository must be owner/name: ${repository}`);
+  const refs: DatedSalvageRef[] = [];
+  let after: string | null = null;
+  for (let page = 0; page < 200; page++) {
+    const args = ['api', 'graphql', '-f', `query=${REFS_QUERY}`, '-F', `owner=${owner}`, '-F', `name=${name}`, ...(after ? ['-F', `after=${after}`] : [])];
+    const parsed = JSON.parse(execute(args)) as { data?: { repository?: { refs?: { pageInfo?: { hasNextPage?: boolean; endCursor?: string | null }; nodes?: Array<{ name?: unknown; target?: { committedDate?: unknown } | null }> } } } };
+    const block = parsed.data?.repository?.refs;
+    if (!block || !Array.isArray(block.nodes) || !block.pageInfo) throw new Error('incomplete salvage ref listing');
+    for (const node of block.nodes) {
+      if (typeof node.name !== 'string') throw new Error('incomplete salvage ref listing');
+      refs.push({ branch: `salvage/${node.name}`, committedAt: typeof node.target?.committedDate === 'string' ? node.target.committedDate : null });
+    }
+    if (!block.pageInfo.hasNextPage) return refs;
+    after = block.pageInfo.endCursor ?? null;
+    if (!after) throw new Error('incomplete salvage ref listing');
+  }
+  throw new Error('salvage ref listing exceeded pagination limit');
+}
+
+const OPEN_PR_LIMIT = 5000;
+
+/** 열린 PR(head ⊕ 본문). ⛔ 상한에 닿으면 «전부 읽었다»를 증명 못 하므로 던진다(참조 있는 가지를 후보로 세지 않는다). */
+export function listOpenPrRefs(repository: string, execute: GhExecute = executeGh): SalvageReferenceSources['openPrs'] {
+  const rows = JSON.parse(execute(['pr', 'list', '--repo', repository, '--state', 'open', '--limit', String(OPEN_PR_LIMIT), '--json', 'number,headRefName,body'])) as unknown;
+  if (!Array.isArray(rows)) throw new Error('incomplete open PR listing');
+  if (rows.length >= OPEN_PR_LIMIT) throw new Error(`incomplete open PR listing: reached the ${OPEN_PR_LIMIT} limit`);
+  return rows.map((row) => {
+    const pr = row as { number?: unknown; headRefName?: unknown; body?: unknown };
+    if (typeof pr.number !== 'number' || typeof pr.headRefName !== 'string') throw new Error('incomplete open PR listing');
+    return { number: pr.number, headRefName: pr.headRefName, body: typeof pr.body === 'string' ? pr.body : null };
+  });
+}

package/src/self-implement/seams.ts

@@ -972,6 +972,8 @@ export interface DefaultSeamsOptions {
   signal?: AbortSignal;
   /** Parent-surface progress receiver supplied by the dev pipeline. */
   onProgress?: SelfImplementSeams['onProgress'];
+  /** Relay the actual worktree soft-stop target to the invoking surface. */
+  onSoftStopSpaceReady?: SelfImplementSeams['onSoftStopSpaceReady'];
   /** ⑤ HITL — PR 승인 게이트. ★fail-closed: 생략 시 PR 안 열림(자동 승인 없음). 실전 필수. */
   approvePr?: SelfImplementSeams['approvePr'];
   /** gate 스텝(기본 ['test']). */
@@ -1394,6 +1396,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
   };
   return {
     ...(o.onProgress ? { onProgress: o.onProgress } : {}),
+    ...(o.onSoftStopSpaceReady ? { onSoftStopSpaceReady: o.onSoftStopSpaceReady } : {}),
     ...(escalateGoalClarifications ? { escalateGoalClarifications } : {}),
     queryChildProviderErrors,
     persistPrBodyArtifact: (input) => createArtifactStore().put('block', input.body, {
@@ -1423,6 +1426,10 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       const { supersedeMergedGoalDrafts } = await import('../harness/harness-cli-command.js');
       await supersedeMergedGoalDrafts(number, cwd);
     },
+    resyncSiblingsOnMerge: async (number, cwd) => {
+      const { resyncMergedSiblings } = await import('../harness/harness-cli-command.js');
+      await resyncMergedSiblings(number, cwd);
+    },
     followUp: {
       mode: readFollowUpMode(),
       stateRoot: elanousStateRoot(),

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

@@ -111,6 +111,8 @@ export function singleRunAsJobResult(feature: string, r: SelfImplementResultWith
     ...(r.harvestable === true && r.branch ? { harvestable: true } : {}),
     ...(r.worktreePath ? { worktreePath: r.worktreePath } : {}),
     ...(r.prUrl ? { prUrl: r.prUrl } : {}),
+    // TA-LIVE-REVIEW-POD — 작업 트리 없는 런(Pod)의 live review 가 «런이 낸 PR 머리»를 확인하는 근거.
+    ...(r.checkedHeadCommit !== undefined ? { checkedHeadCommit: r.checkedHeadCommit } : {}),
     ...(r.merged !== undefined ? { merged: r.merged } : {}),
     ...(r.mergeReason ? { mergeReason: r.mergeReason } : {}),
     ...(r.completionDisposition ? { completionDisposition: r.completionDisposition } : {}),

package/src/self-implement/self-implement-runtime.ts

@@ -55,6 +55,13 @@ interface SelfImplementRuntimeDeps {
 }
 let runtimeDeps: SelfImplementRuntimeDeps = {};
 
+// TUI-only observer. The tool call id is furnished by the actual dispatcher;
+// other surfaces and calls without an id cannot register a stop target.
+let softStopSpaceObserver: ((toolCallId: string, spaceId: string) => void) | null = null;
+export function setSelfImplementSoftStopSpaceObserver(observer: typeof softStopSpaceObserver): void {
+  softStopSpaceObserver = observer;
+}
+
 /** 자식 헤드리스 elanous 의 config/state 격리 + 구현 대기 상한을 주입. */
 export function setSelfImplementRuntimeDeps(d: SelfImplementRuntimeDeps | null): void {
   runtimeDeps = d ?? {};
@@ -711,6 +718,11 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
       ...(runtimeDeps.implementMaxWaitSec ? { implementMaxWaitSec: runtimeDeps.implementMaxWaitSec } : {}),
       ...(approvePr ? { approvePr } : {}),
       onProgress: resolveHarnessProgressSink(ctx),
+      ...(ctx.surface === 'tui' && ctx.toolCallId && softStopSpaceObserver ? {
+        onSoftStopSpaceReady: (spaceId: string) => {
+          try { softStopSpaceObserver?.(ctx.toolCallId!, spaceId); } catch { /* UI observer cannot break harness */ }
+        },
+      } : {}),
     });
 
     const runnableDocumentReferences = documentReferences.filter(({ result }) => result.kind !== 'outside-repository');

package/src/self-implement/sibling-resync.ts

@@ -0,0 +1,223 @@
+/**
+ * SIBLING-RESYNC-ON-MERGE (0.2.21 P0) — when one harness PR merges, the open sibling PRs that touch the
+ * same paths learn it «now», not when their gate fails or main-sync breaks.
+ *
+ * Measured 2026-10-07: 76% of launches overlap an open PR or a running run on the same paths.
+ *
+ * Delivery reuses existing channels only:
+ *   · live owning run  → one supervisor memo in its control inbox (`elanous self send --memo` path)
+ *   · no live run      → the registered `elanous:needs-rebase` label (QUIET-PR-COMMENTS: never a comment)
+ *
+ * Cost bound (#24893 review should-fix ①, measured 186 open PRs → 186 `…/files` calls per merge):
+ *   · prefilter   — a PR already carrying the marker is skipped before any file fetch
+ *   · priority    — PRs whose branch shares path tokens with the merged files are fetched first
+ *   · fetch cap   — at most `maxFetch` file inventories per merge (config `harness.siblingResync.maxFetch`, default 40)
+ *   · concurrency — at most `fetchConcurrency` (default 6) fetches in flight
+ *
+ * Pure core: every side effect is an injected adapter so tests never touch GitHub or the inbox.
+ */
+import { debug } from '../debug/log.js';
+import type { ControlMemoPayload } from '../harness/control-inbox.js';
+
+export const SIBLING_RESYNC_CATEGORY = 'self-implement.sibling-resync';
+export const SIBLING_RESYNC_DEFAULT_CAP = 10;
+export const SIBLING_RESYNC_DEFAULT_MAX_FETCH = 40;
+export const SIBLING_RESYNC_DEFAULT_FETCH_CONCURRENCY = 6;
+export const SIBLING_RESYNC_MARKER_LABEL = 'elanous:needs-rebase';
+const HARNESS_BRANCH_PREFIX = 'self-impl/';
+
+/** An open PR before its file inventory is fetched. */
+export interface SiblingResyncCandidate {
+  readonly number: number;
+  readonly branch: string;
+  readonly labels: readonly string[];
+}
+
+export interface SiblingResyncPr extends SiblingResyncCandidate {
+  /** `undefined` means the file list could not be proven complete — such a PR never qualifies. */
+  readonly files: readonly string[] | undefined;
+}
+
+export type SiblingRunTarget =
+  | { readonly alive: true; readonly runId: string; readonly spaceId: string }
+  | { readonly alive: false; readonly runId?: string; readonly reason: string };
+
+export interface SiblingResyncAdapters {
+  /** Open PRs (draft or ready) against the default branch, without files. A rejection is not an empty list. */
+  listOpenPrs(): Promise<readonly SiblingResyncCandidate[]>;
+  /** One PR's files; `undefined` (or a rejection) means unknown and that PR never qualifies. */
+  prFiles(number: number): Promise<readonly string[] | undefined>;
+  /** The merged PR's files; `undefined` means unknown and nothing is sent. */
+  mergedFiles(): Promise<readonly string[] | undefined>;
+  resolveRun(pr: SiblingResyncPr): Promise<SiblingRunTarget>;
+  sendResync(target: { runId: string; spaceId: string }, memo: ControlMemoPayload): Promise<void> | void;
+  addMarker(prNumber: number, label: string): Promise<void> | void;
+}
+
+export interface SiblingResyncResult {
+  readonly requested: readonly number[];
+  readonly marked: readonly number[];
+  readonly failed: readonly number[];
+  readonly skippedOverCap: readonly number[];
+  /** Already marked before any fetch — not fetched. */
+  readonly skippedPrefilter: readonly number[];
+  /** Over the per-merge fetch cap — not fetched. */
+  readonly skippedFetchCap: readonly number[];
+  readonly filesFetched: number;
+  readonly durationMs: number;
+  readonly reason?: string;
+}
+
+export function siblingResyncMemo(merged: number, overlap: readonly string[]): ControlMemoPayload {
+  const shown = overlap.slice(0, 5).join(', ');
+  const more = overlap.length > 5 ? ` (+${overlap.length - 5} more)` : '';
+  return {
+    version: 1,
+    kind: 'sibling-resync',
+    urgency: 'normal',
+    body: `[sibling-resync] Sibling PR #${merged} just merged into main touching the same paths: ${shown}${more}. `
+      + 'Before continuing: git fetch origin main, rebase this branch onto origin/main (resolve conflicts keeping both intents), then re-run the gate on your changed files.',
+  };
+}
+
+/** Exact path intersection; a PR without a provable file list is never a sibling. */
+export function overlappingFiles(merged: readonly string[], sibling: readonly string[] | undefined): string[] {
+  if (!sibling || sibling.length === 0) return [];
+  const mergedSet = new Set(merged);
+  return [...new Set(sibling.filter((file) => mergedSet.has(file)))].sort();
+}
+
+const GENERIC_TOKENS = new Set(['src', 'test', 'tests', 'index', 'scripts', 'docs', 'goals', 'goal', 'self', 'impl', 'apps', 'main', 'json', 'html', 'spec', 'types', 'lib']);
+
+/** Lower-case path tokens (dir segments and file stems split on `-_.`), generic and short ones removed. */
+export function pathTokens(text: string): Set<string> {
+  return new Set(text.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length >= 3 && !GENERIC_TOKENS.has(token) && !/^\d+$/.test(token)));
+}
+
+/** Shared path tokens between the merged files and a branch name — a cheap ordering hint, never a filter. */
+export function branchAffinity(mergedTokens: ReadonlySet<string>, branch: string): number {
+  let score = 0;
+  for (const token of pathTokens(branch)) if (mergedTokens.has(token)) score += 1;
+  return score;
+}
+
+async function mapBounded<T, R>(items: readonly T[], limit: number, work: (item: T) => Promise<R>): Promise<R[]> {
+  const results = new Array<R>(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, async () => {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await work(items[index]!);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
+const nonNegativeInt = (value: number | undefined, fallback: number): number =>
+  value !== undefined && Number.isSafeInteger(value) && value >= 0 ? value : fallback;
+
+export async function requestSiblingResync(input: {
+  merged: { number: number };
+  adapters: SiblingResyncAdapters;
+  cap?: number;
+  maxFetch?: number;
+  fetchConcurrency?: number;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+  now?: () => number;
+}): Promise<SiblingResyncResult> {
+  const { merged, adapters } = input;
+  const now = input.now ?? Date.now;
+  const startedAt = now();
+  const cap = nonNegativeInt(input.cap, SIBLING_RESYNC_DEFAULT_CAP);
+  const maxFetch = nonNegativeInt(input.maxFetch, SIBLING_RESYNC_DEFAULT_MAX_FETCH);
+  const concurrency = Math.max(1, nonNegativeInt(input.fetchConcurrency, SIBLING_RESYNC_DEFAULT_FETCH_CONCURRENCY));
+  const log = input.log ?? ((category, event, data) => debug.log(category, event, data));
+  const emit = (event: string, data: Record<string, unknown>) => {
+    try { log(SIBLING_RESYNC_CATEGORY, event, { merged: merged.number, ...data }); } catch { /* fail-soft */ }
+  };
+  const requested: number[] = [];
+  const marked: number[] = [];
+  const failed: number[] = [];
+  const skippedOverCap: number[] = [];
+  const skippedPrefilter: number[] = [];
+  const skippedFetchCap: number[] = [];
+  let filesFetched = 0;
+  const result = (reason?: string): SiblingResyncResult => ({
+    requested, marked, failed, skippedOverCap, skippedPrefilter, skippedFetchCap, filesFetched,
+    durationMs: Math.max(0, now() - startedAt), ...(reason ? { reason } : {}),
+  });
+  let mergedFiles: readonly string[] | undefined;
+  let open: readonly SiblingResyncCandidate[];
+  try {
+    mergedFiles = await adapters.mergedFiles();
+    if (!mergedFiles || mergedFiles.length === 0) {
+      const out = result('merged-files-unknown');
+      emit('skipped', { reason: out.reason, durationMs: out.durationMs });
+      return out;
+    }
+    open = await adapters.listOpenPrs();
+  } catch (error) {
+    const out = result('inventory-failed');
+    emit('skipped', { reason: out.reason, error: String(error), durationMs: out.durationMs });
+    return out;
+  }
+  const mergedTokens = new Set<string>();
+  for (const file of mergedFiles) for (const token of pathTokens(file)) mergedTokens.add(token);
+  const candidates: { pr: SiblingResyncCandidate; affinity: number }[] = [];
+  for (const pr of open) {
+    if (pr.number === merged.number || !pr.branch.startsWith(HARNESS_BRANCH_PREFIX)) continue;
+    // Already marked: the quiet signal is in place, and a re-fetch would only re-confirm it.
+    if (pr.labels.includes(SIBLING_RESYNC_MARKER_LABEL)) { skippedPrefilter.push(pr.number); continue; }
+    candidates.push({ pr, affinity: branchAffinity(mergedTokens, pr.branch) });
+  }
+  // Most likely siblings first; ties go to the newest PR (most likely to have a live run).
+  candidates.sort((a, b) => b.affinity - a.affinity || b.pr.number - a.pr.number);
+  const toFetch = candidates.slice(0, maxFetch);
+  skippedFetchCap.push(...candidates.slice(maxFetch).map(({ pr }) => pr.number));
+  const fetched = await mapBounded(toFetch, concurrency, async ({ pr }): Promise<SiblingResyncPr> => {
+    let files: readonly string[] | undefined;
+    try { files = await adapters.prFiles(pr.number); } catch { files = undefined; }
+    filesFetched += 1;
+    return { ...pr, files };
+  });
+  const siblings = fetched
+    .map((pr) => ({ pr, overlap: overlappingFiles(mergedFiles!, pr.files) }))
+    .filter(({ overlap }) => overlap.length > 0)
+    .sort((a, b) => a.pr.number - b.pr.number);
+  for (const [index, { pr, overlap }] of siblings.entries()) {
+    if (index >= cap) { skippedOverCap.push(pr.number); continue; }
+    let target: SiblingRunTarget;
+    try {
+      target = await adapters.resolveRun(pr);
+    } catch (error) {
+      target = { alive: false, reason: `run-resolution-failed: ${String(error)}` };
+    }
+    if (target.alive) {
+      try {
+        await adapters.sendResync({ runId: target.runId, spaceId: target.spaceId }, siblingResyncMemo(merged.number, overlap));
+        requested.push(pr.number);
+        emit('requested', { sibling: pr.number, runId: target.runId, spaceId: target.spaceId, overlap });
+        continue;
+      } catch (error) {
+        // A live run we could not reach still needs to be visible — fall through to the quiet marker.
+        emit('send-failed', { sibling: pr.number, runId: target.runId, error: String(error) });
+      }
+    }
+    try {
+      await adapters.addMarker(pr.number, SIBLING_RESYNC_MARKER_LABEL);
+      marked.push(pr.number);
+      emit('marked', { sibling: pr.number, label: SIBLING_RESYNC_MARKER_LABEL, reason: target.alive ? 'send-failed' : target.reason, ...(target.runId ? { runId: target.runId } : {}), overlap });
+    } catch (error) {
+      failed.push(pr.number);
+      emit('mark-failed', { sibling: pr.number, error: String(error) });
+    }
+  }
+  const out = result();
+  emit('summary', {
+    siblings: siblings.length, requested, marked, failed, skippedOverCap, cap,
+    filesFetched, skippedPrefilter: skippedPrefilter.length, skippedFetchCap: skippedFetchCap.length, maxFetch, concurrency,
+    durationMs: out.durationMs,
+  });
+  return out;
+}