elanous 0.2.28 → 0.2.31

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

@@ -0,0 +1,282 @@
+// ── Seat knowhow packs — RFC-seat-knowhow-packs-adaptive-knowledge-2026-10-11.md §A ──
+//
+// Loader for `내부 문서 `KNOWHOW`` v2 items plus the role charter
+// `내부 문서 `<자리>``. Replaces the two duplicate role-file reads inside
+// seat-loop.ts (gatherSeatInputs + inquire) — one loader, no 4,000-char cut
+// on the charter, one overall budget cap instead.
+//
+// Injection rules (§A3 ⊕ review must-fix 1):
+//   «사실»          = status active ⊕ last verification «참» ⊕ within half-life
+//   «참고(검증 안 됨)» = unproven / unverifiable(못잼) / expired half-life
+//   dropped          = any status outside active/unproven/unverifiable,
+//                     last verification «거짓»/future/invalid date,
+//                     상태 미선언 · 검증 미선언 — a card is injected
+//                     only with an explicit 상태 AND an explicit 검증 line;
+//                     a missing 상태 is never assumed to be `active`.
+//
+// Half-life (§A1): fact 14 · warning 30 · heuristic 90 · playbook 60 days,
+// case unlimited; kind defaults to fact when a card does not declare one.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../debug/log.js';
+
+export type KnowhowKind = 'fact' | 'warning' | 'heuristic' | 'playbook' | 'case';
+
+export const KNOWHOW_HALF_LIFE_DAYS: Record<KnowhowKind, number> = {
+  fact: 14,
+  warning: 30,
+  heuristic: 90,
+  playbook: 60,
+  case: Number.POSITIVE_INFINITY,
+};
+
+/** One overall budget cap for the whole injected pack (RFC §A3 — value
+ * unspecified in the ask; 32,000 chars adopted as the documented value for
+ * this slice, replacing the old per-chunk 4,000-char cuts).
+ *
+ * Budget policy (review must-fix 3) — whole items only, `text.slice` is never
+ * used: the charter, each block header, and each card enter the pack whole or
+ * not at all.
+ *   1. The charter is always kept whole and outranks every card.
+ *   2. Cards are appended whole in top-k order while the running total stays
+ *      within this cap; a card that would exceed it is skipped (a later,
+ *      smaller card may still fit).
+ *   3. A charter that alone exceeds the cap is still injected whole and both
+ *      card blocks are dropped entirely — the seat keeps its charter; slicing
+ *      the charter mid-way is exactly what this policy abolishes. */
+export const SEAT_PACK_TOTAL_BUDGET_CHARS = 32_000;
+export const DEFAULT_TOP_K = 8;
+
+export interface KnowhowItem {
+  kind: KnowhowKind;
+  /** Declared 상태 — '' when the card states none (never assumed active). */
+  status: string;
+  verifiedAt: Date | null;
+  /** true = 참 · false = 거짓 · null = 못잼/unproven */
+  verified: boolean | null;
+  text: string;
+}
+
+export interface SeatPack {
+  charter: string;
+  /** Card texts actually injected into `text` — never a superset of it. */
+  facts: string[];
+  refs: string[];
+  /** Cards refused by classification (contradicted·stale·superseded·거짓·
+   *  상태/검증 미선언). Cards skipped only by the budget are not counted. */
+  dropped: number;
+  text: string;
+}
+
+export interface SeatPackDeps {
+  repo?: string;
+  read?: (path: string) => string;
+  now?: () => Date;
+  topK?: number;
+}
+
+// 참/거짓 뒤 경계는 \b 대신 명시적 뒷자리 제한 — \w 가 ASCII 한정이라
+// 참(한글) 뒤에서는 \b 가 경계로 안 센다(실측: verified 가 null 로 흘렀다).
+const VERIFIED_TRUE_RE = /^\s*(\d{4}-\d{2}-\d{2})\s*참(?![^\s(·])/;
+const VERIFIED_FALSE_RE = /^\s*(\d{4}-\d{2}-\d{2})\s*거짓(?![^\s(·])/;
+const VERIFIED_UNVERIFIABLE_RE = /^\s*(\d{4}-\d{2}-\d{2})\s*못잼/;
+const FIELD_RE = /^-([^:]+):\s*(.*)$/;
+
+function calendarDate(isoDay: string): Date | null {
+  const date = new Date(`${isoDay}T00:00:00Z`);
+  return Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === isoDay ? date : null;
+}
+
+export function parseKnowhowItems(body: string, seat: string): KnowhowItem[] {
+  const headerRe = new RegExp(`^##\\s+K-${seat.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}-\\d+`, 'i');
+  const items: KnowhowItem[] = [];
+  // First section before any card header is the document preamble — drop it.
+  const sections = body.split(/^##\s+/m);
+  for (const section of sections) {
+    const lines = section.split('\n');
+    const header = lines[0] ?? '';
+    if (!headerRe.test(`## ${header}`)) continue;
+    const rest = lines.slice(1).join('\n');
+    const fields: Record<string, string> = {};
+    let kind: KnowhowKind | null = null;
+    let status = '';
+    let verifiedAt: Date | null = null;
+    let verified: boolean | null = null;
+    for (const line of rest.split('\n')) {
+      const m = line.match(FIELD_RE);
+      if (m) {
+        const label = m[1].trim();
+        const value = m[2].trim();
+        fields[label] = value;
+        if (label === '종류' && value in KNOWHOW_HALF_LIFE_DAYS) {
+          kind = value as KnowhowKind;
+        } else if (label === '상태') {
+          status = value;
+        } else if (label === '검증') {
+          // A later verification line supersedes the earlier one even when
+          // malformed; otherwise an old «참» survives a failed new check.
+          verified = null;
+          verifiedAt = null;
+          const t = value.match(VERIFIED_TRUE_RE);
+          const f = value.match(VERIFIED_FALSE_RE);
+          const u = value.match(VERIFIED_UNVERIFIABLE_RE);
+          if (t) {
+            verified = true;
+            verifiedAt = calendarDate(t[1]);
+          } else if (f) {
+            verified = false;
+            verifiedAt = calendarDate(f[1]);
+          } else if (u) {
+            verified = null;
+            verifiedAt = calendarDate(u[1]);
+          }
+        }
+      }
+    }
+    // Inline `상태:`/`종류:` inside other fields (e.g. the 출처 line) also count.
+    for (const value of Object.values(fields)) {
+      if (!status) {
+        const s = value.match(/(?:^|·\s*|[·，,;|\s])상태:\s*(\S+)/);
+        if (s) status = s[1];
+      }
+      if (!kind) {
+        const k = value.match(/(?:^|·\s*|[·，,;|\s])종류:\s*(\S+)/);
+        if (k && k[1] in KNOWHOW_HALF_LIFE_DAYS) kind = k[1] as KnowhowKind;
+      }
+    }
+    items.push({
+      kind: kind ?? 'fact',
+      // Missing 상태 stays '' — the classifier refuses to inject it; the
+      // parser must not default a status-less card to `active` (must-fix 1).
+      status,
+      verifiedAt,
+      verified,
+      text: `## ${header}\n${rest}`.trim(),
+    });
+  }
+  return items;
+}
+
+function withinHalfLife(item: KnowhowItem, now: Date): boolean {
+  if (!item.verifiedAt) return false;
+  const ageMs = now.getTime() - item.verifiedAt.getTime();
+  if (!Number.isFinite(ageMs) || ageMs < 0) return false;
+  const days = KNOWHOW_HALF_LIFE_DAYS[item.kind];
+  if (!Number.isFinite(days)) return true;
+  return ageMs <= days * 24 * 60 * 60 * 1000;
+}
+
+/** «사실» vs «참고(검증 안 됨)» vs dropped(contradicted·stale·superseded·최근
+ * 검증 거짓·상태/검증 미선언). Only active/unproven/unverifiable are admitted;
+ * a future or invalid verification date is rejected. A card is injected only when it declares an
+ * explicit 상태 AND an explicit 검증 line; a card whose most recent
+ * verification is «거짓» is contradicted — dropped, never filed as
+ * «검증 안 됨» (review must-fix 1). */
+export function splitKnowhow(
+  items: KnowhowItem[],
+  now: Date,
+): { facts: KnowhowItem[]; refs: KnowhowItem[]; dropped: number } {
+  const facts: KnowhowItem[] = [];
+  const refs: KnowhowItem[] = [];
+  let dropped = 0;
+  for (const item of items) {
+    const allowedStatus = item.status === 'active' || item.status === 'unproven' || item.status === 'unverifiable';
+    const verifiedAtMs = item.verifiedAt?.getTime();
+    const lacksExplicitConditions = !Number.isFinite(verifiedAtMs) || item.verified === false
+      || verifiedAtMs! > now.getTime();
+    if (!allowedStatus || lacksExplicitConditions) {
+      dropped += 1;
+      continue;
+    }
+    if (item.verified === true && item.status === 'active' && withinHalfLife(item, now)) {
+      facts.push(item);
+    } else {
+      refs.push(item);
+    }
+  }
+  return { facts, refs, dropped };
+}
+
+function tokenize(text: string): string[] {
+  return text
+    .toLowerCase()
+    .split(/[^\p{L}\p{N}_]+/u)
+    .filter((t) => t.length > 0);
+}
+
+/** Top-k by word overlap with the query (default k = 8). Ties keep pack order. */
+export function selectTopK(items: KnowhowItem[], query: string, k: number = DEFAULT_TOP_K): KnowhowItem[] {
+  const tokens = new Set(tokenize(query));
+  const scored = items.map((item, index) => {
+    const itemTokens = new Set(tokenize(item.text));
+    let score = 0;
+    for (const token of itemTokens) if (tokens.has(token)) score += 1;
+    return { item, score, index };
+  });
+  scored.sort((a, b) => b.score - a.score || a.index - b.index);
+  return scored.slice(0, Math.max(0, k)).map((s) => s.item);
+}
+
+/** Assemble the pack under SEAT_PACK_TOTAL_BUDGET_CHARS at whole-item
+ * granularity — see the policy on the constant. The `facts`/`refs` arrays in
+ * the result carry exactly the cards that made it into `text`. */
+function assemblePack(
+  charter: string,
+  rankedItems: KnowhowItem[],
+  factSet: ReadonlySet<KnowhowItem>,
+): { text: string; facts: string[]; refs: string[] } {
+  const SEP = '\n\n';
+  let used = charter.length;
+  const facts: string[] = [];
+  const refs: string[] = [];
+  // Budget in query rank order; rendering can still group facts before refs.
+  for (const item of rankedItems) {
+    const isFact = factSet.has(item);
+    const out = isFact ? facts : refs;
+    const header = isFact ? '### 사실 (검증된 노하우)' : '### 참고 (검증 안 됨)';
+    const cost = out.length === 0
+      ? (used > 0 ? SEP.length : 0) + header.length + SEP.length + item.text.length
+      : SEP.length + item.text.length;
+    if (used + cost > SEAT_PACK_TOTAL_BUDGET_CHARS) continue;
+    out.push(item.text);
+    used += cost;
+  }
+  let text = charter;
+  if (facts.length > 0) text += `${text ? SEP : ''}### 사실 (검증된 노하우)${SEP}${facts.join(SEP)}`;
+  if (refs.length > 0) text += `${text ? SEP : ''}### 참고 (검증 안 됨)${SEP}${refs.join(SEP)}`;
+  return { text, facts, refs };
+}
+
+export function loadSeatPack(seat: string, query = '', deps: SeatPackDeps = {}): SeatPack {
+  const repo = deps.repo ?? process.cwd();
+  const read = deps.read ?? ((path: string) => readFileSync(path, 'utf8'));
+  const now = deps.now ?? (() => new Date());
+  const charter = read(join(repo, 'docs', 'roles', `${seat}.md`)).trim();
+  const knowhowPath = join(repo, 'docs', 'roles', seat, 'KNOWHOW.md');
+  // NOTE: presence is decided by reading through `deps.read`, not existsSync —
+  // tests mount a virtual reader; a disk probe would report the virtual path
+  // missing and silently drop the whole KNOWHOW pack (observed: facts=0).
+  let knowhowBody = '';
+  try {
+    knowhowBody = read(knowhowPath);
+  } catch {
+    knowhowBody = '';
+  }
+  const items = parseKnowhowItems(knowhowBody, seat);
+  const { facts, refs, dropped } = splitKnowhow(items, now());
+  const topK = deps.topK ?? DEFAULT_TOP_K;
+  // One top-k pass over the whole candidate pool (facts ⊕ refs), then the
+  // winners are split back into their blocks in score order — applying k per
+  // block would inject up to 2k cards (review must-fix 2).
+  const selected = selectTopK([...facts, ...refs], query, topK);
+  const factSet = new Set(facts);
+  const pack = assemblePack(charter, selected, factSet);
+  debug.log('seat.loop', 'pack-loaded', {
+    seat,
+    facts: pack.facts.length,
+    refs: pack.refs.length,
+    dropped,
+  });
+  return { charter, facts: pack.facts, refs: pack.refs, dropped, text: pack.text };
+}

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

@@ -1,6 +1,7 @@
 import { execFile } from 'node:child_process';
 import { createHash, randomUUID } from 'node:crypto';
 import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
+import { loadSeatPack } from './seat-knowhow.js';
 import { Database } from 'bun:sqlite';
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { promisify } from 'node:util';
@@ -28,6 +29,7 @@ import { recordSeatAskShadow } from '../seat-dispatch/seat-ask.js';
 import { appendSeatRequestRows, listSeatRequests, withSeatRequestLedgerLock } from '../seat-dispatch/seat-request-ledger.js';
 import { answerCrossCheck, answerSeat, askCrossCheck, askSeat, crossCheckAnswer, deliveredSeatQuestion, hasSeatAnswer, isSeatId, seatCrossChecks, seatQuestions, type CrossCheckJudgment, type SeatId } from '../seat-dispatch/seat-questions.js';
 import { queryRunningRuns } from '../self-implement/running-runs.js';
+import { collectDraftMetrics, DRAFT_NEEDS_OWNER_SEAT_CAP, shouldHoldSeatNewLaunch, type DraftMetrics } from '../self-dev/draft-sweep.js';
 import { checklistHistory, listChecklist, type Checklist } from '../release-loop/checklist.js';
 import { readSchedules, releasedVersion } from '../release-loop/feature-store.js';
 import { runOpDecide, type OpDecideCandidate } from './op-decide.js';
@@ -74,6 +76,12 @@ export type SeatDeps = {
   now?: () => Date;
   read?: (path: string) => string;
   run?: (args: string[]) => Promise<string>;
+  /** Current open draft inventory for the launch seat; injected tests avoid live GitHub. */
+  draftMetrics?: (now: Date) => Promise<DraftMetrics>;
+  /** Explicit needs-owner hold gate — the hold is an autonomous-launch guard. The orchestrator launch
+   *  (loops/orchestrator/tick.ts) and the hook wake (hooks/dispatch.ts) pass true; tests assert this
+   *  option instead of inferring the boundary from which seams are injected. */
+  needsOwnerGate?: boolean;
   /** Seat-folder resolver for every process this loop starts; production reads the registry-validated `seats/<role>` view, tests inject an isolated folder. */
   launchSeat?: (seat: string) => string;
   enqueue?: (seat: string, text: string, root: string, idempotencyKey: string, item: SeatItem) => Promise<{ id: string }>;
@@ -614,7 +622,10 @@ export async function gatherSeatInputs(seat: string, deps: SeatDeps = {}, ledger
   for (const request of pending) {
     if (request.source === 'seat-question' && ownedEvidence) request.evidence = ownedEvidence;
   }
-  return { requests: pending, checklist, role: read(join(deps.repo ?? repoRoot, 'docs', 'roles', `${seat}.md`)).slice(0, 4_000) };
+  // SEAT-PACK-LOADER (RFC seat-knowhow §A3): full charter (4,000-char cut abolished) ⊕ knowhow 사실/참고 blocks, top-k on this turn's judgment items.
+  const pack = loadSeatPack(seat, [...pending, ...checklist].map((item) => `${item.title}\n${item.text ?? ''}`).join('\n'),
+    { repo: deps.repo ?? repoRoot, read, now: deps.now ?? (() => new Date()) });
+  return { requests: pending, checklist, role: pack.text };
 }
 
 /** OP-LOOP-DECIDE: filter open decision cards each OP turn. Shadow records; live decides/routes. A failure never blocks the turn. */
@@ -1500,7 +1511,7 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
       ? ledger.find((row) => row.status === 'awaiting-resolution' && row.item && itemKey(row.item) === itemKey(item))?.inquiry ?? null
       : unfinished?.inquiry ?? await (deps.inquire ?? (async (asking: SeatId, work: SeatItem) => { try {
       const output = JSON.parse((await run(['agent', '--json', '--no-tools',
-        `[${asking} 자리 · 역할 docs/roles/${asking}.md] 이 항목을 판단할 근거가 부족한 경우에만 다른 자리 또는 사람에게 질문한다. 근거가 충분하면 null. JSON 객체 하나만 반환: null 또는 {"to":"OP|TC|MK|UX|CEO","question":"필요한 근거를 묻는 질문"}. 항목: ${work.id} ${work.title}\n내용: ${work.text}\n역할: ${(deps.read ?? defaultRead)(join(deps.repo ?? repoRoot, 'docs', 'roles', `${asking}.md`)).slice(0, 4_000)}`])).trim()) as { reply?: unknown };
+        `[${asking} 자리 · 역할 docs/roles/${asking}.md] 이 항목을 판단할 근거가 부족한 경우에만 다른 자리 또는 사람에게 질문한다. 근거가 충분하면 null. JSON 객체 하나만 반환: null 또는 {"to":"OP|TC|MK|UX|CEO","question":"필요한 근거를 묻는 질문"}. 항목: ${work.id} ${work.title}\n내용: ${work.text}\n역할: ${loadSeatPack(asking, `${work.title}\n${work.text}`, { repo: deps.repo ?? repoRoot, read: deps.read ?? defaultRead, now: () => now }).text}`])).trim()) as { reply?: unknown };
       const value: unknown = typeof output?.reply === 'string' ? JSON.parse(output.reply) : output;
       if (value === null) return null;
       if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('invalid seat inquiry');
@@ -1696,6 +1707,34 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
   }
   const action = planned!;
   if (action.kind === 'harness') {
+    // A count is observation until the dispatch boundary uses it. Do not enqueue or call harness say for an over-cap seat.
+    // NEEDS-OWNER-BOUNDARY: the hold is an autonomous-launch guard — the orchestrator launch
+    // (loops/orchestrator/tick.ts) and the hook wake (hooks/dispatch.ts) opt in via deps.needsOwnerGate;
+    // tests assert the option instead of inferring the boundary from which seams are injected.
+    if (deps.needsOwnerGate ?? false) {
+      let metrics: DraftMetrics | undefined;
+      try {
+        metrics = await (deps.draftMetrics ?? (async (clock: Date) => {
+          const [{ resolveRepositoryName }, { githubDraftSweepAdapters }] = await Promise.all([
+            import('../harness/repository-name.js'), import('../harness/harness-cli-command.js'),
+          ]);
+          return collectDraftMetrics(resolveRepositoryName({}), githubDraftSweepAdapters(), clock);
+        }))(now);
+        if (!metrics.needsOwnerBySeat) throw new Error('per-seat draft inventory missing');
+      } catch (error) {
+        // NEEDS-OWNER-POLICY: an unreadable census — gh unavailable, rate-limited, or one unreadable
+        // claim comment — is unobserved, not failed-closed. Unobserved input never holds the seat's
+        // dispatch; only an observed count over the cap does. The next loop pass re-collects.
+        observe('launch-needs-owner-unobserved', { seat, item: item.id, reason: String(error).slice(0, 140) });
+      }
+      if (metrics && shouldHoldSeatNewLaunch(seat, metrics.needsOwnerBySeat ?? {})) {
+        entry.status = 'wait';
+        entry.reason = `needs-owner ${seat}: ${metrics.needsOwnerBySeat?.[seat]} > ${DRAFT_NEEDS_OWNER_SEAT_CAP}`;
+        append(path, entry);
+        observe('launch-held-needs-owner', { seat, item: item.id, count: metrics.needsOwnerBySeat?.[seat] });
+        return entry;
+      }
+    }
     const launchedRunIds = new Set(ledger.flatMap((row) => row.seat === seat && row.status === 'launched' && row.runId ? [row.runId] : []));
     let running: readonly RunningSeatPod[] = [];
     let observationUnavailable = false;

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

@@ -8,6 +8,7 @@ import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { getUserConfig, type SeatLoopConfig } from '../user-config.js';
 import { collectDraftMetrics, collectOverlapMetrics, countSalvagedToday, type DraftMetrics, type OverlapMetrics } from '../self-dev/draft-sweep.js';
 import { queryRunningRuns } from '../self-implement/running-runs.js';
+import { loadRunLedger } from '../self-implement/run-ledger.js';
 import { readTaskAgentCover } from '../cli/tasks-cli.js';
 import { formatTaskAgentCover } from '../task-agent/cover.js';
 import type { TasksCliDeps } from '../cli/tasks-cli.js';
@@ -27,6 +28,10 @@ export type SeatReportDeps = {
   /** DRAFT-NOT-ARCHIVE salvage branches since the KST day start; null = unreadable. */
   salvagedToday?: (dayStart: Date, now: Date) => Promise<number | null>;
   runningRuns?: (runIds: readonly string[]) => { running: number; unknown: number } | null;
+  /** Launched-run 착지 집계; null 이나 예외는 «착지 못 잼»으로 나온다. */
+  landedRuns?: (runIds: readonly string[]) => { landed: number; unread: number } | null;
+  /** 기본 집계의 runId별 읽기 경로를 시험할 때만 교체한다. */
+  loadLedger?: typeof loadRunLedger;
 };
 export type SeatReportResult = { seat: string; date: string; body: string; posted: boolean };
 const repoRoot = resolve(import.meta.dir, '../..');
@@ -173,10 +178,45 @@ export async function seatReport(seat: string, deps: SeatReportDeps = {}): Promi
         : ` · 도는 런 ${counts.running}(불확실 ${counts.unknown})`;
     } catch { runningDetail = ' · 도는 런 못 잼'; }
   }
-  const body = `**[${seat}]** {{TS}} → 보고 ${date}: ${detail.join(' · ') || (classified.length ? 'OP 그림자 판단' : '원장 기록 없음')}${opDetail}${draftDetail}${runningDetail}`;
+  // ⭐ 사다리 ① (#25210 «도는 런» 옆): 발사된 runId 각각의 run 원장을 읽어 착지 수를 센다.
+  //   'merged' 사건이 있으면 착지 · 원장이 null(로컬에 없음 — Pod 런 등)이면 «원장 없음»으로 따로 센다.
+  let landedDetail = '';
+  let landed: number | null = 0;
+  let landedUnread: number | null = 0;
+  if (runIds.length) {
+    try {
+      const counts = (deps.landedRuns ?? ((ids: readonly string[]) => {
+        let landedCount = 0;
+        let unreadCount = 0;
+        let unreadable = false;
+        for (const runId of ids) {
+          try {
+            const ledger = (deps.loadLedger ?? loadRunLedger)(runId);
+            if (ledger === null) unreadCount += 1;
+            else if (ledger.some((entry) => entry.event === 'merged')) landedCount += 1;
+          } catch { unreadable = true; }
+        }
+        return unreadable ? null : { landed: landedCount, unread: unreadCount };
+      }))(runIds);
+      if (counts === null) {
+        landed = null;
+        landedUnread = null;
+        landedDetail = ' · 착지 못 잼';
+      } else {
+        landed = counts.landed;
+        landedUnread = counts.unread;
+        landedDetail = ` · 착지 ${counts.landed}(원장 없음 ${counts.unread})`;
+      }
+    } catch {
+      landed = null;
+      landedUnread = null;
+      landedDetail = ' · 착지 못 잼';
+    }
+  }
+  const body = `**[${seat}]** {{TS}} → 보고 ${date}: ${detail.join(' · ') || (classified.length ? 'OP 그림자 판단' : '원장 기록 없음')}${opDetail}${draftDetail}${runningDetail}${landedDetail}`;
   const pr = (deps.config ?? getUserConfig().loops?.seat)?.reportPr;
   const posted = deps.post === true && pr !== undefined;
   if (posted) await (deps.send ?? ((text, id, number) => defaultSend(text, id, number, deps.repo ?? repoRoot)))(body, seat, pr);
-  try { debug.log('seat.loop', 'reported', { seat, date, entries: entries.length, posted }); } catch { /* observation is fail-soft */ }
+  try { debug.log('seat.loop', 'reported', { seat, date, entries: entries.length, posted, landed, landedUnread }); } catch { /* observation is fail-soft */ }
   return { seat, date, body, posted };
 }

package/src/seat-loop/traffic-signal.ts

@@ -6,6 +6,7 @@ export type TrafficSignal = {
   global: string;
   versions?: string[];
   hold?: string[];
+  order?: string[];
   paused?: Record<string, boolean>;
 };
 export type TrafficSignalRead = TrafficSignal | { unreadable: true } | null;
@@ -29,10 +30,12 @@ export function readTrafficSignal(path?: string): TrafficSignalRead {
     if (typeof row.global !== 'string'
       || (row.versions !== undefined && (!Array.isArray(row.versions) || !row.versions.every((version) => typeof version === 'string')))
       || (row.hold !== undefined && (!Array.isArray(row.hold) || !row.hold.every((id) => typeof id === 'string')))
+      || (row.order !== undefined && (!Array.isArray(row.order) || !row.order.every((id) => typeof id === 'string')))
       || (row.paused !== undefined && (!row.paused || typeof row.paused !== 'object' || Array.isArray(row.paused)
         || !Object.values(row.paused).every((paused) => typeof paused === 'boolean')))) return { unreadable: true };
     return { global: row.global, ...(row.versions !== undefined ? { versions: row.versions as string[] } : {}),
       ...(row.hold !== undefined ? { hold: row.hold as string[] } : {}),
+      ...(row.order !== undefined ? { order: row.order as string[] } : {}),
       ...(row.paused !== undefined ? { paused: row.paused as Record<string, boolean> } : {}) };
   } catch (error) {
     return missing(error) ? null : { unreadable: true };

package/src/self-dev/ask-launch-flow.ts

@@ -81,14 +81,35 @@ export type InvokerBehindDefaultBranch =
   | { readonly state: 'measured'; readonly commits: number; readonly baseRef: string }
   | { readonly state: 'unmeasurable'; readonly reason: string };
 
+/** Ambient git location vars override `git -C <cwd>`; the invoker tree is the given cwd only. */
+const GIT_LOCATION_ENV_KEYS = [
+  'GIT_DIR', 'GIT_WORK_TREE', 'GIT_COMMON_DIR', 'GIT_INDEX_FILE',
+  'GIT_OBJECT_DIRECTORY', 'GIT_ALTERNATE_OBJECT_DIRECTORIES',
+] as const;
+
+function gitReadEnv(): NodeJS.ProcessEnv {
+  const env = { ...process.env };
+  for (const key of GIT_LOCATION_ENV_KEYS) delete env[key];
+  return env;
+}
+
+function gitRead(cwd: string, args: readonly string[]): string {
+  // git-spawn-allow: Reads only the given cwd after dropping ambient GIT_DIR/GIT_WORK_TREE so the invoker tree is that cwd, not the parent harness checkout.
+  return execFileSync('git', ['-C', cwd, ...args], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: gitReadEnv(),
+  }).trim();
+}
+
 /** 현재 인보커 작업 트리의 HEAD를 이미 알려진 원격 기본 브랜치 ref와만 비교한다. */
 export function measureInvokerBehindDefaultBranch(cwd: string): InvokerBehindDefaultBranch {
   try {
     // git-spawn-allow: Reads the known origin/HEAD remote-tracking ref without fetching or changing repository state.
-    const baseRef = execFileSync('git', ['-C', cwd, 'rev-parse', '--abbrev-ref', 'origin/HEAD'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+    const baseRef = gitRead(cwd, ['rev-parse', '--abbrev-ref', 'origin/HEAD']);
     if (!baseRef || baseRef === 'origin/HEAD') throw new Error('원격 기본 브랜치 ref를 해석하지 못했다');
     // git-spawn-allow: Counts commits reachable from the known remote default branch but not local HEAD without changing repository state.
-    const raw = execFileSync('git', ['-C', cwd, 'rev-list', '--count', `HEAD..${baseRef}`], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+    const raw = gitRead(cwd, ['rev-list', '--count', `HEAD..${baseRef}`]);
     const commits = Number(raw);
     if (!Number.isSafeInteger(commits) || commits < 0) throw new Error(`뒤처진 커밋 수가 유효하지 않다: ${raw || '(빈 값)'}`);
     return { state: 'measured', commits, baseRef };
@@ -102,7 +123,7 @@ export function measureInvokerBehindDefaultBranch(cwd: string): InvokerBehindDef
 function gitTopLevel(dir: string): string | null {
   try {
     // git-spawn-allow: Reads the repository top-level path without changing repository state.
-    return execFileSync('git', ['-C', dir, 'rev-parse', '--show-toplevel'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim() || null;
+    return gitRead(dir, ['rev-parse', '--show-toplevel']) || null;
   } catch { return null; }
 }
 

package/src/self-dev/decompose-compose-graph.ts

@@ -5,7 +5,8 @@ import { orderPiecesTopologically, type DecomposePiece } from './decompose-propo
 /** ⭐ RFC §5 «5단계» — `compose` 부모 그래프.
  *
  *  RFC §4.4 는 ***"compose 그래프가 «부모»가 되고, 조각마다 자식 그래프 인스턴스를 연다"*** 라고 적었다.
- *  겹침→간선 파생은 `orderPiecesTopologically` 가 «이미» 한다(`#15782`). 여기서 더하는 것은 둘이다:
+ *  ⛔ 겹침→간선 파생은 «없다»(2026-10-16 제거 · 대표 10-11 «겹침이라 미루는 현상 제거») — 순서 간선은 dependsOn 만 만든다.
+ *  여기서 더하는 것은 둘이다:
  *
  *  ⓐ 그 순서를 ***`GraphTemplate` 로 세워*** 2단계 위상 검사를 «그대로» 걸 수 있게 한다.
  *  ⓑ RFC 가 요구한 두 분모를 ***정적으로*** 잰다(원장 타임스탬프 대신 그래프 «경로»로).
@@ -42,22 +43,8 @@ export function composeGraphFromPieces(pieces: readonly DecomposePiece[], graphI
       if (!edges[dep]!.includes(piece.id)) { edges[dep]!.push(piece.id); hasIncoming.add(piece.id); }
     }
   }
-  // hotPaths 겹침 — 파생기와 «같은 규칙»(배열 앞선 것 먼저 · 이미 길이 있으면 건너뛴다)을 쓴다.
-  const reaches = (from: string, to: string): boolean => {
-    const seen = new Set([from]); const stack = [from];
-    while (stack.length) { const at = stack.pop()!; if (at === to) return true;
-      for (const next of edges[at] ?? []) if (!seen.has(next)) { seen.add(next); stack.push(next); } }
-    return false;
-  };
-  pieces.forEach((piece, index) => {
-    if (!piece.hotPaths?.length) return;
-    for (let earlier = 0; earlier < index; earlier++) {
-      const other = pieces[earlier]!;
-      if (!other.hotPaths?.some((path) => piece.hotPaths!.includes(path))) continue;
-      if (reaches(piece.id, other.id)) continue;
-      if (!edges[other.id]!.includes(piece.id)) { edges[other.id]!.push(piece.id); hasIncoming.add(piece.id); }
-    }
-  });
+  // ⛔ hotPaths 겹침 간선은 만들지 않는다(2026-10-16 제거 · 대표 10-11 «겹침이라 미루는 현상 제거»).
+  //    순서는 «의미 의존 dependsOn» 만 만든다 — 겹침은 pickDecomposeProposals 가 형제 겹침으로 따로 센다.
 
   for (const piece of pieces) {
     if (!hasIncoming.has(piece.id)) edges[COMPOSE_START]!.push(piece.id);
@@ -80,10 +67,11 @@ export function composeGraphFromPieces(pieces: readonly DecomposePiece[], graphI
 }
 
 /** RFC §5 5단계의 두 분모 — ⛔ 타임스탬프가 아니라 그래프 «경로»로 잰다.
- *  A = 겹치는 조각쌍(전부 직렬이어야 한다) · B = 겹치지 않는 쌍(하나 이상이 «나란히 갈 수» 있어야 한다).
+ *  A = 겹치는 조각쌍(선언된 의존 «외» 에는 직렬이어야 «하지 않는다») · B = 겹치지 않는 쌍(하나 이상이 «나란히 갈 수» 있어야 한다).
  *  ⛔ A=0 이거나 B=0 이면 «통과가 아니라» `unmeasured` 다. */
 export interface ComposeConcurrencyReport {
   readonly overlappingPairs: number;
+  /** 겹치는 쌍 중 «선언된 의존 외» 이유로 그래프에서 직렬로 남은 것 — 간선이 dependsOn 뿐이므로 구조적으로 0 이다(방어 관측). */
   readonly overlappingSerialized: number;
   readonly nonOverlappingPairs: number;
   readonly nonOverlappingConcurrent: number;
@@ -102,9 +90,9 @@ export function analyzeComposeConcurrency(pieces: readonly DecomposePiece[]): Co
     return false;
   };
 
-  // ⛔⭐ 「선언된 의존」과 「겹침에서 파생된 순서」를 «갈라» 본다.
-  //   분해기가 dependsOn 으로 «의미로» 정한 순서는 결함이 아니다 — 그것을 「불필요한 직렬화」로 세면
-  //   분모 B 가 거짓으로 0 이 되고, 통과할 판이 fail 로 뒤집힌다(이 갈림을 안 두었더니 실제로 그랬다).
+  // ⛔⭐ 「선언된 의존」으로 직렬된 쌍은 결함이 «아니다» — 분해기가 dependsOn 으로 «의미로» 정한 순서다.
+  //   겹침 간선이 사라진(2026-10-16) 그래프에서 남는 직렬은 전부 선언에서 오므로,
+  //   overlappingSerialized 는 «선언 외 직렬»만 센다 — 0 이 아니면 새 간선 원천이 생겼다는 방어 관측이다.
   const ids = new Set(pieces.map((p) => p.id));
   const declared: Record<string, string[]> = Object.fromEntries(pieces.map((p) => [p.id, [] as string[]]));
   for (const piece of pieces) {
@@ -120,16 +108,29 @@ export function analyzeComposeConcurrency(pieces: readonly DecomposePiece[]): Co
       const a = pieces[i]!, b = pieces[j]!;
       const overlaps = Boolean(a.hotPaths?.some((p) => b.hotPaths?.includes(p)));
       const serial = reachIn(edges, a.id, b.id) || reachIn(edges, b.id, a.id);
-      if (overlaps) { overlappingPairs++; if (serial) overlappingSerialized++; continue; }
+      if (overlaps) {
+        overlappingPairs++;
+        // ⛔ 선언된 의존으로 직렬된 겹침은 결함이 아니다 — «선언 외» 직렬만 센다.
+        if (!(reachIn(declared, a.id, b.id) || reachIn(declared, b.id, a.id)) && serial) overlappingSerialized++;
+        continue;
+      }
       // 선언된 의존으로 이미 순서가 있는 쌍은 분모 B 에서 «뺀다» — 나란히 갈 이유가 없는 쌍이다.
       if (reachIn(declared, a.id, b.id) || reachIn(declared, b.id, a.id)) continue;
       nonOverlappingPairs++;
       if (!serial) nonOverlappingConcurrent++;
     }
   }
-  const verdict: ComposeConcurrencyReport['verdict'] =
-    overlappingPairs === 0 || nonOverlappingPairs === 0 ? 'unmeasured'
-      : overlappingSerialized === overlappingPairs && nonOverlappingConcurrent >= 1 ? 'pass'
-        : 'fail';
-  return { overlappingPairs, overlappingSerialized, nonOverlappingPairs, nonOverlappingConcurrent, verdict };
+  return {
+    overlappingPairs, overlappingSerialized, nonOverlappingPairs, nonOverlappingConcurrent,
+    verdict: composeConcurrencyVerdict({ overlappingPairs, overlappingSerialized, nonOverlappingPairs, nonOverlappingConcurrent }),
+  };
+}
+
+/** RFC §5 5단계 판정식 — 파생 그래프에서 fail 이 구조적으로 안 나와도 식 자체는 살아 있다. */
+export function composeConcurrencyVerdict(
+  counts: Pick<ComposeConcurrencyReport, 'overlappingPairs' | 'overlappingSerialized' | 'nonOverlappingPairs' | 'nonOverlappingConcurrent'>,
+): ComposeConcurrencyReport['verdict'] {
+  return counts.overlappingPairs === 0 || counts.nonOverlappingPairs === 0 ? 'unmeasured'
+    : counts.overlappingSerialized === 0 && counts.nonOverlappingConcurrent >= 1 ? 'pass'
+      : 'fail';
 }