elanous 0.2.36 → 0.2.38

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/intake-collect-telegram-saved-stage.ts

@@ -0,0 +1,48 @@
+// TG-SAVED-ZERO 무대 — save(me) 대화의 가짜 저장 메시지로 흡수 경로를 세 번 지난다.
+// ① 다른 주체가 이미 흡수한 판 · ② 사흘 0 관측 그대로(필터로 비어 커서만 전진) · ③ 판정선(저장 1건이 다음 흡수에 원장으로).
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { collectTelegramSaved, readSavedCursor, renderCollectTelegramSavedResult, savedMessageToRaws, type SavedMessage } from '../src/intake-plane/collect-telegram-saved.js';
+import { ingestIntakeItems, listIntakeItems, markIntakeItem, pickAbsorbQueue } from '../src/intake-plane/items.js';
+
+const root = mkdtempSync(join(tmpdir(), 'tg-saved-zero-'));
+const saved: SavedMessage[] = [
+  { id: 8959, date: '2026-10-22T00:05:00.000Z', text: 'https://example.com/first 메모', urls: [] },
+  { id: 8975, date: '2026-10-23T00:05:00.000Z', text: '', urls: [] },
+  { id: 9092, date: '2026-10-24T00:05:00.000Z', text: '   ', urls: [] },
+  { id: 9200, date: '2026-10-25T00:05:00.000Z', text: 'https://example.com/next 다음 것', urls: [] },
+];
+
+// 대표가 텔레그램에서 «저장한» 목록의 창 — 지금 창 안의 메시지만 fetch 가 돌려준다.
+let visibleUpTo = 8959;
+const fetchSaved = async (minId: number) => saved.filter((m) => m.id > minId && m.id <= visibleUpTo);
+const run = (max = 300) => collectTelegramSaved(root, fetchSaved, { max });
+
+// ① 다른 주체(queue)가 8959 를 먼저 가져가 흡수까지 끝낸 판 — collect 는 «이미 끝난 것» 만 본다.
+ingestIntakeItems(root, 'telegram-saved', savedMessageToRaws(saved[0]!));
+for (const item of pickAbsorbQueue(root, { max: 10, laneMax: 30 })) markIntakeItem(root, item.id, { status: 'absorbed' });
+const consumed = await run();
+console.log('=== ① 같은 항목을 다른 주체(queue)가 먼저 흡수한 판 — «원장 입력 있음 · 새 0»');
+console.log(renderCollectTelegramSavedResult(consumed));
+
+// ② 사흘 0 의 관측 그대로 — 커서는 8959→9092 로 전진했는데 원장 입력 0(빈 메시지가 필터에 걸림)
+visibleUpTo = 9092;
+const filtered = await run();
+console.log('=== ② 사흘 0 관측 그대로 — 커서만 8959 → 9092 로 전진 · 원장 입력 0');
+console.log(renderCollectTelegramSavedResult(filtered));
+console.log(`   (원장 줄 수 ${listIntakeItems(root).length} — 그대로)`);
+
+// ③ 판정 — 대표가 저장한 다음 메시지 1건(id 9200)이 다음 흡수에 원장으로 들어간다
+visibleUpTo = 9200;
+const next = await run();
+console.log('=== ③ 판정 — 대표가 저장한 메시지 1건(id 9200)이 다음 흡수에 원장으로 들어감');
+console.log(renderCollectTelegramSavedResult(next));
+
+const links = listIntakeItems(root).map((i) => i.url);
+console.log(`\n[ledger] 원장 링크 ${JSON.stringify(links)} · 커서 ${readSavedCursor(root)}`);
+const ok = filtered.raws === 0 && filtered.cursorAfter === 9092 && filtered.messages === 2
+  && (next.ingest?.added ?? 0) === 1 && links.filter((u) => u === 'https://example.com/next').length === 1
+  && consumed.ingest?.seen === 1;
+console.log(ok ? '[verdict] 판정선 통과 — 저장 메시지 1건이 다음 흡수에 원장으로 들어갔다' : '[verdict] 판정선 실패');
+process.exitCode = ok ? 0 : 1;