elanous 0.2.9 → 0.2.11

package/src/seat-loop/seat-report.ts

@@ -0,0 +1,99 @@
+import { execFile } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { getUserConfig, type SeatLoopConfig } from '../user-config.js';
+import { seatDay, seatLedgerPath, type OpCandidate, type SeatEntry } from './seat-loop.js';
+
+export type SeatReportDeps = {
+  root?: string;
+  repo?: string;
+  now?: () => Date;
+  read?: (path: string) => string;
+  config?: SeatLoopConfig;
+  post?: boolean;
+  send?: (body: string, seat: string, pr: number) => Promise<void> | void;
+};
+export type SeatReportResult = { seat: string; date: string; body: string; posted: boolean };
+const repoRoot = resolve(import.meta.dir, '../..');
+const exec = promisify(execFile);
+
+function opJudgment(candidate: OpCandidate): { kind: 'card' | 'todo'; text: string } | null {
+  if (candidate.kind === 'release-readiness') {
+    if (candidate.verdict === 'no-open-release') return null;
+    return { kind: 'todo', text: `판올림 준비 ${candidate.version} · ${candidate.verdict} · 빨강 ${candidate.red.join(', ') || '없음'} · 미결 ${candidate.undecided.join(', ') || '없음'} · 차단 ${candidate.blocked.join(', ') || '없음'}` };
+  }
+  if (candidate.kind === 'unassigned-cell') {
+    if (candidate.verdict === 'none' || !candidate.id) return null;
+    return { kind: 'todo', text: `빈 칸 분배 ${candidate.version} ${candidate.id} ${candidate.title ?? ''}`.trim() };
+  }
+  if (candidate.verdict === 'none' || !candidate.id) return null;
+  const text = `결정 대리 ${candidate.id} ${candidate.title ?? ''}`.trim();
+  return { kind: candidate.category && ['irreversible', 'money', 'security', 'secret', 'publish'].includes(candidate.category) ? 'card' : 'todo',
+    text: `${text} (${candidate.category ?? '범주 없음'})` };
+}
+
+async function defaultSend(body: string, seat: string, pr: number, repo: string): Promise<void> {
+  const dir = mkdtempSync(join(tmpdir(), 'seat-report-'));
+  try {
+    const file = join(dir, 'body.md');
+    writeFileSync(file, body);
+    await exec('bash', [join(repo, 'scripts', 'coord-post.sh'), file], {
+      cwd: repo, env: { ...process.env, COORD_ID: seat, CH_PR: String(pr) }, timeout: 30_000,
+    });
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+}
+
+export async function seatReport(seat: string, deps: SeatReportDeps = {}): Promise<SeatReportResult> {
+  if (!/^(?:MK|OP|TC|UX)$/.test(seat)) throw new Error(`unknown seat: ${seat}`);
+  const now = (deps.now ?? (() => new Date()))();
+  const date = seatDay(now);
+  let raw = '';
+  try { raw = (deps.read ?? ((path) => readFileSync(path, 'utf8')))(seatLedgerPath(seat, deps.root ?? effectiveInstanceRoot(), now)); }
+  catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
+  const entries = raw.split('\n').filter(Boolean).map((line) => JSON.parse(line) as SeatEntry);
+  // One line per item, its last state wins: an `attempting` row followed by `launched` is not «unconfirmed».
+  const latest = new Map<string, SeatEntry>();
+  const judgments = new Map<string, OpCandidate>();
+  for (const entry of entries) {
+    if (seat === 'OP' && entry.candidate) {
+      if (entry.candidate.verdict === 'none') {
+        if (entry.candidate.id) {
+          const key = entry.candidate.kind === 'unassigned-cell'
+            ? `unassigned-cell:${JSON.stringify([entry.candidate.version, entry.candidate.id])}`
+            : `decision-delegation:${entry.candidate.id}`;
+          judgments.delete(key);
+        } else for (const key of judgments.keys()) if (key.startsWith(`${entry.candidate.kind}:`)) judgments.delete(key);
+        continue;
+      }
+      const key = entry.candidate.kind === 'unassigned-cell'
+        ? `unassigned-cell:${JSON.stringify([entry.candidate.version, entry.candidate.id])}`
+        : entry.candidate.kind === 'decision-delegation' && entry.candidate.id
+          ? `${entry.candidate.kind}:${entry.candidate.id}` : entry.candidate.kind;
+      judgments.set(key, entry.candidate);
+      continue;
+    }
+    const key = entry.item ? `${entry.item.source}:${entry.item.version ?? ''}:${entry.item.id}` : `none:${entry.status}`;
+    latest.delete(key);
+    latest.set(key, entry);
+  }
+  const detail = [...latest.values()].map((entry) => {
+    const label = entry.item ? `${entry.item.version ? `${entry.item.version} ` : ''}${entry.item.id} ${entry.item.title}`.replace(/\s+/g, ' ').trim() : '배정 없음';
+    if (entry.status === 'launched') return `발사 ${label} (${entry.runId ?? 'runId 없음'})`;
+    if (entry.status === 'hitl') return `결정 상정 ${label}`;
+    if (entry.status === 'shadow') return `shadow ${label}`;
+    if (entry.status === 'attempting' || entry.status === 'outcome-unknown') return `결과 확인 필요 ${entry.status} ${label}`;
+    return `건너뜀 ${entry.status} ${label}`;
+  });
+  const classified = [...judgments.values()].map(opJudgment).filter((row): row is NonNullable<typeof row> => row !== null);
+  const opDetail = classified.length ? ` · 결정 카드 후보: ${classified.filter((row) => row.kind === 'card').map((row) => row.text).join(' / ') || '없음'} · OP 가 할 일: ${classified.filter((row) => row.kind === 'todo').map((row) => row.text).join(' / ') || '없음'}` : '';
+  const body = `**[${seat}]** {{TS}} → 보고 ${date}: ${detail.join(' · ') || (classified.length ? 'OP 그림자 판단' : '원장 기록 없음')}${opDetail}`;
+  const pr = (deps.config ?? getUserConfig().loops?.seat)?.reportPr;
+  const posted = deps.post === true && pr !== undefined;
+  if (posted) await (deps.send ?? ((text, id, number) => defaultSend(text, id, number, deps.repo ?? repoRoot)))(body, seat, pr);
+  try { debug.log('seat.loop', 'reported', { seat, date, entries: entries.length, posted }); } catch { /* observation is fail-soft */ }
+  return { seat, date, body, posted };
+}

package/src/self-dev/decompose.ts

@@ -156,6 +156,8 @@ interface SelfDevSubtaskGradeRationale {
 }
 
 export interface SelfDevDecompositionObservation extends SelfDevDecompositionMeta {
+  /** Number of registration-only goals folded into their dependency. */
+  foldedRegistration: number;
   /** Number of retained subtasks whose original feature text grades `too_large`. */
   tooLargeSubtaskCount: number;
   /** Number of retained subtasks whose original feature text grades `too_small`. */
@@ -250,7 +252,7 @@ function observeDecomposerSelection(selection: SelfDevDecomposerSelection, obser
 }
 
 function applyGoalDefaultsAndHotPaths(goals: SelfDevGoal[], defaults: { base?: string; autoMerge?: boolean }): SelfDevGoal[] {
-  return pruneDanglingDependencies(goals.map((goal) => {
+  return goals.map((goal) => {
     const hotPaths = [...new Set([...(goal.hotPaths ?? []), ...inferHotPaths(goal.feature ?? '')])];
     return {
       ...goal,
@@ -258,7 +260,55 @@ function applyGoalDefaultsAndHotPaths(goals: SelfDevGoal[], defaults: { base?: s
       ...(defaults.base !== undefined ? { base: defaults.base } : {}),
       ...(defaults.autoMerge !== undefined ? { autoMerge: defaults.autoMerge } : {}),
     };
-  }));
+  });
+}
+
+const REGISTRATION_FILES = new Set([
+  'src/nexus/api/http-server.ts',
+  'src/index.ts',
+  'src/telegram-commands.ts',
+]);
+
+function isRegistrationFile(path: string): boolean {
+  return REGISTRATION_FILES.has(path) || /^graphs\/(?:[^/]+\/)*[^/]+\.yaml$/.test(path);
+}
+
+/** Fold only registration-only goals into their one retained dependency. */
+export function foldRegistrationOnlyGoals(goals: SelfDevGoal[]): SelfDevGoal[] {
+  let remaining = [...goals];
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const registration of remaining) {
+      const files = registration.hotPaths ?? [];
+      if (files.length === 0 || !files.every(isRegistrationFile) || registration.dependsOn?.length !== 1) continue;
+      const dependencyId = registration.dependsOn[0];
+      const targetIndex = remaining.findIndex((goal) => goal.id === dependencyId && goal !== registration);
+      if (targetIndex < 0) continue;
+      const target = remaining[targetIndex]!;
+      remaining = remaining.filter((goal) => goal !== registration).map((goal) => {
+        if (goal === target) {
+          const dependsOn = goal.dependsOn?.filter((id) => id !== registration.id && id !== goal.id);
+          const { dependsOn: _old, ...rest } = goal;
+          return {
+            ...rest,
+            ...(dependsOn?.length ? { dependsOn } : {}),
+            feature: `${goal.feature}\nAlso register: ${registration.feature}`,
+            hotPaths: [...new Set([...(goal.hotPaths ?? []), ...files])],
+          };
+        }
+        if (!goal.dependsOn?.includes(registration.id!)) return goal;
+        const dependsOn = [...new Set(goal.dependsOn.map((id) => id === registration.id ? target.id! : id))]
+          .filter((id) => id !== goal.id);
+        const { dependsOn: _old, ...rest } = goal;
+        return dependsOn.length ? { ...rest, dependsOn } : rest;
+      });
+      debug.log('self-dev.decompose', 'fold-registration', { from: registration.id, into: target.id, files });
+      changed = true;
+      break;
+    }
+  }
+  return remaining;
 }
 
 function observeDecomposition(
@@ -267,12 +317,14 @@ function observeDecomposition(
   arcClassification?: { arcs: SelfDevArc[]; hintDeviation?: { requested: number; actual: number } },
   observationContext: SelfDevDecompositionObservationContext = {},
   pathGroundingOptions?: DecomposePathGroundingOptions,
+  foldedRegistration = 0,
 ): SelfDevDecomposition {
   const retainedSubtasks = decomposition.outcome === 'decomposed' ? goals : [];
   const gradedSubtasks = retainedSubtasks.map(gradeRetainedSubtask);
   const tooLargeSubtaskCount = gradedSubtasks.filter(({ grade }) => grade.verdict === 'too_large').length;
   const observation: SelfDevDecompositionObservation & { goalId: string | null; runId: string | null } = {
     ...decomposition,
+    foldedRegistration,
     tooLargeSubtaskCount,
     tooSmallSubtaskCount: gradedSubtasks.filter(({ grade }) => grade.verdict === 'too_small').length,
     hasMultipleTooLargeSubtasks: tooLargeSubtaskCount >= 2,
@@ -467,14 +519,15 @@ async function finalizeDecomposition(
   decomposition: SelfDevDecompositionMeta,
   opts: SelfDevDecomposeOptions,
   arcHint: number | undefined,
+  foldedRegistration = 0,
 ): Promise<SelfDevDecomposition> {
-  if (arcHint === undefined || goals.length === 0) return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding);
+  if (arcHint === undefined || goals.length === 0) return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding, foldedRegistration);
   try {
     const arcLlm = opts.arcLlm ?? opts.llm ?? (await defaultDecomposeLlm(opts.model));
     const tasks = goals.map((goal) => ({ id: goal.id ?? '', title: goal.feature ?? '', description: goal.feature, dependsOn: goal.dependsOn }));
     const grouping = parseSelfDevArcGrouping(await arcLlm(buildSelfDevArcClassifyPrompt(feature, tasks, arcHint)));
     const classification = grouping ? deriveSelfDevArcsFromGrouping(tasks, grouping, arcHint) : null;
-    if (!classification) return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding);
+    if (!classification) return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding, foldedRegistration);
     const arcByTask = new Map(classification.arcs.flatMap((arc) => arc.taskIds.map((taskId) => [taskId, arc])));
     const taskIdsForArc = new Map(classification.arcs.map((arc) => [arc.id, arc.taskIds]));
     const orderedGoals = goals.map((goal) => {
@@ -482,9 +535,9 @@ async function finalizeDecomposition(
       const dependsOn = [...new Set([...(goal.dependsOn ?? []), ...arcDependencies])].filter((id) => id !== goal.id);
       return dependsOn.length ? { ...goal, dependsOn } : goal;
     });
-    return observeDecomposition(pruneDanglingDependencies(orderedGoals), decomposition, classification, opts.observation, opts.pathGrounding);
+    return observeDecomposition(pruneDanglingDependencies(orderedGoals), decomposition, classification, opts.observation, opts.pathGrounding, foldedRegistration);
   } catch {
-    return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding);
+    return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding, foldedRegistration);
   }
 }
 
@@ -514,17 +567,18 @@ export async function decomposeSelfDevGoal(
     }
     observeDecomposerSelection('fabric', opts.observation);
     const actualTaskCount = result.goals.length;
-    const goals = actualTaskCount > 0
+    const prepared = actualTaskCount > 0
       ? applyGoalDefaultsAndHotPaths(result.goals.slice(0, hardMaxTasks), defaults)
       : [single];
-    return finalizeDecomposition(feature, goals, {
+    const goals = foldRegistrationOnlyGoals(prepared);
+    return finalizeDecomposition(feature, pruneDanglingDependencies(goals), {
       recommendedMaxTasks: maxTasks,
       actualTaskCount,
       truncatedAtHardMax: actualTaskCount > hardMaxTasks,
       exceededRecommendedMax: actualTaskCount > maxTasks,
       outcome: actualTaskCount === 0 ? 'single-no-subtasks' : 'decomposed',
       omittedGoalCount: result.omittedGoalCount,
-    }, opts, actualTaskCount > 0 ? arcHint : undefined);
+    }, opts, actualTaskCount > 0 ? arcHint : undefined, prepared.length - goals.length);
   }
 
   observeDecomposerSelection('default', opts.observation);
@@ -539,8 +593,9 @@ export async function decomposeSelfDevGoal(
   const actualTaskCount = rawSubtasks.length;
   const decomposition: SelfDevDecompositionMeta = { recommendedMaxTasks: maxTasks, actualTaskCount, truncatedAtHardMax: actualTaskCount > hardMaxTasks, exceededRecommendedMax: actualTaskCount > maxTasks, outcome: actualTaskCount === 0 ? 'single-no-subtasks' : 'decomposed' };
   const parsedGoals = parseSelfDevDecomposition(JSON.stringify({ subtasks: rawSubtasks.slice(0, hardMaxTasks) }), defaults);
-  const goals = parsedGoals.length > 0 ? pruneDanglingDependencies(parsedGoals) : [single];
-  return finalizeDecomposition(feature, goals, decomposition, opts, parsedGoals.length > 0 ? arcHint : undefined);
+  const foldedGoals = foldRegistrationOnlyGoals(parsedGoals);
+  const goals = parsedGoals.length > 0 ? pruneDanglingDependencies(foldedGoals) : [single];
+  return finalizeDecomposition(feature, goals, decomposition, opts, parsedGoals.length > 0 ? arcHint : undefined, parsedGoals.length - foldedGoals.length);
 }
 
 /** Default LLM seam — lazy `streamLLM` wire (kept out of the test path). */

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

@@ -97,6 +97,8 @@ export interface DevCliOpts {
   pollMs?: string;
   model?: string;
   attach?: string;
+  /** drive: DRIVE-JAIL boundary directory. */
+  jailHome?: string;
   observeOnly?: boolean;
   cols?: string;
   rows?: string;
@@ -1748,7 +1750,7 @@ export function assertDevCliPathOptions(
   if (foreign.length > 0) throw new DevPipelineError(formatForeignDevOptions(path, foreign));
 }
 
-const DRIVE_ALIAS_OPTIONS = new Set(['goal', 'maxSteps', 'pollMs', 'model', 'cwd', 'worktree', 'json', 'attach']);
+const DRIVE_ALIAS_OPTIONS = new Set(['goal', 'maxSteps', 'pollMs', 'model', 'cwd', 'worktree', 'json', 'attach', 'jailHome']);
 const DRIVE_ALIAS_ALLOWED_FLAGS = [...DRIVE_ALIAS_OPTIONS].map(toCliFlag).join(' · ');
 
 export function assertDriveAliasOptions(explicitOptionNames: readonly string[]): void {
@@ -1947,6 +1949,7 @@ export function buildDevCliSpec(
         ...(opts.pollMs !== undefined ? { pollMs: parseNonNegativeInt(opts.pollMs, '--poll-ms') } : {}),
         ...(opts.model ? { model: opts.model } : {}),
         ...(opts.cwd ? { cwd: opts.cwd } : {}),
+        ...(opts.jailHome ? { jailHome: opts.jailHome } : {}),
       },
     };
   }

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

@@ -25,6 +25,7 @@ import { createRepositoryReferencedFileReader, type ReferencedFileReader } from
 import { parseGoalDocumentClarifications } from '../self-implement/goal-author-clarification.js';
 import { requiredEvidenceFromGoal } from '../self-implement/off-diff-evidence.js';
 import { debug } from '../debug/log.js';
+import { releasePathHold, releasePathHoldComment, RELEASE_PATH_LABEL } from './release-path-guard.js';
 import { runGitCommand } from '../git-fs/runner.js';
 import type { GitRunResult } from '../git-fs/retry.js';
 import { DEFAULT_BRANCH_WORKTREE_BASE, observeGitResidue, type GitResidueObservation } from '../git-fs/worktree.js';
@@ -135,6 +136,8 @@ export interface DevShellDriveOpts {
   pollMs?: number;
   model?: string;
   cwd?: string;
+  /** DRIVE-JAIL boundary — inputs naming paths outside it are not sent to the PTY. */
+  jailHome?: string;
 }
 
 /** staged harness(plan-staged) 실행 옵션 — `harness run` front door의 무손실 재라우팅용.
@@ -1852,6 +1855,24 @@ async function observeDevTaskDispatch(spec: DevPipelineSpec, plan: ResolvedDevPl
   }
 }
 
+async function inspectReleasePathBeforeMerge(seams: SelfImplementSeams, number: number, cwd: string): Promise<string | undefined> {
+  if (!seams.readPrFiles) throw new Error('release-path inspection unavailable — automatic merge refused');
+  const files = await seams.readPrFiles({ number, cwd });
+  if (!Array.isArray(files) || !files.every((path) => typeof path === 'string')) throw new Error('invalid PR file list — automatic merge refused');
+  const path = releasePathHold(files);
+  if (!path) return undefined;
+  debug.log('self-dev.merge', 'release-path-hold', { number, path, label: RELEASE_PATH_LABEL });
+  try {
+    if (!seams.addPrLabel) throw new Error('addPrLabel seam unavailable');
+    await seams.addPrLabel({ number, label: RELEASE_PATH_LABEL, cwd });
+  } catch (error) { debug.log('self-dev.merge', 'release-path-annotation-failed', { number, path, action: 'label', error: String(error) }); }
+  try {
+    if (!seams.postPrComment) throw new Error('postPrComment seam unavailable');
+    await seams.postPrComment({ number, body: releasePathHoldComment(path), cwd });
+  } catch (error) { debug.log('self-dev.merge', 'release-path-annotation-failed', { number, path, action: 'comment', error: String(error) }); }
+  return path;
+}
+
 async function runDevPipelineDispatch(
   spec: DevPipelineSpec,
   deps: DevPipelineDeps,
@@ -2071,7 +2092,22 @@ async function runDevPipelineDispatch(
     const defaultSeams = deps.buildSelfImplementSeams
       ? await deps.buildSelfImplementSeams(plan)
       : await buildDefaultSelfImplementSeams(plan, { progress: deps.progress });
-    const seams = deps.approver ? { ...defaultSeams, approvePr: deps.approver } : defaultSeams;
+    const assembledSeams = deps.approver ? { ...defaultSeams, approvePr: deps.approver } : defaultSeams;
+    // Guard even injected runSelfImplement implementations: do not trust a dispatched merge to
+    // have used orchestrator's own PR-path check before requesting mergePr.
+    const seams: SelfImplementSeams = {
+      ...assembledSeams,
+      ...(assembledSeams.mergePr ? { mergePr: async (input) => {
+        let path: string | undefined;
+        try { path = await inspectReleasePathBeforeMerge(assembledSeams, input.number, input.cwd); }
+        catch (error) {
+          debug.log('self-dev.merge', 'release-path-inspection-failed', { number: input.number, error: String(error) });
+          return { merged: false, detail: `automatic merge refused: ${String(error)}` };
+        }
+        if (path) return { merged: false, detail: `OP approval required: ${path}` };
+        return assembledSeams.mergePr!(input);
+      } } : {}),
+    };
     // ⭐ 대표 지시(2026-09-08) — ***걸음을 「위」로 흘린다.***
     //   🩸 그 전까지 런 슈퍼바이저가 받는 것은 «시도의 요약 판정»뿐이었고(stage·stopReason·분류 …)
     //     「어느 노드를 몇 번 밟았나」는 ***런 안에서 끝났다***(`onNodeEntry` 는 있는데 호출부 0).

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

@@ -1,11 +1,12 @@
-import { CLAIM_IDLE_HOURS, PR_LABELS } from '../github/pr-labels.js';
+import { CLAIM_IDLE_HOURS, PR_LABELS, STALLED_DRAFT_HOURS } from '../github/pr-labels.js';
+import { debug } from '../debug/log.js';
 import { decideDraft, type DraftTriagePr } from './draft-triage-rules.js';
 
 export interface SweepDraft extends DraftTriagePr {
   readonly title: string;
   readonly labels: readonly string[];
   readonly createdAt: string;
-  /** Last PR update (push, label, comment). Missing ⇒ running claim stays untouched; other drafts use legacy triage. */
+  /** Last PR update (push, label, comment). Missing ⇒ no idle-based close; merged twins can still close. */
   readonly updatedAt?: string;
   readonly runId?: string | null;
 }
@@ -18,7 +19,7 @@ export interface DraftSweepAdapters {
   /** Each call returns one complete page; a rejection must not be mistaken for an empty page. */
   listDrafts(page: number, perPage: number, repository: string): Promise<readonly SweepDraft[]>;
   listMerged(page: number, perPage: number, repository: string): Promise<readonly SweepMergedPr[]>;
-  /** Undefined means no run assessment; it does not authorize a close. */
+  /** Undefined means no run assessment; a merged twin or 24h idle draft can still authorize a close. */
   getRunStatus(draft: SweepDraft, repository: string): Promise<string | undefined>;
   /** Undefined means liveness could not be established. */
   listLiveBranches(repository: string): Promise<ReadonlySet<string> | undefined>;
@@ -51,6 +52,7 @@ export interface DraftSweepResult {
   apply: boolean;
   complete: boolean;
   entries: DraftSweepEntry[];
+  counts: Record<string, number>;
   /** Drafts whose run could not be observed from here (kept, or closed by the idle rule). */
   unobserved?: number;
   /** Closes decided this tick (at most DRAFT_SWEEP_CLOSE_CAP). */
@@ -73,11 +75,8 @@ const stalledLabel = label('close', 'stalled');
 const supersededLabel = label('close', 'superseded');
 const approvalLabel = PR_LABELS.find((entry) => entry.axis === 'state' && entry.sweep.action === 'none')?.name;
 const keepLabel = PR_LABELS.find((entry) => entry.sweep.action === 'exclude')?.name;
+const releaseHoldLabel = PR_LABELS.find((entry) => entry.axis === 'addon' && entry.sweep.action === 'none')?.name;
 const PAGE_SIZE = 100;
-/** 🅢 2026-09-28 (lead decision, channel #20798 04:1x): a run the sweeper cannot see is closed as stalled only when its branch
- *  is not in a host worktree and the draft has been idle this long. A Pod lives at most POD_JOB_DEADLINE_SECONDS (3h), so a
- *  draft idle for 48h cannot belong to a running Pod — the «not in a running Pod» condition follows from the idle time. */
-export const UNOBSERVED_IDLE_CLOSE_HOURS = 48;
 /** At most this many closes per tick, so a wrong rule cannot close everything at once. */
 export const DRAFT_SWEEP_CLOSE_CAP = 10;
 
@@ -94,7 +93,16 @@ async function collectPages<T>(fetch: (page: number, perPage: number) => Promise
 
 /** A failed inventory or liveness lookup is never treated as proof that a draft can be closed. */
 export async function runDraftSweep({ repository, adapters, apply = false, now = new Date() }: DraftSweepOptions): Promise<DraftSweepResult> {
-  const result: DraftSweepResult = { repository, apply, complete: false, entries: [] };
+  const result: DraftSweepResult = { repository, apply, complete: false, entries: [], counts: {} };
+  const record = (entry: DraftSweepEntry): void => {
+    result.entries.push(entry);
+    result.counts[entry.reason] = (result.counts[entry.reason] ?? 0) + 1;
+    debug.log('drafts.cleanup', 'decided', { number: entry.number, action: entry.action, reason: entry.reason });
+  };
+  const finish = (): DraftSweepResult => {
+    debug.log('drafts.cleanup', 'summary', result.counts);
+    return result;
+  };
   let drafts: SweepDraft[];
   let merged: SweepMergedPr[];
   let liveBranches: ReadonlySet<string> | undefined;
@@ -109,7 +117,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       || merged.some((pr) => !Number.isInteger(pr.number) || !pr.branch)) throw new Error('Invalid PR inventory');
   } catch (error) {
     result.error = String(error);
-    return result;
+    return finish();
   }
   let statuses: Map<number, string | undefined>;
   try {
@@ -117,7 +125,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     for (const draft of drafts) statuses.set(draft.number, await adapters.getRunStatus(draft, repository));
   } catch (error) {
     result.error = String(error);
-    return result;
+    return finish();
   }
   result.complete = true;
   let closes = 0;
@@ -128,39 +136,41 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     const runStatus = statuses.get(draft.number);
     const states = stateLabels.filter((state) => draft.labels.includes(state.name));
     const contradiction = states.length > 1 || draft.labels.includes(approvalLabel ?? '');
-    if (!contradiction && draft.labels.includes(keepLabel ?? '')) {
-      result.entries.push({ number: draft.number, action: 'keep', reason: `label:${keepLabel}`, applied: false });
+    if (draft.labels.includes(releaseHoldLabel ?? '') || (!contradiction && draft.labels.includes(keepLabel ?? ''))) {
+      const held = draft.labels.includes(keepLabel ?? '') ? keepLabel : releaseHoldLabel;
+      record({ number: draft.number, action: 'keep', reason: `label:${held}`, applied: false });
       continue;
     }
     const isClaimed = !contradiction && draft.labels.includes(runningLabel);
     const ageHours = (now.getTime() - Date.parse(draft.createdAt)) / 3_600_000;
+    const idleHours = typeof draft.updatedAt === 'string' && Number.isFinite(Date.parse(draft.updatedAt))
+      ? (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: runStatus ?? 'ended-unclosed', mergedTwins: merged, liveBranches, ageHours }) : undefined;
+    const mergedDecision = isClaimed ? decideDraft({ draft, runStatus, mergedTwins: merged, liveBranches, ageHours: idleHours }) : undefined;
     const supersededClaim = mergedDecision?.reason.startsWith('superseded-by #') === true;
     // 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)))) {
-      result.entries.push({ number: draft.number, action: 'keep', reason: 'claim-update-unobserved', applied: false });
+      record({ number: draft.number, action: 'keep', reason: 'claim-update-unobserved', applied: false });
       continue;
     }
-    const claimIdleHours = draft.updatedAt === undefined ? NaN : (now.getTime() - Date.parse(draft.updatedAt)) / 3_600_000;
-    if (isClaimed && !supersededClaim && Number.isFinite(claimIdleHours) && claimIdleHours < CLAIM_IDLE_HOURS) {
+    if (isClaimed && !supersededClaim && Number.isFinite(idleHours) && idleHours < CLAIM_IDLE_HOURS) {
       claimed += 1;
-      result.entries.push({ number: draft.number, action: 'keep', reason: `label:running(<${CLAIM_IDLE_HOURS}h)`, applied: false });
+      record({ number: draft.number, action: 'keep', reason: `label:running(<${CLAIM_IDLE_HOURS}h)`, applied: false });
       continue;
     }
-    if (isClaimed && !supersededClaim && Number.isFinite(claimIdleHours) && claimIdleHours >= CLAIM_IDLE_HOURS) {
+    if (isClaimed && !supersededClaim && Number.isFinite(idleHours) && idleHours >= CLAIM_IDLE_HOURS) {
       claimExpired += 1;
       if (runStatus === 'running' || runStatus === 'probable-running' || liveBranches.has(draft.branch)) {
-        result.entries.push({ number: draft.number, action: 'keep', reason: 'claim-expired-but-live', applied: false });
+        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',
         ...(action === 'close' ? { statusLabel: stalledLabel } : {}), applied: false };
-      result.entries.push(entry);
+      record(entry);
       if (!apply || action !== 'close') continue;
       let labelsChanged = false;
       try {
@@ -178,17 +188,12 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
     }
     // Unlabelled non-harness drafts are outside the sweeper's jurisdiction.
     if (!contradiction && !states.length && !draft.branch.startsWith('self-impl/')) {
-      result.entries.push({ number: draft.number, action: 'keep', reason: 'outside-harness', applied: false });
+      record({ number: draft.number, action: 'keep', reason: 'outside-harness', applied: false });
       continue;
     }
-    let decision = supersededClaim ? mergedDecision! : decideDraft({ draft, runStatus, mergedTwins: merged, liveBranches, ageHours });
-    if (decision.reason === 'unobserved') {
-      unobserved += 1;
-      const idleHours = (now.getTime() - Date.parse(draft.updatedAt ?? draft.createdAt)) / 3_600_000;
-      if (!liveBranches.has(draft.branch) && Number.isFinite(idleHours) && idleHours >= UNOBSERVED_IDLE_CLOSE_HOURS) {
-        decision = { action: 'close', reason: 'unobserved-idle' };
-      }
-    }
+    let decision = supersededClaim ? mergedDecision! : decideDraft({ draft, runStatus, mergedTwins: merged, liveBranches,
+      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' };
       else closes += 1;
@@ -202,7 +207,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       ? decision.reason.startsWith('superseded-by #') ? 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 };
-    result.entries.push(entry);
+    record(entry);
     if (!apply || action === 'report') continue;
     let labelsChanged = false;
     try {
@@ -213,8 +218,8 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
         labelsChanged = true;
       }
       if (action === 'close') {
-        await adapters.closeDraft(repository, draft.number, decision.reason === 'unobserved-idle'
-          ? `Draft sweep: run unobserved — no run record reachable here, no host worktree for this branch, idle ≥${UNOBSERVED_IDLE_CLOSE_HOURS}h. Closed as stalled. Branch preserved; reopen to restore.`
+        await adapters.closeDraft(repository, draft.number, decision.reason === 'stale-unobserved'
+          ? `Draft sweep: run unobserved — no run record reachable here, no host worktree for this branch, idle ≥${STALLED_DRAFT_HOURS}h. Closed as stalled. Branch preserved; reopen to restore.`
           : `Draft sweep: ${decision.reason}. Branch preserved.`);
       }
       entry.applied = labelsChanged || action === 'close';
@@ -227,5 +232,5 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
   result.closed = closes;
   result.claimed = claimed;
   result.claimExpired = claimExpired;
-  return result;
+  return finish();
 }

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

@@ -1,4 +1,5 @@
 import { PR_LABELS, STALLED_DRAFT_HOURS } from '../github/pr-labels.js';
+import { RELEASE_PATH_LABEL } from './release-path-guard.js';
 
 export interface DraftTriagePr {
   number: number;
@@ -18,9 +19,10 @@ export interface DraftTriageInput {
 export type DraftDecision = { action: 'close' | 'keep'; reason: string };
 
 // Labels the sweeper must never close: an approval-waiting state and the human «keep» / release holds (R-PRK3).
-const PROTECTED_LABELS: ReadonlySet<string> = new Set<string>(PR_LABELS
-  .filter((label) => label.sweep.action === 'exclude' || (label.axis === 'state' && label.sweep.action === 'none'))
-  .map((label) => label.name));
+// RELGUARD's release-path hold waits for OP approval — a long wait is not «stale» (TC review #23217).
+const PROTECTED_LABELS: ReadonlySet<string> = new Set<string>([...PR_LABELS
+  .filter((label) => label.sweep.action === 'exclude' || (label.sweep.action === 'none' && (label.axis === 'state' || label.axis === 'addon')))
+  .map((label) => label.name), RELEASE_PATH_LABEL]);
 
 const goalId = (branch: string): string | undefined => /(?:^|[-/])goalid-([a-f0-9]+)(?=-|\/|$)/i.exec(branch)?.[1]?.toLowerCase();
 
@@ -30,13 +32,14 @@ export function decideDraft({ draft, runStatus, mergedTwins, ageHours, liveBranc
   if (runStatus === 'running' || runStatus === 'probable-running' || (draft.branch && liveBranches.has(draft.branch))) {
     return { action: 'keep', reason: 'live' };
   }
-  // A missing assessment never authorizes a close; unknown is the running-run query's non-running classification.
-  if (!runStatus) return { action: 'keep', reason: 'unobserved' };   // run status unknown — kept, and said so
   const lineage = goalId(draft.branch);
   const twin = mergedTwins.find((pr) => pr.number !== draft.number && (
     (draft.title && pr.title === draft.title) || (lineage && goalId(pr.branch) === lineage)
   ));
   if (twin) return { action: 'close', reason: `superseded-by #${twin.number}` };
+  if (!runStatus) return Number.isFinite(ageHours) && ageHours >= STALLED_DRAFT_HOURS
+    ? { action: 'close', reason: 'stale-unobserved' }
+    : { action: 'keep', reason: 'unobserved' };
   if (Number.isFinite(ageHours) && ageHours >= STALLED_DRAFT_HOURS) return { action: 'close', reason: 'stale-ended-run' };
   return { action: 'keep', reason: 'recent' };
 }