elanous 0.2.36 → 0.2.37

package/scripts/goals/authoring-metrics.ts

@@ -1,4 +1,12 @@
 #!/usr/bin/env bun
+/**
+ * GOAL-BENCH-FU — 열 과제×세 경로(문면·구체화·구현 결과) 결과표와 절차 삭제 후보.
+ *
+ *   bun scripts/goals/authoring-metrics.ts --records <ledger.json|ledger.jsonl> [--json]
+ *
+ * 레코드 = { task, path, landed, rounds, procedureSteps }. `--records` 가 없으면 기존 측정 모드
+ * (경로 인자 · chars/bytes/sections/marker)가 그대로 돈다 — 표 형식·요약 JSON 불변.
+ */
 import { readFileSync } from 'node:fs';
 import { inspectAskMarkers } from '../ask-marker-check.js';
 
@@ -35,7 +43,257 @@ export function median(numbers: readonly number[]): number | null {
     : (sorted[middle - 1]! + sorted[middle]!) / 2;
 }
 
+/** 골이 지나는 세 경로 — 문면(text) · 구체화(elaboration) · 구현 결과(implementation). */
+export type AuthoringPath = 'text' | 'elaboration' | 'implementation';
+
+const AUTHORING_PATHS: readonly AuthoringPath[] = ['text', 'elaboration', 'implementation'];
+
+export interface AuthoringRecord {
+  readonly task: string;
+  readonly path: AuthoringPath;
+  /** 그 과제가 그 경로에서 착지했나. */
+  readonly landed: boolean;
+  /** 착지까지 든 라운드 수. */
+  readonly rounds: number;
+  /** 그 경로에서 실제로 밟은 절차 단계 — 삭제 후보 판정의 입력. */
+  readonly procedureSteps: readonly string[];
+}
+
+export interface PathCell {
+  readonly path: AuthoringPath;
+  readonly landed: number;
+  readonly total: number;
+  /** 착지율 0~1. 레코드가 없으면 null. */
+  readonly groundingRate: number | null;
+  /** 평균 라운드. 레코드가 없으면 null. */
+  readonly rounds: number | null;
+}
+
+export interface ResultRow {
+  readonly task: string;
+  /** buildResultTable 의 columns 와 같은 순서. 그 경로 레코드가 없으면 total 0 셀. */
+  readonly cells: readonly PathCell[];
+}
+
+export interface ResultTable {
+  readonly columns: readonly AuthoringPath[];
+  readonly rows: readonly ResultRow[];
+  readonly summary: readonly PathCell[];
+}
+
+export interface DeletionCandidate {
+  readonly step: string;
+  readonly withGroundingRate: number | null;
+  readonly withoutGroundingRate: number | null;
+  readonly withRounds: number | null;
+  readonly withoutRounds: number | null;
+  readonly withSamples: number;
+  readonly withoutSamples: number;
+  readonly reason: string;
+}
+
+export function computeGroundingRate(records: readonly AuthoringRecord[]): number | null {
+  if (records.length === 0) return null;
+  return records.filter((record) => record.landed).length / records.length;
+}
+
+function meanRounds(records: readonly AuthoringRecord[]): number | null {
+  if (records.length === 0) return null;
+  return records.reduce((sum, record) => sum + record.rounds, 0) / records.length;
+}
+
+function cellFor(path: AuthoringPath, records: readonly AuthoringRecord[]): PathCell {
+  return {
+    path,
+    landed: records.filter((record) => record.landed).length,
+    total: records.length,
+    groundingRate: computeGroundingRate(records),
+    rounds: meanRounds(records),
+  };
+}
+
+/** 행 = 과제, 열 = 경로, 셀 = 착지율·라운드. summary 는 경로별 전체 집계다. */
+export function buildResultTable(records: readonly AuthoringRecord[]): ResultTable {
+  const columns = AUTHORING_PATHS.filter((path) => records.some((record) => record.path === path));
+  const tasks: string[] = [];
+  for (const record of records) if (!tasks.includes(record.task)) tasks.push(record.task);
+  return {
+    columns,
+    rows: tasks.map((task) => ({
+      task,
+      cells: columns.map((path) =>
+        cellFor(path, records.filter((record) => record.task === task && record.path === path))),
+    })),
+    summary: columns.map((path) => cellFor(path, records.filter((record) => record.path === path))),
+  };
+}
+
+/**
+ * 그 단계를 밟은 레코드가 «안 밟은 레코드보다» 착지율이 높지도 않고 라운드도 줄이지 못하면 삭제 후보다.
+ * 대조군이 없는 단계(모든 레코드가 밟음)는 판정할 근거가 없으므로 후보로 올리지 않는다.
+ */
+export function findDeletionCandidates(records: readonly AuthoringRecord[]): readonly DeletionCandidate[] {
+  const steps = [...new Set(records.flatMap((record) => record.procedureSteps))].sort();
+  const candidates: DeletionCandidate[] = [];
+  for (const step of steps) {
+    const withStep = records.filter((record) => record.procedureSteps.includes(step));
+    const withoutStep = records.filter((record) => !record.procedureSteps.includes(step));
+    if (withStep.length === 0 || withoutStep.length === 0) continue;
+    const withGroundingRate = computeGroundingRate(withStep);
+    const withoutGroundingRate = computeGroundingRate(withoutStep);
+    const withRounds = meanRounds(withStep);
+    const withoutRounds = meanRounds(withoutStep);
+    if (withGroundingRate === null || withoutGroundingRate === null) continue;
+    if (withRounds === null || withoutRounds === null) continue;
+    if (withGroundingRate > withoutGroundingRate) continue;
+    if (withRounds < withoutRounds) continue;
+    candidates.push({
+      step,
+      withGroundingRate,
+      withoutGroundingRate,
+      withRounds,
+      withoutRounds,
+      withSamples: withStep.length,
+      withoutSamples: withoutStep.length,
+      reason: `착지율 ${formatPercent(withGroundingRate)} ≤ ${formatPercent(withoutGroundingRate)}`
+        + ` · 라운드 ${withRounds.toFixed(1)} ≥ ${withoutRounds.toFixed(1)}`,
+    });
+  }
+  return candidates.sort((a, b) =>
+    (b.withRounds! - b.withoutRounds!) - (a.withRounds! - a.withoutRounds!)
+    || (a.withGroundingRate! - b.withGroundingRate!)
+    || a.step.localeCompare(b.step));
+}
+
+function formatPercent(rate: number | null): string {
+  return rate === null ? '—' : `${(rate * 100).toFixed(1)}%`;
+}
+
+function formatRounds(rounds: number | null): string {
+  return rounds === null ? '—' : rounds.toFixed(1);
+}
+
+function formatCell(cell: PathCell): string {
+  if (cell.total === 0) return '—';
+  return `${formatPercent(cell.groundingRate)}/${formatRounds(cell.rounds)}`;
+}
+
+export function renderResultTable(table: ResultTable): string {
+  const lines = [`task\t${table.columns.join('\t')}`];
+  for (const row of table.rows) lines.push(`${row.task}\t${row.cells.map(formatCell).join('\t')}`);
+  lines.push(`summary\t${table.summary.map(formatCell).join('\t')}`);
+  return lines.join('\n');
+}
+
+export function renderDeletionCandidates(candidates: readonly DeletionCandidate[]): string {
+  if (candidates.length === 0) return 'candidates\tnone';
+  const lines = ['step\twith.landing\twithout.landing\twith.rounds\twithout.rounds\tsamples'];
+  for (const candidate of candidates) {
+    lines.push([
+      candidate.step,
+      formatPercent(candidate.withGroundingRate),
+      formatPercent(candidate.withoutGroundingRate),
+      formatRounds(candidate.withRounds),
+      formatRounds(candidate.withoutRounds),
+      `${candidate.withSamples}/${candidate.withoutSamples}`,
+    ].join('\t'));
+  }
+  return lines.join('\n');
+}
+
+export type ParsedRecords =
+  | { readonly ok: true; readonly records: readonly AuthoringRecord[] }
+  | { readonly ok: false; readonly error: string };
+
+function parseRecord(entry: unknown): AuthoringRecord | string {
+  if (typeof entry !== 'object' || entry === null) return 'is not an object';
+  const value = entry as Record<string, unknown>;
+  if (typeof value.task !== 'string' || value.task.trim() === '') return 'task must be a non-empty string';
+  if (!AUTHORING_PATHS.includes(value.path as AuthoringPath)) {
+    return `path must be one of ${AUTHORING_PATHS.join('|')}`;
+  }
+  if (typeof value.landed !== 'boolean') return 'landed must be a boolean';
+  if (typeof value.rounds !== 'number' || !Number.isFinite(value.rounds) || value.rounds < 0) {
+    return 'rounds must be a finite number >= 0';
+  }
+  const steps = value.procedureSteps;
+  if (steps !== undefined && (!Array.isArray(steps)
+    || steps.some((step) => typeof step !== 'string' || step.trim() === ''))) {
+    return 'procedureSteps must be an array of non-empty strings';
+  }
+  return {
+    task: value.task,
+    path: value.path as AuthoringPath,
+    landed: value.landed,
+    rounds: value.rounds,
+    procedureSteps: (steps ?? []) as readonly string[],
+  };
+}
+
+/** JSON 배열 한 덩어리 또는 JSON Lines(원장 한 줄 = 레코드 하나) 둘 다 받는다. */
+export function parseRecords(text: string): ParsedRecords {
+  const trimmed = text.trim();
+  if (trimmed === '') return { ok: true, records: [] };
+  const entries: unknown[] = [];
+  if (trimmed.startsWith('[')) {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return { ok: false, error: 'records ledger is not valid JSON' };
+    }
+    if (!Array.isArray(parsed)) return { ok: false, error: 'records must be a JSON array or JSON Lines' };
+    entries.push(...parsed);
+  } else {
+    for (const [index, line] of trimmed.split(/\r?\n/).entries()) {
+      if (line.trim() === '') continue;
+      try {
+        entries.push(JSON.parse(line) as unknown);
+      } catch {
+        return { ok: false, error: `line ${index + 1} is not valid JSON` };
+      }
+    }
+  }
+  const records: AuthoringRecord[] = [];
+  for (const [index, entry] of entries.entries()) {
+    const parsed = parseRecord(entry);
+    if (typeof parsed === 'string') return { ok: false, error: `record ${index + 1}: ${parsed}` };
+    records.push(parsed);
+  }
+  return { ok: true, records };
+}
+
+function printRecordsLedger(argv: readonly string[]): number {
+  const file = argv[argv.indexOf('--records') + 1];
+  if (file === undefined || file.startsWith('--')) {
+    console.error('authoring-metrics: --records needs a ledger path');
+    return 2;
+  }
+  let text: string;
+  try {
+    text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(readFileSync(file));
+  } catch {
+    console.error(`authoring-metrics: unreadable records ledger: ${file}`);
+    return 1;
+  }
+  const parsed = parseRecords(text);
+  if (!parsed.ok) {
+    console.error(`authoring-metrics: ${parsed.error}`);
+    return 1;
+  }
+  const table = buildResultTable(parsed.records);
+  const candidates = findDeletionCandidates(parsed.records);
+  if (argv.includes('--json')) {
+    console.log(JSON.stringify({ columns: table.columns, rows: table.rows, summary: table.summary, candidates }));
+  } else {
+    console.log(renderResultTable(table));
+    console.log(renderDeletionCandidates(candidates));
+  }
+  return 0;
+}
+
 function main(argv: readonly string[]): number {
+  if (argv.includes('--records')) return printRecordsLedger(argv);
   const json = argv.includes('--json');
   const paths = argv.filter((argument) => argument !== '--json');
   const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });

package/scripts/graph-units/draft-close-node.ts

@@ -0,0 +1,222 @@
+import { readFileSync } from 'node:fs';
+import { PROTECTED_LABELS, decideDraft, type DraftTriagePr } from '../../src/self-dev/draft-triage-rules.js';
+
+type Json = Record<string, unknown>;
+type DraftCloseKind = 'harvest' | 'close-candidate' | 'hold';
+type DraftCloseOutcome = DraftCloseKind | 'failed';
+const DRAFT_CLOSE_PROTECTED_LABELS = new Set([...PROTECTED_LABELS, 'elanous:running', 'elanous:claim', 'elanous:harvest-claimed']);
+
+interface DraftCloseRow extends Json {
+  mapRunId: string | null;
+  snapshotTime: string | null;
+  inventoryComplete: boolean;
+  pr: number | null;
+  headOid: string | null;
+  kind: DraftCloseKind;
+  classification: string;
+  reason: string;
+  replacement: number | null;
+  protectedReason: string | null;
+  evidence: string[];
+  writes: readonly [];
+}
+
+interface DraftCloseDecision {
+  outcome: DraftCloseOutcome;
+  result: DraftCloseRow;
+  evidence: Json;
+}
+
+function record(value: unknown): Json {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Json : {};
+}
+
+function string(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function strings(value: unknown): string[] | undefined {
+  return Array.isArray(value) && value.every((item) => typeof item === 'string') ? value as string[] : undefined;
+}
+
+function row(input: {
+  mapRunId?: string;
+  snapshotTime?: string;
+  inventoryComplete: boolean;
+  pr?: number;
+  headOid?: string;
+  kind: DraftCloseKind;
+  classification: string;
+  reason: string;
+  replacement?: number;
+  protectedReason?: string;
+  evidence: string[];
+  extra?: Json;
+}): DraftCloseRow {
+  return {
+    mapRunId: input.mapRunId ?? null,
+    snapshotTime: input.snapshotTime ?? null,
+    inventoryComplete: input.inventoryComplete,
+    pr: input.pr ?? null,
+    headOid: input.headOid ?? null,
+    kind: input.kind,
+    classification: input.classification,
+    reason: input.reason,
+    replacement: input.replacement ?? null,
+    protectedReason: input.protectedReason ?? null,
+    evidence: input.evidence,
+    writes: [],
+    ...input.extra,
+  };
+}
+
+function failClosed(mapRunId: string | undefined, snapshotTime: string | undefined, reason: string): DraftCloseDecision {
+  const result = row({ mapRunId, snapshotTime, inventoryComplete: false, kind: 'hold', classification: 'inventory-incomplete',
+    reason, evidence: [reason], extra: { rowsSuppressed: true } });
+  return { outcome: 'hold', result, evidence: { rowsSuppressed: true } };
+}
+
+function holdItem(input: { mapRunId?: string; snapshotTime?: string; pr?: number; headOid?: string; reason: string }): DraftCloseDecision {
+  const result = row({ mapRunId: input.mapRunId, snapshotTime: input.snapshotTime, inventoryComplete: true, pr: input.pr,
+    headOid: input.headOid, kind: 'hold', classification: 'human', reason: input.reason, evidence: [input.reason] });
+  return { outcome: 'hold', result, evidence: { reason: input.reason } };
+}
+
+/** Pure, deterministic item classifier used by the draft-close graph's observe node. */
+export function decideDraftClose(raw: unknown): DraftCloseDecision {
+  const envelope = record(raw);
+  const context = Object.keys(record(envelope.context)).length > 0 ? record(envelope.context) : envelope;
+  const inventory = record(context.inventory);
+  const item = record(context.item);
+  const mapRunId = string(context.mapRunId);
+  const snapshotTime = string(context.snapshotTime) ?? string(inventory.snapshotTime);
+  const completenessClaims = [context.inventoryComplete, inventory.complete].filter((value): value is boolean => typeof value === 'boolean');
+  const inventoryComplete = completenessClaims.length > 0 && completenessClaims.every(Boolean);
+  const completenessConflict = completenessClaims.some((value) => value !== completenessClaims[0]);
+  const truncated = context.truncated === true || inventory.truncated === true;
+  const inventoryError = string(context.inventoryError) ?? string(inventory.error);
+  if (!inventoryComplete || completenessConflict || truncated || inventoryError) {
+    return failClosed(mapRunId, snapshotTime, inventoryError ?? (truncated ? 'inventory truncated/page limit'
+      : completenessConflict ? 'conflicting inventory completeness claims' : 'inventory completeness not proven'));
+  }
+
+  const prValue = item.pr ?? item.number;
+  const pr = typeof prValue === 'number' && Number.isSafeInteger(prValue) && prValue > 0 ? prValue
+    : typeof prValue === 'string' && /^\d+$/.test(prValue) ? Number(prValue) : undefined;
+  const headOid = string(item.headOid) ?? string(item.headSha);
+  const mainSha = string(context.mainSha) ?? string(inventory.mainSha);
+  const repository = string(item.repository);
+  const state = string(item.state)?.toLowerCase();
+  const labels = strings(item.labels);
+  const branch = string(item.branch);
+  const title = string(item.title);
+  const body = typeof item.body === 'string' ? item.body : undefined;
+  const createdAt = string(item.createdAt);
+  const changedFiles = strings(item.changedFiles);
+  const latestFileChanges = record(item.latestFileChanges) as Record<string, string>;
+  const snapshotMs = Date.parse(snapshotTime ?? '');
+  if (!pr || !headOid || !repository || !mainSha || !snapshotTime || !Number.isFinite(snapshotMs)
+    || state !== 'open' || item.isDraft !== true || !labels || !branch || !title || body === undefined || !createdAt
+    || !changedFiles || item.changedFilesComplete !== true) {
+    return holdItem({ mapRunId, snapshotTime, pr, headOid,
+      reason: 'PR snapshot lacks required id/head/repo/state/labels/body/files or main/snapshot proof' });
+  }
+
+  const protectedLabel = labels.find((label) => DRAFT_CLOSE_PROTECTED_LABELS.has(label));
+  if (protectedLabel) {
+    const result = row({ mapRunId, snapshotTime, inventoryComplete: true, pr, headOid, kind: 'hold', classification: 'protected',
+      reason: `protected label ${protectedLabel}`, protectedReason: protectedLabel, evidence: [`label=${protectedLabel}`, `head=${headOid}`] });
+    return { outcome: 'hold', result, evidence: { protectedReason: protectedLabel } };
+  }
+
+  const reviewGate = record(item.reviewGate);
+  const reviewHead = string(reviewGate.headOid);
+  const gateHead = string(reviewGate.gateHeadOid);
+  const review = string(reviewGate.review)?.toLowerCase();
+  const gate = string(reviewGate.gate)?.toLowerCase();
+  const mustFix = reviewGate.mustFix;
+  const reviewPass = reviewHead === headOid && ['pass', 'warn'].includes(review ?? '')
+    && Array.isArray(mustFix) && mustFix.length === 0;
+  const gatePass = gateHead === headOid && gate === 'pass' && reviewGate.introduced === 0;
+  if (reviewPass && gatePass) {
+    const reason = 'same-head GLM mustFix=0 and changed gate introduced=0';
+    const result = row({ mapRunId, snapshotTime, inventoryComplete: true, pr, headOid, kind: 'harvest', classification: 'harvest', reason,
+      evidence: [reason, `repository=${repository}`, `mainSha=${mainSha}`, `head=${headOid}`], extra: {
+        handoff: ['merge-origin-main-into-branch', 'resolve-conflicts-on-same-branch', 'changed-gate-introduced-0',
+          'GLM-review-same-head-mustFix-0', 'land-enqueue-without-gate-summary'],
+      } });
+    return { outcome: 'harvest', result, evidence: { headOid, mainSha, handoff: result.handoff } };
+  }
+
+  if (item.openDraftsComplete !== true || item.mergedTwinsComplete !== true) {
+    const reason = 'open/merged peer inventory incomplete; close decision suppressed';
+    return holdItem({ mapRunId, snapshotTime, pr, headOid, reason: `${reason}; mainSha=${mainSha}` });
+  }
+
+  const latestCommitAt = string(item.lastCommitAt) ?? string(item.latestCommitAt);
+  const latestCommitMs = Date.parse(latestCommitAt ?? '');
+  const ageHours = Number.isFinite(latestCommitMs) ? (snapshotMs - latestCommitMs) / 3_600_000 : Number.NaN;
+  if (!latestCommitAt || !Number.isFinite(latestCommitMs)) {
+    return holdItem({ mapRunId, snapshotTime, pr, headOid, reason: 'last commit time unavailable; 48h/stale decision suppressed' });
+  }
+  const openDrafts = Array.isArray(item.openDrafts) ? item.openDrafts as DraftTriagePr[] : [];
+  const mergedTwins = Array.isArray(item.mergedTwins) ? item.mergedTwins as DraftTriagePr[] : [];
+  const liveBranches = new Set(strings(item.liveBranches) ?? []);
+  const runStatus = string(item.runStatus);
+  const decision = decideDraft({
+    draft: { number: pr, title, branch, labels, body, createdAt, changedFiles, latestFileChanges, latestCommitAt },
+    runStatus,
+    mergedTwins,
+    openDrafts,
+    ageHours,
+    liveBranches,
+    ...(typeof item.finalRunResult === 'boolean' ? { finalRunResult: item.finalRunResult } : {}),
+  });
+  if (decision.action === 'keep') {
+    const result = row({ mapRunId, snapshotTime, inventoryComplete: true, pr, headOid, kind: 'hold', classification: 'keep',
+      reason: decision.reason, evidence: [`decideDraft=${decision.action}:${decision.reason}`, `head=${headOid}`, `mainSha=${mainSha}`] });
+    return { outcome: 'hold', result, evidence: { decision } };
+  }
+
+  // Keep item-level completeness guards beside the close decision even though the envelope guard above also checks them.
+  if (decision.reason.startsWith('duplicate-of-open') && item.openDraftsComplete !== true) {
+    return failClosed(mapRunId, snapshotTime, 'complete open-draft inventory required for duplicate close proposal');
+  }
+  if ((decision.reason.includes('all-files-landed') || decision.reason.startsWith('superseded-by'))
+    && (item.mergedTwinsComplete !== true || item.changedFilesComplete !== true)) {
+    return failClosed(mapRunId, snapshotTime, 'complete changed-file and merged-peer evidence required for superseded close proposal');
+  }
+
+  const match = /#(\d+)/.exec(decision.reason);
+  const replacement = match ? Number(match[1]) : undefined;
+  const classification = decision.reason.includes('all-files-landed') ? 'all-files-landed'
+    : decision.reason.startsWith('duplicate-of-open') ? 'duplicate-of-open'
+      : decision.reason.startsWith('superseded-by') ? 'superseded' : 'stale';
+  const result = row({ mapRunId, snapshotTime, inventoryComplete: true, pr, headOid, kind: 'close-candidate', classification,
+    reason: decision.reason, replacement, evidence: [`decideDraft=close:${decision.reason}`, `lastCommitAt=${latestCommitAt}`,
+      `ageHours=${ageHours}`, `repository=${repository}`, `mainSha=${mainSha}`, `head=${headOid}`], extra: { writeBoundary: 'reduce-only' } });
+  return { outcome: 'close-candidate', result, evidence: { decision, latestCommitAt, ageHours, mainSha, headOid } };
+}
+
+function graphContext(): Json {
+  const path = process.env.ELANOUS_GRAPH_CONTEXT;
+  if (!path) throw new Error('ELANOUS_GRAPH_CONTEXT is required');
+  return JSON.parse(readFileSync(path, 'utf8')) as Json;
+}
+
+if (import.meta.main) {
+  const context = graphContext();
+  const mode = process.argv[2];
+  if (mode === 'decide') {
+    const decision = decideDraftClose(context.input);
+    process.stdout.write(`${JSON.stringify(decision)}\n`);
+  } else if (mode === 'emit') {
+    const branch = process.argv[3] as DraftCloseKind | undefined;
+    const decided = record(record(context.outputs).decide);
+    const result = record(decided.result);
+    if (!branch || result.kind !== branch) throw new Error(`decision row kind does not match branch ${branch ?? '<missing>'}`);
+    process.stdout.write(`${JSON.stringify({ outcome: 'done', result, evidence: decided.evidence ?? {} })}\n`);
+  } else {
+    throw new Error(`unknown draft-close mode: ${mode ?? '<missing>'}`);
+  }
+}

package/scripts/hook-order-sweep.ts

@@ -106,9 +106,10 @@ function isFunctionLike(ts: Ts, node: Node): boolean {
   return ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node);
 }
 
-/** 이 노드와 소유자 사이에 «분기»가 있나 — 있으면 그 훅은 매 렌더에 안 돈다. */
+/** 이 노드와 소유자 사이에 «분기»가 있나 — 단축 평가 연산자의 오른쪽만 조건부다. */
 function branchBetween(ts: Ts, node: Node, owner: Node): boolean {
-  for (let current = node.parent; current && current !== owner; current = current.parent) {
+  let child: Node = node;
+  for (let current = node.parent; current && current !== owner; child = current, current = current.parent) {
     if (
       ts.isIfStatement(current)
       || ts.isConditionalExpression(current)
@@ -116,7 +117,9 @@ function branchBetween(ts: Ts, node: Node, owner: Node): boolean {
       || ts.isWhileStatement(current) || ts.isDoStatement(current)
       || ts.isSwitchStatement(current)
       || ts.isTryStatement(current) || ts.isCatchClause(current)
-      || (ts.isBinaryExpression(current) && (current.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || current.operatorToken.kind === ts.SyntaxKind.BarBarToken || current.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken))
+      || (ts.isBinaryExpression(current)
+        && child === current.right
+        && (current.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || current.operatorToken.kind === ts.SyntaxKind.BarBarToken || current.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken))
     ) return true;
   }
   return false;
@@ -270,7 +273,7 @@ export function formatHookOrderReport(report: HookOrderReport): string[] {
   return [
     `[hook-order] denominator: hook calls=${report.hookCallsScanned}; components and custom hooks=${report.ownersScanned}; files=${report.filesScanned}; ruler=identifier call matching /^use[A-Z]/ in TypeScript sources under the scanned scopes; scope=${report.scanRoots.join(', ') || 'none'}; unmeasured scopes=${report.unavailableScopes.join(', ') || 'none'}`,
     `[hook-order] after early return: ${kindCount(report, 'after-early-return')}; ruler=hook call positioned after a return statement in the top-level statement list of its component, so a render that takes the early return calls fewer hooks`,
-    `[hook-order] conditional: ${kindCount(report, 'conditional')}; ruler=hook call nested inside a branch, loop, switch, try, or short-circuit operator within its component`,
+    `[hook-order] conditional: ${kindCount(report, 'conditional')}; ruler=hook call nested inside a branch, loop, switch, try, or the right operand of &&, ||, or ?? within its component`,
     `[hook-order] nested function: ${kindCount(report, 'nested-function')}; ruler=hook call inside a function that is neither a component nor a custom hook, so it does not run on every render of the surrounding component`,
     `[hook-order] imported hook identity: not-measured; ruler=a locally declared function that calls no hook is excluded because a hook is a function that calls hooks, but an imported name and a property access such as React.useState are judged by the naming convention React itself enforces; a hook renamed on import to a name that does not start with use is outside this ruler and outside React's own convention`,
     `[hook-order] elapsed: ${report.elapsedSeconds.toFixed(2)}s`,

package/scripts/land-global-checks.ts

@@ -9,6 +9,9 @@
 // 재는 명령: `bun scripts/land-global-checks.ts` (표) · `bun scripts/land-global-checks.ts <바뀐 파일…>` (끌려오는 시험)
 
 import { spawnSync } from 'node:child_process';
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 
 type LandGlobalCheck = {
   /** 바뀐 파일 경로(저장소 루트 기준 · `/` 구분)에 대는 꼴. */
@@ -19,9 +22,16 @@ type LandGlobalCheck = {
   why: string;
 };
 
+/** 착지 게이트가 실물 판정하는 next.md 경로 꼴 — 이번 착지가 이 꼴을 바꿀 때만 next.md 판정(landNextMdGate)이 돈다. */
+const NEXT_MD_PATTERN = /^release\/next\.md$/;
+
 export const LAND_GLOBAL_CHECKS: readonly LandGlobalCheck[] = [
   { pattern: /^apps\/pwa\/.+\.tsx$/, test: 'test/hook-order-sweep.test.ts', why: 'PWA 컴포넌트 훅 순서(#24719)' },
-  { pattern: /^release\/next\.md$/, test: 'scripts/release-story/draft.test.ts', why: '판 노트 초안·브랜드 규칙(#24688)' },
+  { pattern: NEXT_MD_PATTERN, test: 'scripts/release-story/draft.test.ts', why: '판 노트 초안·브랜드 규칙(#24688)' },
+  // 초안 규칙(draft.test)은 노트 줄에 B11 이 «없음»을 단언하는 길이라 발행 판정과 자가 다르다 — 0.2.24 는
+  //   next.md 의 «신설:» 한 줄로 컷 노드 notes-check 가 두 번 ✗ 났는데(10-12 01:28 · 01:51) 착지에서는 그 줄이 통과했다.
+  //   착지 판정이 실제 next.md 를 발행과 같은 check() 로 보게 `landNextMdGate`(runLandGlobalChecksGate 안)가 판정 자를 맞춘다.
+  { pattern: NEXT_MD_PATTERN, test: 'scripts/announce-loop/check-node.test.ts', why: '발행 노트 한국어 B11(0.2.24 notes-check)' },
   { pattern: /^docs\/ops\/machines\.yaml$/, test: 'test/machines-ledger-data.test.ts', why: '기계 원장 데이터 ↔ 생성 Markdown(#24729)' },
   // 새 CLI 하위 명령은 `src/index.ts` 또는 `src/cli/` 의 등록 모듈에서 생긴다 — 입구 목록 시험(#24661).
   { pattern: /^src\/(?:index|cli\/(?:[^/]+\/)*[^/]+)(?<!\.test)\.ts$/, test: 'src/index.test.ts', why: 'CLI 입구·하위 명령 목록(#24661)' },
@@ -41,6 +51,59 @@ export function landGlobalChecks(changedFiles: readonly string[], table: readonl
 
 export type LandGlobalChecksRun = { status: number | null; output: string; error?: string };
 
+const CHECK_NODE_SCRIPT = join(import.meta.dir, 'announce-loop', 'check-node.ts');
+
+type NextMdFinding = { rule: string; file: string; line: number; text: string };
+
+/** 발행 notes-check 와 같은 check()(scripts/announce-loop/check-node.ts)에 «실제 저장소의» release/next.md 를 넣고
+ * «착지» 범위(--landing)로 돈다 — gh·fetch 없이 B11·B8·공유 줄 규칙만(B1·B10 네트워크 검사는 발행 판정에만 있다). */
+function runNextMdCheck(cwd: string): LandGlobalChecksRun {
+  const dir = mkdtempSync(join(tmpdir(), 'land-next-md-'));
+  const prfaq = join(dir, 'prfaq.md');
+  writeFileSync(prfaq, '');
+  try {
+    const r = spawnSync('bun', [CHECK_NODE_SCRIPT, '--landing', '--prfaq', prfaq, '--files', 'release/next.md'], {
+      cwd, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024, timeout: 60_000,
+    });
+    return { status: r.status, output: `${r.stdout ?? ''}\n${r.stderr ?? ''}`, ...(r.error ? { error: r.error.message } : {}) };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * 착지 게이트가 실제 release/next.md 를 발행 판정과 같은 check() 로 본다 — 0.2.24 어긋남(착지 통과 · 발행 B11 ✗) 수리.
+ * ⚠️ 파일이 없으면 «해당 없음»으로 통과한다(착지 게이트는 무대의 실물만 본다).
+ * 호출부(runLandGlobalChecksGate)는 이번 착지의 바뀐 파일에 release/next.md 가 있을 때만 부른다 —
+ *   next.md 를 건드리지 않은 PR 은 main 의 next.md 상태에 영향을 받지 않는다.
+ * 판정 범위는 «착지»(--landing) — B11·B8·공유 줄 규칙만. B1(PR 참조)·B10(링크) 네트워크 검사는 발행 판정에만 있다.
+ */
+export function landNextMdGate(cwd: string, io: { log: (message: string) => void; error: (message: string) => void }): boolean {
+  const nextMd = join(cwd, 'release', 'next.md');
+  if (!existsSync(nextMd)) return true;
+  const result = runNextMdCheck(cwd);
+  if (result.error !== undefined || result.status === null) {
+    throw new Error(`release/next.md 발행 노트 검사 러너가 못 돌았다 — ${result.error ?? 'status=null'}`);
+  }
+  if (result.status === 0) {
+    io.log('✓ land-global-checks: 실제 release/next.md 발행 노트 검사(check-node) PASS — 위반 0.');
+    return true;
+  }
+  let findings: NextMdFinding[] = [];
+  const jsonLine = result.output.split(/\r?\n/).find((line) => line.trim().startsWith('{'));
+  if (jsonLine !== undefined) {
+    try { findings = (JSON.parse(jsonLine) as { findings?: NextMdFinding[] }).findings ?? []; } catch { findings = []; }
+  }
+  if (findings.length === 0) {
+    io.error(`✗ land-global-checks: 실제 release/next.md 발행 노트 검사(check-node)가 실패했다(종료 ${result.status}) — ${result.output.trim().split(/\r?\n/).at(-1) ?? ''}`);
+  }
+  for (const f of findings) {
+    io.error(`✗ land-global-checks: 실제 release/next.md — 발행 노트 검사(check-node) 위반 ${f.rule} ${f.file}:${f.line} ${f.text.trim()}`);
+  }
+  io.error('✗ land-global-checks: scripts/land-global-checks.ts blocked pr land — 실제 release/next.md 가 발행 notes-check(check-node) 판정에서 위반했다. 발행 판정과 착지 판정의 B11 자를 맞추려면 노트를 고치고 착지하라.');
+  return false;
+}
+
 type LandGlobalChecksGateIo = {
   changedFiles: readonly string[];
   cwd: string;
@@ -59,9 +122,14 @@ function runDeterministic(tests: readonly string[], cwd: string): LandGlobalChec
 
 /**
  * 반환: true = 해당 없음 또는 끌려온 시험 통과 · false = 끌려온 시험이 실패했다(착지를 막는다).
+ * 실물 next.md 판정(landNextMdGate)은 이번 착지가 release/next.md 를 바꿀 때만 돈다 — 머리 주석의
+ * «바뀐 파일 꼴로 끌어온다» 계약을 따른다. next.md 를 건드리지 않은 PR 은 main 의 next.md 상태를 보지 않는다.
  * ⛔ 러너가 «못 돌았다»(spawn 실패·시간 초과)면 던진다 — 호출부(`gateVerdict`)가 「검사 못 함」으로 말한다.
  */
 export function runLandGlobalChecksGate(io: LandGlobalChecksGateIo): boolean {
+  if (io.changedFiles.some((file) => NEXT_MD_PATTERN.test(file.replace(/\\/g, '/')))) {
+    if (!landNextMdGate(io.cwd, io)) return false;
+  }
   const tests = landGlobalChecks(io.changedFiles);
   if (tests.length === 0) {
     io.log(`[land-global-checks] 해당 없음 — 바뀐 파일 ${io.changedFiles.length}개가 전역 검사 표(${LAND_GLOBAL_CHECKS.length}줄)의 꼴에 안 걸린다.`);