elanous 0.2.4 → 0.2.6

package/src/release-loop/checklist.ts

@@ -0,0 +1,217 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { Database } from 'bun:sqlite';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { debug } from '../debug/log.js';
+import { releaseLedgerRoot } from '../instance/resolve.js';
+
+export type ChecklistStatus = 'green' | 'yellow' | 'red' | 'done';
+export type ChecklistDisposition = 'move' | 'known-issue' | 'block';
+export interface ChecklistItem {
+  id: string;
+  title: string;
+  status: ChecklistStatus;
+  owner?: string;
+  evidence?: string;
+  disposition?: ChecklistDisposition;
+  updatedAt: string;
+  updatedBy: string;
+}
+export interface ChecklistHistory {
+  at: string;
+  by: string;
+  id: string;
+  field: string;
+  from: unknown;
+  to: unknown;
+  released: string;
+  dev: string;
+}
+export interface Checklist {
+  version: string;
+  released: string;
+  dev: string;
+  items: ChecklistItem[];
+  history: ChecklistHistory[];
+}
+
+export function devVersion(): string {
+  return (JSON.parse(readFileSync(join(import.meta.dir, '..', '..', 'package.json'), 'utf8')) as { version: string }).version;
+}
+
+function releasedVersion(): string {
+  const dir = join(releaseLedgerRoot(), 'release');
+  if (!existsSync(dir)) return '';
+  return readdirSync(dir).filter((v) => /^\d+\.\d+\.\d+$/.test(v) && existsSync(join(dir, v, 'release.json')))
+    .filter((v) => {
+      try { const record = JSON.parse(readFileSync(join(dir, v, 'release.json'), 'utf8')) as { version?: string; publishedAt?: string }; return record.version === v && typeof record.publishedAt === 'string'; }
+      catch { return false; }
+    })
+    .sort((a, b) => {
+      const aa = a.split('.').map(Number), bb = b.split('.').map(Number);
+      return (bb[0]! - aa[0]!) || (bb[1]! - aa[1]!) || (bb[2]! - aa[2]!);
+    })[0] ?? '';
+}
+
+function pathFor(v: string): string {
+  if (!/^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/.test(v)) throw new Error(`체크리스트 판이 아니다: ${v}`);
+  return join(releaseLedgerRoot(), 'release', v, 'checklist.json');
+}
+
+export function listChecklist(v: string): Checklist {
+  const path = pathFor(v);
+  if (existsSync(path)) {
+    const data = JSON.parse(readFileSync(path, 'utf8')) as Checklist;
+    refresh(data);
+    return data;
+  }
+  return { version: v, released: releasedVersion(), dev: devVersion(), items: [], history: [] };
+}
+
+// SQLite's OS-backed write lock is released when the owning process exits, even without a finally block.
+// Hold it across the JSON read/modify/atomic-rename sequence so writers never use stale snapshots.
+function mutate(v: string, apply: (data: Checklist) => boolean): Checklist {
+  const path = pathFor(v);
+  mkdirSync(dirname(path), { recursive: true });
+  const lock = `${path}.mutex.sqlite`;
+  const db = new Database(lock, { create: true, strict: true });
+  try {
+    chmodSync(lock, 0o600);
+    db.exec('PRAGMA busy_timeout = 10000');
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      const data = listChecklist(v);
+      if (apply(data)) save(v, data);
+      db.exec('COMMIT');
+      return data;
+    } catch (error) {
+      db.exec('ROLLBACK');
+      throw error;
+    }
+  } finally { db.close(); }
+}
+
+function save(v: string, data: Checklist): void {
+  const path = pathFor(v);
+  mkdirSync(dirname(path), { recursive: true });
+  const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temp, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
+    chmodSync(temp, 0o600);
+    renameSync(temp, path);
+  } finally { if (existsSync(temp)) rmSync(temp); }
+}
+
+function change(data: Checklist, id: string, field: string, from: unknown, to: unknown, by: string, at: string): void {
+  data.history.push({ at, by, id, field, from: from ?? null, to: to ?? null, released: data.released, dev: data.dev });
+  debug.log('release-loop.checklist', 'change', { version: data.version, id, field, from: from ?? null, to: to ?? null, by });
+}
+
+function refresh(data: Checklist): void { data.released = releasedVersion(); data.dev = devVersion(); }
+
+export function addItem(v: string, input: { id: string; title: string; owner?: string }): Checklist {
+  if (!input.id.trim()) throw new Error('칸 id 가 비었다');
+  if (!input.title.trim()) throw new Error('칸 제목이 비었다');
+  return mutate(v, (data) => {
+    if (data.items.some((item) => item.id === input.id)) throw new Error(`이미 있는 칸: ${input.id}`);
+    const by = process.env.ELANOUS_TRACK || 'cli';
+    const at = new Date().toISOString();
+    const item: ChecklistItem = { id: input.id, title: input.title, status: 'yellow', ...(input.owner !== undefined ? { owner: input.owner } : {}), updatedAt: at, updatedBy: by };
+    data.items.push(item);
+    change(data, item.id, 'add', null, item, by, at);
+    return true;
+  });
+}
+
+export function setItem(v: string, id: string, patch: { status?: ChecklistStatus; evidence?: string; owner?: string; disposition?: ChecklistDisposition }, by: string): Checklist {
+  return mutate(v, (data) => {
+    const item = data.items.find((i) => i.id === id);
+    if (!item) throw new Error(`없는 칸: ${id}`);
+    if (patch.status !== undefined && !['green', 'yellow', 'red', 'done'].includes(patch.status)) throw new Error(`잘못된 상태: ${patch.status}`);
+    if (patch.disposition !== undefined && !['move', 'known-issue', 'block'].includes(patch.disposition)) throw new Error(`잘못된 처분: ${patch.disposition}`);
+    const fields = (['evidence', 'owner', 'status', 'disposition'] as const).filter((field) => patch[field] !== undefined && patch[field] !== item[field]);
+    if (fields.length === 0) return false;
+    const at = new Date().toISOString();
+    for (const field of fields) {
+      const from = item[field];
+      const to = patch[field]!;
+      (item as unknown as Record<string, unknown>)[field] = to;
+      item.updatedAt = at;
+      item.updatedBy = by;
+      change(data, id, field, from, to, by, at);
+    }
+    return true;
+  });
+}
+
+export function removeItem(v: string, id: string, by: string): Checklist {
+  return mutate(v, (data) => {
+    const index = data.items.findIndex((i) => i.id === id);
+    if (index < 0) throw new Error(`없는 칸: ${id}`);
+    const at = new Date().toISOString();
+    const [item] = data.items.splice(index, 1);
+    change(data, id, 'remove', item, null, by, at);
+    return true;
+  });
+}
+
+export function summarize(v: string): ChecklistSummary {
+  return summarizeChecklist(listChecklist(v));
+}
+
+export interface ChecklistSummary { green: number; yellow: number; red: number; done: number; blocked: string[]; byOwner: Record<string, number> }
+
+export function summarizeChecklist(data: Checklist): ChecklistSummary {
+  const summary = { green: 0, yellow: 0, red: 0, done: 0, blocked: [] as string[], byOwner: Object.create(null) as Record<string, number> };
+  for (const item of data.items) {
+    summary[item.status]++;
+    if (item.status === 'red') summary.blocked.push(item.id);
+    const owner = item.owner ?? 'unassigned';
+    summary.byOwner[owner] = (summary.byOwner[owner] ?? 0) + 1;
+  }
+  return summary;
+}
+
+export interface ChecklistGate {
+  ok: boolean;
+  red: string[];
+  undecided: string[];
+  blocked: string[];
+  moved: string[];
+  knownIssues: Array<{ id: string; title: string; evidence: string }>;
+}
+
+export function checklistGate(v: string): ChecklistGate {
+  const result: ChecklistGate = { ok: true, red: [], undecided: [], blocked: [], moved: [], knownIssues: [] };
+  for (const item of listChecklist(v).items) {
+    if (item.status === 'red') result.red.push(item.id);
+    if (item.status !== 'yellow') continue;
+    if (item.disposition === 'block') result.blocked.push(item.id);
+    else if (item.disposition === 'move') result.moved.push(item.id);
+    else if (item.disposition === 'known-issue') result.knownIssues.push({ id: item.id, title: item.title, evidence: item.evidence ?? '' });
+    else result.undecided.push(item.id);
+  }
+  result.ok = result.red.length === 0 && result.undecided.length === 0 && result.blocked.length === 0;
+  return result;
+}
+
+export function seedFromRoadmap(v: string, markdown: string): Checklist {
+  return mutate(v, (data) => {
+    let added = false;
+    for (const line of markdown.split('\n')) {
+      const match = /^\|\s*(K\d+[a-z]?[′']?)\s*\|\s*(.*?)\s*\|\s*(.*?)\s*\|/.exec(line);
+      if (!match || data.items.some((i) => i.id === match[1])) continue;
+      const id = match[1]!;
+      const title = match[2]!;
+      const icon = match[3]!.trim();
+      const status: ChecklistStatus = icon.startsWith('🟢') ? 'green' : icon.startsWith('🔴') ? 'red' : icon.startsWith('✅') ? 'done' : 'yellow';
+      const at = new Date().toISOString();
+      const by = process.env.ELANOUS_TRACK || 'cli';
+      const item: ChecklistItem = { id, title, status, updatedAt: at, updatedBy: by };
+      data.items.push(item);
+      change(data, id, 'add', null, item, by, at);
+      added = true;
+    }
+    return added;
+  });
+}

package/src/release-loop/release-note.ts

@@ -30,9 +30,10 @@ function blankFencedCode(text: string): string {
 
 export function parseReleaseNoteSection(rawPrBody: string): { fragment?: Section; problems: string[] } {
   const prBody = blankFencedCode(rawPrBody);
-  const start = /^## 릴리스 노트[ \t]*\r?$/m.exec(prBody);
+  const sections = [...prBody.matchAll(/^## 릴리스 노트[ \t]*\r?$/gm)];
+  const start = sections.at(-1);
   if (!start) return { problems: [] };
-  const rest = prBody.slice(start.index + start[0].length).replace(/^\r?\n/, '');
+  const rest = prBody.slice(start.index! + start[0].length).replace(/^\r?\n/, '');
   const nextHeading = /^ {0,3}#{1,6}(?:[ \t]+|$)/m.exec(rest);
   const body = nextHeading ? rest.slice(0, nextHeading.index) : rest;
   const fields = new Map<string, string>();
@@ -51,7 +52,9 @@ export function parseReleaseNoteSection(rawPrBody: string): { fragment?: Section
   if (duplicates.has('종류') || !kind || !['fix', 'feat', 'security', 'internal'].includes(kind)) problems.push('종류');
   if (duplicates.has('문서') || !doc || (doc.startsWith('없음') ? !/^없음\([^\s()]+(?:[^()]*)\)$/.test(doc) : !/^\S+$/.test(doc))) problems.push('문서');
   if (duplicates.has('대상') || (target !== 'next' && target !== 'later')) problems.push('대상');
-  if (problems.length) return { problems };
+  const invalid = problems.length > 0;
+  if (sections.length > 1) problems.push(`multiple release-note sections (${sections.length}); using the last`);
+  if (invalid) return { problems };
   return {
     fragment: {
       line: line!, kind: kind as Section['kind'],

package/src/seat-address/seat-address.ts

@@ -0,0 +1,34 @@
+import trackData from '../../scripts/coord-tracks.json';
+
+export type SeatEntry = {
+  id: string;
+  title?: string;
+  alias?: string;
+};
+
+export type SeatAddress = { seats: string[]; body: string };
+
+const registry: readonly SeatEntry[] = trackData.tracks.filter((entry) => 'title' in entry);
+const addressLine = /^@([A-Za-z][A-Za-z0-9_-]*(?:,[A-Za-z][A-Za-z0-9_-]*)*)(?:[ \t]+|\r?\n|(?![\s\S]))/gm;
+
+/** Parse an address only when its @ begins a line; leave the instruction text intact. */
+export function parseSeatAddress(text: string): SeatAddress | null {
+  const match = addressLine.exec(text);
+  addressLine.lastIndex = 0;
+  if (!match) return null;
+
+  const seats = match[1]!.split(',');
+  const body = `${text.slice(0, match.index)}${text.slice(match.index + match[0].length)}`;
+  return { seats, body };
+}
+
+/** Resolve against the seat registry, preferring titles to ids to legacy aliases. */
+export function resolveSeat(address: string, seats: readonly SeatEntry[] = registry): SeatEntry | undefined {
+  const needle = address.replace(/^@/, '').toLocaleLowerCase();
+  if (!needle) return undefined;
+  for (const field of ['title', 'id', 'alias'] as const) {
+    const found = seats.find((seat) => seat[field]?.toLocaleLowerCase() === needle);
+    if (found) return found;
+  }
+  return undefined;
+}

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

@@ -45,6 +45,7 @@ import { getUserConfig, type UserConfig } from '../user-config.js';
 import { resolveChildLlmPreference, type ChildLlmPreferenceInput, type ResolvedChildLlmPreference } from '../self-implement/child-llm-preference.js';
 import { readCachedGrokQuota } from '../oauth/codex-account-store.js';
 import { queryAbandonedDraftPrs, type AbandonedDraftPr } from '../cli/logs-abandoned-draft-prs.js';
+import { branchLineageSlug } from '../cli/pr-lineage.js';
 import { decideDraft, type DraftTriagePr } from './draft-triage-rules.js';
 import { resolveLogTargets } from '../cli/logs-cli.js';
 import { LogStore } from '../mss/logging/log-store.js';
@@ -196,12 +197,12 @@ export interface DevSelfRunExecution {
 
 interface DraftTriage {
   closed: number[];
-  kept: number | null;
+  kept: number[] | null;
   closeFailed: number[];
   skippedNotDraft: number[];
 }
 
-export type DraftPrViewState = { isDraft: boolean; state: string } | null;
+export type DraftPrViewState = { isDraft: boolean; state: string; headRefName?: string } | null;
 
 export interface DraftPrInventory {
   readonly open: readonly (DraftTriagePr & { url: string; openedAtMs: number; runId?: string | null })[];
@@ -294,11 +295,13 @@ function defaultViewDraftPr(prUrl: string, timeoutMs?: number): DraftPrViewState
   if (IN_TEST_PROCESS()) return null;
   const target = draftPrTargetFromUrl(prUrl);
   if (!target) return null;
-  const view = spawnSync('gh', ['pr', 'view', String(target.number), '--repo', target.repository, '--json', 'isDraft,state'], { encoding: 'utf8', ...(timeoutMs === undefined ? {} : { timeout: timeoutMs }) });
+  const view = spawnSync('gh', ['pr', 'view', String(target.number), '--repo', target.repository, '--json', 'isDraft,state,headRefName'], { encoding: 'utf8', ...(timeoutMs === undefined ? {} : { timeout: timeoutMs }) });
   if (view.status !== 0) return null;
   try {
-    const parsed = JSON.parse(view.stdout) as { isDraft?: unknown; state?: unknown };
-    return typeof parsed.isDraft === 'boolean' && typeof parsed.state === 'string' ? { isDraft: parsed.isDraft, state: parsed.state } : null;
+    const parsed = JSON.parse(view.stdout) as { isDraft?: unknown; state?: unknown; headRefName?: unknown };
+    return typeof parsed.isDraft === 'boolean' && typeof parsed.state === 'string'
+      ? { isDraft: parsed.isDraft, state: parsed.state, ...(typeof parsed.headRefName === 'string' ? { headRefName: parsed.headRefName } : {}) }
+      : null;
   } catch {
     return null;
   }
@@ -946,41 +949,58 @@ export async function executeDevSelfRun(
     const view = supervise?.viewDraftPr ?? defaultViewDraftPr;
     const closeDraft = supervise?.closeDraftPr ?? defaultCloseDraftPr;
     const commentDraft = supervise?.commentDraftPr ?? defaultCommentDraftPr;
-    const openDrafts: string[] = [];
+    const openDrafts: Array<{ url: string; lineage: string | null }> = [];
     const skippedNotDraft: number[] = [];
     for (const prUrl of drafts) {
       let live: DraftPrViewState = null;
       try { live = view(prUrl); } catch { live = null; }
-      if (live?.isDraft === true && live.state === 'OPEN') openDrafts.push(prUrl);
-      else {
+      if (live?.isDraft === true && live.state === 'OPEN') {
+        openDrafts.push({ url: prUrl, lineage: live.headRefName ? branchLineageSlug(live.headRefName) : null });
+      } else {
         const number = prNumberFromUrl(prUrl);
         if (number !== null) skippedNotDraft.push(number);
       }
     }
-    const keptUrl = converged ? undefined : openDrafts.at(-1);
-    const kept = keptUrl === undefined ? null : prNumberFromUrl(keptUrl);
+    const keptByLineage = new Map<string, string>();
+    if (!converged) {
+      for (const draft of openDrafts) {
+        if (draft.lineage !== null) keptByLineage.set(draft.lineage, draft.url);
+      }
+    }
+    const keptDrafts = converged ? [] : openDrafts.filter(({ url, lineage }) => lineage === null || keptByLineage.get(lineage) === url);
+    const kept = keptDrafts.length === 0 ? null : keptDrafts.flatMap(({ url }) => {
+      const number = prNumberFromUrl(url);
+      return number === null ? [] : [number];
+    });
     const closed: number[] = [];
     const closeFailed: number[] = [];
     const landed = mergedNumbers.map((n) => `#${n}`).join(' ') || '없음';
-    for (const prUrl of openDrafts) {
-      if (prUrl === keptUrl) continue;
-      const number = prNumberFromUrl(prUrl);
+    for (const { url, lineage } of openDrafts) {
+      if (!converged && (lineage === null || keptByLineage.get(lineage) === url)) continue;
+      const number = prNumberFromUrl(url);
+      const keptInLineage = lineage === null ? null : prNumberFromUrl(keptByLineage.get(lineage)!);
       const comment = converged
         ? `하니스 종결 트리아지: 이 런이 수렴해 대체됨 — 착지 ${landed}`
-        : `하니스 종결 트리아지: 최신 산출 #${kept ?? 'unknown'} 로 대체됨`;
+        : `하니스 종결 트리아지: 최신 산출 #${keptInLineage ?? 'unknown'} 로 대체됨`;
       let ok = false;
-      try { ok = closeDraft(prUrl, comment); } catch { ok = false; }
+      try { ok = closeDraft(url, comment); } catch { ok = false; }
       if (number === null) continue;
       if (ok) closed.push(number);
       else closeFailed.push(number);
     }
-    if (keptUrl !== undefined) {
+    for (const { url, lineage } of keptDrafts) {
+      const keptLineage = [...keptByLineage.keys()].find((other) => other !== lineage);
+      if (lineage !== null && keptLineage !== undefined) {
+        try { debug.log('self-dev.triage', 'kept-distinct-piece', { pr: prNumberFromUrl(url), lineage, keptLineage }); } catch { /* fail-open */ }
+      }
       const rounds = Math.max(1, executedRounds);
-      const handoff = closeFailed.length === 0
-        ? '이 draft 가 이 골의 유일한 사람 판단 대상'
-        : `닫지 못한 draft 도 남아 있다: ${closeFailed.map((n) => `#${n}`).join(' ')}`;
+      const handoff = closeFailed.length > 0
+        ? `닫지 못한 draft 도 남아 있다: ${closeFailed.map((n) => `#${n}`).join(' ')}`
+        : lineage === null ? '브랜치 계보 미확인 — 사람 판단 대상'
+          : keptDrafts.length === 1 ? '이 draft 가 이 골의 유일한 사람 판단 대상'
+            : '이 draft 가 이 계보의 사람 판단 대상';
       const comment = `하니스 종결 트리아지: 멈춘 사유 ${supervisorStopReason ?? 'unsupervised'} · 라운드 ${rounds} · 착지한 조각 PR ${landed} · ${handoff}`;
-      try { commentDraft(keptUrl, comment); } catch { /* fail-open */ }
+      try { commentDraft(url, comment); } catch { /* fail-open */ }
     }
     draftTriage = { closed, kept, closeFailed, skippedNotDraft };
   };

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

@@ -15,8 +15,12 @@
 //   self 는 backend 리스트 항목이 아니라 transport 축을 붕괴시키는 특수 갈래. 감독 축도 self=turn 레벨.
 
 import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { readFileSync } from 'node:fs';
-import { appendEvidenceLocationRequirement, extractVerbatimOriginalAsk, formatGoalFileLintFinding, inspectAskDecisionSignalMarker, leadingGoalMetadata, lintGoalFile, parseGoalId, parseGoalType, SUPERSEDED_BY_LINE, type GoalFileLintFinding, type GoalFileLintResult } from '../self-implement/goal-author.js';
+import { dispatchTask, type DispatchTaskDeps } from '../execution-loop/dispatch-task.js';
+import { getNestDepth } from '../agent/nest-depth.js';
+import { appendRunLedgerEntry } from '../self-implement/run-ledger.js';
+import { appendEvidenceLocationRequirement, extractVerbatimOriginalAsk, formatGoalFileLintFinding, inspectAskDecisionSignalMarker, leadingGoalMetadata, lintGoalFile, parseGoalId, parseGoalType, tracedPathReferences, SUPERSEDED_BY_LINE, type GoalFileLintFinding, type GoalFileLintResult } from '../self-implement/goal-author.js';
 import { createRepositoryReferencedFileReader, type ReferencedFileReader } from '../self-implement/goal-file-reader.js';
 import { parseGoalDocumentClarifications } from '../self-implement/goal-author-clarification.js';
 import { requiredEvidenceFromGoal } from '../self-implement/off-diff-evidence.js';
@@ -55,6 +59,8 @@ export type OrchestrateRuntime = Omit<OrchestrateSelfDevOptions, 'goals' | 'conc
 export interface DevMissionOpts {
   chain?: readonly ('codex' | 'claude' | 'elanous')[];
   plugin?: { plugin: string; marketplace: string };
+  resources?: 'on' | 'off';
+  backendExplicit?: string;
   headless?: boolean;
   evidence?: EvidenceMode;
   maxRounds?: number;
@@ -619,6 +625,8 @@ export function toAgentMissionSpec(
     ...(m.headless === true ? { headless: true } : {}),
     ...(m.chain ? { chain: m.chain } : {}),
     ...(m.plugin ? { plugin: m.plugin } : {}),
+    ...(m.resources !== undefined ? { resources: m.resources } : {}),
+    ...(m.backendExplicit !== undefined ? { backendExplicit: m.backendExplicit } : {}),
     ...(plan.base ? { base: plan.base } : {}),
     ...(plan.enhance !== undefined ? { enhance: plan.enhance } : {}),
     ...(m.maxRounds !== undefined ? { maxRounds: m.maxRounds } : {}),
@@ -644,6 +652,8 @@ export function buildAgentMissionDevSpec(o: {
   headless?: boolean;
   chain?: readonly ('codex' | 'claude' | 'elanous')[];
   plugin?: { plugin: string; marketplace: string };
+  resources?: 'on' | 'off';
+  backendExplicit?: string;
   /** --no-enhance 시 false(그 외 미지정 → driver 가 entry 로 구동). */
   enhanceOff?: boolean;
   evidence: EvidenceMode;
@@ -663,6 +673,8 @@ export function buildAgentMissionDevSpec(o: {
       ...(o.headless === true ? { headless: true } : {}),
       ...(o.chain ? { chain: o.chain } : {}),
       ...(o.plugin ? { plugin: o.plugin } : {}),
+      ...(o.resources !== undefined ? { resources: o.resources } : {}),
+      ...(o.backendExplicit !== undefined ? { backendExplicit: o.backendExplicit } : {}),
       maxRounds: o.maxRounds,
       commit: o.commit,
       entry: 'elanous-apparatus',
@@ -918,6 +930,10 @@ export interface DevHarnessDispatchArgs extends Record<string, unknown> {
 }
 
 export interface DevPipelineDeps {
+  dispatchTask?: typeof dispatchTask;
+  dispatchTaskDeps?: DispatchTaskDeps;
+  /** Caller has already recorded this dispatch decision at an outer entrance. */
+  skipDispatchTask?: boolean;
   /** Caller-managed human progress sink (for example SurfaceUx.progress). Absent callers retain byte-for-byte CLI stdout. */
   progress?: SurfaceUx['progress'];
   runSelfImplement?: (o: SelfImplementOptions) => Promise<SelfImplementResult>;
@@ -1777,6 +1793,65 @@ export async function runDevPipeline(spec: DevPipelineSpec, deps: DevPipelineDep
   }
 }
 
+async function observeDevTaskDispatch(spec: DevPipelineSpec, plan: ResolvedDevPlan, deps: DevPipelineDeps): Promise<void> {
+  const skipped = plan.dispatch === 'interactive' && getNestDepth() > 0 ? 'nested-interactive'
+    : plan.relaunch === true ? 'relaunch'
+    : plan.dispatch === 'parallel' ? 'parallel-parent'
+    : deps.skipDispatchTask === true ? 'skipDispatchTask'
+    : process.env.ELANOUS_DISPATCH_RECORDED === '1' ? 'dispatch-recorded'
+    // `bun test` preload sets this so pipeline tests do not run the real gates (usage/recall
+    // lookups) on every launch; tests that inject a dispatcher or gates still observe.
+    : process.env.ELANOUS_EXECUTION_LOOP_DISPATCH === 'off' && !deps.dispatchTask && !deps.dispatchTaskDeps ? 'disabled'
+    : undefined;
+  if (skipped) {
+    try { debug.log('execution-loop.gate', 'dispatch-skipped', { reason: skipped, ...(spec.runId ? { runId: spec.runId } : {}) }); } catch { /* fail-soft */ }
+    return;
+  }
+  try {
+    const goalText = 'text' in plan.input ? plan.input.text : (deps.readFile ?? ((path: string) => readFileSync(path, 'utf8')))(plan.input.file);
+    const goalId = 'file' in plan.input ? parseGoalId(goalText) : null;
+    let recordedCardId: string | undefined;
+    const recordCard = (cardId: string): void => {
+      if (!spec.runId || recordedCardId) return;
+      recordedCardId = cardId;
+      try {
+        appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId: spec.runId,
+          event: 'execution-loop-card', data: { cardId } });
+      } catch (error) {
+        try { debug.log('execution-loop.gate', 'ledger-unavailable', { reason: String(error) }); } catch { /* fail-soft */ }
+      }
+    };
+    const dispatchDeps: DispatchTaskDeps = {
+      ...deps.dispatchTaskDeps,
+      onCardCreated: (cardId) => {
+        recordCard(cardId);
+        deps.dispatchTaskDeps?.onCardCreated?.(cardId);
+      },
+    };
+    const work = Promise.resolve().then(() => (deps.dispatchTask ?? dispatchTask)({
+      goalId: goalId ?? `request-${createHash('sha256').update(goalText).digest('hex').slice(0, 32)}`,
+      title: goalText.split(/\r?\n/, 1)[0]?.trim() || 'Untitled request',
+      goalText,
+      targetPaths: 'file' in plan.input ? tracedPathReferences(goalText).map((reference) => reference.path) : [],
+      spec,
+      ...(spec.runId ? { runKey: spec.runId } : {}),
+    }, dispatchDeps));
+    // The default dispatcher bounds its gates to five seconds. Await its completed
+    // observation so short-lived callers cannot exit before decisions reach the card.
+    // Injected dispatchers retain an outer timeout to protect the original launch.
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+    const result = await (deps.dispatchTask
+      ? Promise.race([
+          work,
+          new Promise<never>((_, reject) => { timeout = setTimeout(() => reject(new Error('dispatch timeout after 5000ms')), 5_000); }),
+        ]).finally(() => { if (timeout) clearTimeout(timeout); })
+      : work);
+    recordCard(result.cardId);
+  } catch (error) {
+    try { debug.log('execution-loop.gate', 'dispatch-unavailable', { reason: String(error) }); } catch { /* fail-soft */ }
+  }
+}
+
 async function runDevPipelineDispatch(
   spec: DevPipelineSpec,
   deps: DevPipelineDeps,
@@ -1785,6 +1860,7 @@ async function runDevPipelineDispatch(
 ): Promise<DevPipelineRunResult> {
   const plan = planDevPipeline(spec);
   seen.plan = plan;
+  await observeDevTaskDispatch(spec, plan, deps);
   if (!plan.wired) {
     throw new DevPipelineError(
       `runDevPipeline: '${plan.dispatch}' 경로는 U4 골격에서 미배선(NotYetUnified). ` +

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

@@ -682,7 +682,9 @@ function runIsolatedBunTest(cwd: string, args: string[], timeout: number): Proce
     return { status: null, stdout: '', stderr: message, error: error instanceof Error ? error : new Error(message) };
   }
   try {
-    return spawnSync('bun', ['test', ...args], { cwd, env: isolated.env, encoding: 'utf8', timeout, maxBuffer: 32 * 1024 * 1024 });
+    // SIGKILL — a test that traps SIGTERM while blocked in a native wait never runs its handler, so spawnSync
+    // waited forever and its drive grandchildren lived on as ppid=1 orphans (09-30 O1: 19 processes, up to 11h).
+    return spawnSync('bun', ['test', ...args], { cwd, env: isolated.env, encoding: 'utf8', timeout, killSignal: 'SIGKILL', maxBuffer: 32 * 1024 * 1024 });
   } finally {
     isolated.cleanup();
   }

package/src/self-implement/goal-author.ts

@@ -32,6 +32,7 @@ import { quoteShellArg } from '../cli/logs-cli.js';
 import type { HarnessGroundingProvenance } from './context-capsule.js';
 import { hasGoalStepCodeName } from './goal-step-code-name.js';
 import { targetScopedGoalText } from './goal-text-path-scope.js';
+import { parseReleaseNoteSection } from '../release-loop/release-note.js';
 
 // ⭐ `situation`/`complication` 은 **선택**이다 — 안 오면 `scqaNarrative` 가 종전 문면을 쓴다.
 //   ⛔ 필수로 만들지 않는다: 그러면 인핸싱이 폴백으로 떨어진 저작(LLM 실패·`disabled`)이 전부 죽는다.
@@ -334,7 +335,7 @@ function endGoalAuthorPhase(phase: GoalAuthorTimedPhase, startedAt: number, auth
 
 export type GoalFileLintLevel = 'ERROR' | 'WARN';
 
-export type GoalFileLintTag = 'canonical-structure' | 'evidence-section' | 'boundary-size' | 'launch-branch' | 'unanswered-clarification' | 'shell-damage' | 'traced-path' | 'grounding-evidence' | 'empty-result-population' | 'decision-signal-numeric-source' | 'decision-signal-numeric-coverage' | 'decision-signal-proxy-expectation' | 'out-of-target-requirement' | 'heading-form-marker' | 'blanket-invariant' | 'self-question-subject' | 'artifact-launch-declaration' | 'all-negative-signals' | 'unreadable-signals' | 'alternative-signals' | 'count-observation' | 'identifier-name-observation' | 'self-reported-observation' | 'default-invocation-observation';
+export type GoalFileLintTag = 'canonical-structure' | 'evidence-section' | 'boundary-size' | 'launch-branch' | 'unanswered-clarification' | 'shell-damage' | 'traced-path' | 'grounding-evidence' | 'empty-result-population' | 'decision-signal-numeric-source' | 'decision-signal-numeric-coverage' | 'decision-signal-proxy-expectation' | 'out-of-target-requirement' | 'heading-form-marker' | 'blanket-invariant' | 'self-question-subject' | 'artifact-launch-declaration' | 'all-negative-signals' | 'unreadable-signals' | 'alternative-signals' | 'count-observation' | 'identifier-name-observation' | 'self-reported-observation' | 'default-invocation-observation' | 'release-note';
 
 type GoalFileLintOrigin =
   | { readonly kind: 'known-incident'; readonly incident: string; readonly reference: string }
@@ -369,6 +370,7 @@ export const GOAL_FILE_LINT_ORIGINS: Record<GoalFileLintTag, GoalFileLintOrigin>
   'identifier-name-observation': { kind: 'known-incident', incident: "an authored observation of 'the list of test names this file registers' produced a test that greps its own source for test-name strings, which passes with every named test body emptied; 59 of 3164 goal documents carried the same wording", reference: 'PR #15791 (closed; superseded by #15802); docs/harness/observability/ISSUES.md OBS-T415' },
   'self-reported-observation': { kind: 'known-incident', incident: "an authored observation of 'the captureScope field of the emitted JSON' stayed green across two failed implementations: a Chrome CLI flag Chrome silently ignores (capture stayed 1280x900 against a true 4651) and a CDP call that timed out leaving no file at all, both of which still emitted captureScope:'full-page'", reference: 'docs/manual/MANUAL-web-clone-to-reproducible-resource-2026-09-08.md section 6b; PR #16201; measured 2026-09-08: 190 of 2867 goal documents that carry a decision signal match this shape, three times the 63 that match identifier-name-observation' },
   'default-invocation-observation': { kind: 'known-incident', incident: 'a scripts/*.ts checker landed green from fixture tests and, run once with no arguments from the repository root, reported covered 1 and uncovered 22 because its default catalog path never opened the map the goal named', reference: 'PR #19126; measured 2026-09-20 against the same-day controls #19123 and #19127' },
+  'release-note': { kind: 'unknown-origin', label: 'ORIGIN-UNKNOWN' },
 } as const satisfies Record<GoalFileLintTag, GoalFileLintOrigin>;
 
 /** Machine-countable reason for a finding that retains the canonical-structure tag. */
@@ -1452,6 +1454,21 @@ export function lintGoalFile(document: string, branch: string, deps: GoalFileLin
   for (const finding of askSectionCountLintFindings(document)) findings.push(finding);
   for (const finding of headingFormMarkerLintFindings(document)) findings.push(finding);
   for (const finding of blanketInvariantLintFindings(document)) findings.push(finding);
+  const releaseNote = parseReleaseNoteSection(document);
+  for (const problem of releaseNote.problems) {
+    findings.push({
+      level: 'WARN', tag: 'release-note',
+      message: `## 릴리스 노트 ${problem} invalid or missing; use - 한 줄: English summary, - 종류: feat|fix|security|internal (feature → feat), - 문서: path or 없음(이유), - 대상: next|later`,
+    });
+  }
+  if (releaseNote.fragment || releaseNote.problems.length) {
+    const section = markdownSection(document, '릴리스 노트') ?? '';
+    const kind = releaseNote.fragment?.kind ?? /^[ \t]*- 종류:[ \t]*(.*?)[ \t]*$/m.exec(section)?.[1];
+    const line = releaseNote.fragment?.line ?? /^[ \t]*- 한 줄:[ \t]*(.*?)[ \t]*$/m.exec(section)?.[1];
+    if (kind && ['feat', 'fix', 'security'].includes(kind) && line && /[가-힣ㄱ-ㅎㅏ-ㅣ]/u.test(line)) {
+      findings.push({ level: 'WARN', tag: 'release-note', message: '## 릴리스 노트 한 줄: 공개 노트에 실리는 문장은 영어로(internal 은 한국어 무방)' });
+    }
+  }
   for (const violation of selfQuestionSubjectViolations) {
     findings.push({
       level: 'WARN',

package/src/self-implement/host-regate.ts

@@ -27,9 +27,13 @@ export type HostRegateDeps = {
   log?: (event: 'passed' | 'failed' | 'unmeasured' | 'base-raced', data: Record<string, unknown>) => void;
 };
 
+const SPAWN_MAX_BUFFER = 256 * 1024 * 1024;
+
 const defaultCommand: NonNullable<HostRegateDeps['command']> = (bin, args, cwd, env) => {
-  const r = spawnSync(bin, [...args], { cwd, env: env ?? process.env, encoding: 'utf8', timeout: 600_000 });
-  return { status: r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + (r.error ? `${r.error.message} (command unavailable)` : '') };
+  // bun ≥1.4 applies Node's 1MB default maxBuffer and silently truncates — test output here is often larger.
+  const r = spawnSync(bin, [...args], { cwd, env: env ?? process.env, encoding: 'utf8', timeout: 600_000, maxBuffer: SPAWN_MAX_BUFFER });
+  const overflow = (r.error as NodeJS.ErrnoException | undefined)?.code === 'ENOBUFS';
+  return { status: overflow ? null : r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + (r.error ? `${r.error.message} (${overflow ? `output exceeded ${SPAWN_MAX_BUFFER} bytes` : 'command unavailable'})` : '') };
 };
 
 /** The informational pr-land gate always returns zero; enforce its measured report and the combined test result instead. */

package/src/self-implement/orchestrator.ts

@@ -3307,9 +3307,14 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
   if (opts.childLlm && (typeof opts.childLlm.provider !== 'string' || !opts.childLlm.provider.trim() || typeof opts.childLlm.model !== 'string' || !opts.childLlm.model.trim())) {
     throw new Error('childLlm.provider and childLlm.model must both be non-empty');
   }
-  const branch = opts.branchName ?? plannedSelfImplBranch(opts.feature, opts.goalId);
   const identity = resolveRunIdentity({ explicit: opts.runId });
   const { runId } = identity;
+  const branch = opts.branchName ?? plannedSelfImplBranch(opts.feature, opts.goalId, runId);
+  try {
+    debug.log('self-implement.branch', 'planned', {
+      runId, goalId: opts.goalId, branch, runSuffix: opts.branchName === undefined ? branch.match(/-r[a-z0-9]{6}$/)?.[0] ?? null : null,
+    });
+  } catch { /* observation must not block the run */ }
   const attemptOrdinal = incrementRunAttemptOrdinal(runId);
   const shardIdentity = parseRunShardIdentity(opts.feature);
   const observeOuter = makeRunObserver(runId, opts.goalId, debug.log.bind(debug), opts.seams.writeRunLedger, shardIdentity);
@@ -4517,8 +4522,8 @@ async function runSelfImplementInner(
     roundClassifications.push(classification);
     onRoundClassification(classification);
   };
-  const branch = opts.branchName ?? plannedSelfImplBranch(opts.feature, opts.goalId);
   const { runId, source: runIdSource } = identity ?? resolveRunIdentity({ explicit: opts.runId });
+  const branch = opts.branchName ?? plannedSelfImplBranch(opts.feature, opts.goalId, runId);
   try {
     debug.log('run-identity', 'own', {
       runId, branch, source: runIdSource, nestDepth: nestInfo().depth, ...originObservationFields(),

package/src/self-implement/run-ledger-compact.ts

@@ -280,7 +280,7 @@ function recordedString(entries: readonly RunLedgerEntry[], field: string): stri
   return undefined;
 }
 
-function summarizeTerminalLedger(runId: string, entries: readonly RunLedgerEntry[]): RunLedgerSummary {
+export function summarizeTerminalLedger(runId: string, entries: readonly RunLedgerEntry[]): RunLedgerSummary {
   const last = entries.at(-1)?.timestamp;
   if (!last || !Number.isFinite(Date.parse(last)) || !hasTerminalRunStatus(entries)) throw new Error('ledger changed since plan');
   const terminator = [...entries].reverse().find((entry) => entry.event === 'human-stop' || entry.event === 'terminal'