elanous 0.2.17 → 0.2.19

package/src/intake-plane/requirement-funnel.ts

@@ -0,0 +1,316 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { normalizeClaim, type AddBriefItem } from '../briefing/brief-items.js';
+import { createRequire } from 'node:module';
+import { debug } from '../debug/log.js';
+import { listChecklist, setItem, type ChecklistItem } from '../release-loop/checklist.js';
+import { placeCell, type PlacementDeps } from '../release-loop/placement.js';
+import { listSchedules } from '../release-loop/release-schedule.js';
+import { getUserConfig } from '../user-config.js';
+import { dateKey } from '../time/format.js';
+import { cardIndexPath, CardStore, type TaskCard } from '../task-cards/card-store.js';
+import { loadIntakeLedger, type IntakeItem } from './items.js';
+import { parseRubric, rubricGrade, rubricScore } from '../release-loop/rubric.js';
+
+export type RequirementSource = 'directive' | 'intake' | 'grounding' | 'coordination' | 'linear';
+export interface RequirementCandidate {
+  id: string;
+  source: RequirementSource;
+  text: string;
+  link: string;
+  receivedAt: string;
+  priority?: 'P0' | 'P1' | 'P2';
+  risk?: number;
+  cost?: number;
+  security?: number;
+  license?: string;
+  patentPrivatePath?: boolean;
+  owner?: string;
+  deadlineVersion?: string;
+}
+export type IncomingRequirement = Omit<RequirementCandidate, 'source'>;
+export interface RequirementSources {
+  directives?: readonly DirectiveRow[];
+  intake?: readonly IntakeItem[];
+  grounding?: readonly IncomingRequirement[];
+  coordination?: readonly IncomingRequirement[];
+  linear?: readonly IncomingRequirement[];
+}
+export interface RequirementDecision {
+  candidate: RequirementCandidate;
+  sources: RequirementCandidate[];
+  status: 'adopted' | 'would-adopt' | 'proposal';
+  cellId?: string;
+  version?: string;
+  rubric: string;
+  reason?: string;
+}
+export interface RequirementFunnelResult {
+  counts: Record<RequirementSource, number>;
+  candidates: number;
+  decisions: RequirementDecision[];
+  unlinkedDirectives: RequirementCandidate[];
+  briefItems: AddBriefItem[];
+}
+export interface FunnelOptions {
+  sources: RequirementSources;
+  /** Older directives are only checked for unlinked P0 backlog, not counted as today's arrivals. */
+  historicalDirectives?: readonly DirectiveRow[];
+  cells: readonly { version: string; item: ChecklistItem }[];
+  now: Date;
+  mode?: 'shadow' | 'live';
+  /** Required for live external adoption; the unresolved daily limit has no implicit value. */
+  dailyCap?: number;
+  adoptedToday?: number;
+  allowedLicenses?: readonly string[];
+  placement?: PlacementDeps;
+  adopt?: (candidate: RequirementCandidate, version: string, cellId: string, evidence: string) => void;
+}
+
+/** How many of the last 24 hours' unlinked directives the single P0 brief line names (the full backlog is one count). */
+export const UNLINKED_DIRECTIVES_SHOWN = 5;
+/** ABSORB-ADOPT daily limit when config sets none (OP 10-06 22:59 · the cell's own number). */
+export const DEFAULT_DAILY_CAP = 5;
+/** Directive row fields the funnel reads — kept local because `src/directives/directive-index` is excluded from the public export. */
+export interface DirectiveRow { ts: string; track: string | null; text: string; source_file: string; line_no: number }
+
+/** Loads the private directive index at run time only (same pattern as decisions/proact-meter), so public builds bundle cleanly. */
+function openDirectiveIndex(stateDir: string): { dailyRequirements(since: string, until: string): DirectiveRow[]; close(): void } {
+  const spec = ['..', 'directives', 'directive-index.js'].join('/');
+  const mod = createRequire(import.meta.url)(spec) as { DirectiveIndex: new (o: { stateDir?: string }) => ReturnType<typeof openDirectiveIndex> };
+  return new mod.DirectiveIndex({ stateDir });
+}
+
+const oneLine = (value: string) => value.replace(/\s+/g, ' ').trim();
+const idFor = (source: RequirementSource, key: string) => createHash('sha256').update(`${source}:${key}`).digest('hex').slice(0, 16);
+
+export function directiveCandidates(rows: readonly DirectiveRow[]): RequirementCandidate[] {
+  return rows.map(row => ({ id: idFor('directive', `${row.source_file}:${row.line_no}`), source: 'directive',
+    text: oneLine(row.text), link: `${row.source_file}#L${row.line_no}`, receivedAt: row.ts,
+    priority: 'P2', owner: row.track && /^[A-Z]{2,8}$/.test(row.track) ? row.track : 'OP' }));
+}
+export function intakeCandidates(rows: readonly IntakeItem[]): RequirementCandidate[] {
+  return rows.map(row => ({ id: row.id, source: 'intake', text: oneLine(row.text || row.title || ''),
+    link: row.url || `intake:${row.id}`, receivedAt: row.observedAt }));
+}
+export function suppliedCandidates(source: 'grounding' | 'coordination' | 'linear', rows: readonly IncomingRequirement[]): RequirementCandidate[] {
+  return rows.map(row => ({ ...row, source, text: oneLine(row.text) }));
+}
+
+function linkFor(candidate: RequirementCandidate, cells: FunnelOptions['cells']): FunnelOptions['cells'][number] | undefined {
+  return cells.find(({ item }) => !!candidate.link && !!item.evidence && item.evidence.includes(candidate.link));
+}
+function gate(candidate: RequirementCandidate, options: FunnelOptions, used: number): string | null {
+  if (candidate.priority !== 'P1' && candidate.priority !== 'P2') return 'P1/P2 판정 없음';
+  if (candidate.priority === 'P1' && !candidate.deadlineVersion) return 'P1 마감 판 미확인';
+  if (candidate.risk === undefined || !Number.isFinite(candidate.risk) || candidate.risk > 1 || candidate.risk < 0) return '위험≤1 미확인';
+  if (candidate.cost !== 0) return '돈 0 미확인';
+  if (candidate.security !== 0) return '보안 0 미확인';
+  if (!candidate.license || !options.allowedLicenses?.includes(candidate.license)) return '허용 라이선스 미확인';
+  if (candidate.patentPrivatePath !== false) return '특허 비공개 경로 무접촉 미확인';
+  if (options.dailyCap === undefined || !Number.isSafeInteger(options.dailyCap) || options.dailyCap < 0) return '하루 상한 미설정';
+  if (used >= options.dailyCap) return '하루 상한 도달';
+  return null;
+}
+
+/** RUBRIC-PLACE: use the release placement engine's priority, deadline, capacity and predecessor checks, not an invented score. */
+export function runRequirementFunnel(options: FunnelOptions): RequirementFunnelResult {
+  const { sources, cells, now } = options;
+  const arrivals = [
+    ...directiveCandidates(sources.directives ?? []), ...intakeCandidates(sources.intake ?? []),
+    ...suppliedCandidates('grounding', sources.grounding ?? []),
+    ...suppliedCandidates('coordination', sources.coordination ?? []),
+    ...suppliedCandidates('linear', sources.linear ?? []),
+  ].filter(candidate => candidate.text && Number.isFinite(Date.parse(candidate.receivedAt)) && Date.parse(candidate.receivedAt) <= now.getTime());
+  const counts: RequirementFunnelResult['counts'] = { directive: 0, intake: 0, grounding: 0, coordination: 0, linear: 0 };
+  for (const candidate of arrivals) counts[candidate.source]++;
+  const groups = new Map<string, RequirementCandidate[]>();
+  for (const candidate of arrivals) {
+    const key = normalizeClaim(candidate.text);
+    groups.set(key, [...(groups.get(key) ?? []), candidate]);
+  }
+  const decisions: RequirementDecision[] = [];
+  let used = options.adoptedToday ?? 0;
+  for (const members of groups.values()) {
+    members.sort((a, b) => a.receivedAt.localeCompare(b.receivedAt));
+    const candidate = members.find(member => member.source === 'directive') ?? members[0]!;
+    const linked = members.map(member => linkFor(member, cells)).find(Boolean);
+    const evidence = members.map(member => `${member.link} (${member.receivedAt})`).join(' · ');
+    if (linked) {
+      decisions.push({ candidate, sources: members, status: 'adopted', cellId: linked.item.id, version: linked.version,
+        rubric: `RUBRIC-PLACE ${linked.item.priority ?? '미지정'} · ${linked.version}` });
+      continue;
+    }
+    const isDirective = members.some(member => member.source === 'directive');
+    const reason = isDirective ? null : gate(candidate, options, used);
+    if (reason) {
+      decisions.push({ candidate, sources: members, status: 'proposal', reason, rubric: `ABSORB-ADOPT · ${reason}` });
+      continue;
+    }
+    const cellId = candidate.id;
+    const priority = candidate.priority ?? 'P1';
+    const rubricInput = { id: cellId, title: candidate.text, owner: candidate.owner ?? 'OP', priority,
+      predecessors: [], ...(priority === 'P1' && candidate.deadlineVersion ? { deadlineVersion: candidate.deadlineVersion } : {}) };
+    let placement: ReturnType<typeof placeCell>;
+    try { placement = placeCell(rubricInput, { ...options.placement, now, dryRun: true }); }
+    catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      decisions.push({ candidate, sources: members, status: isDirective ? 'would-adopt' : 'proposal', reason,
+        rubric: `RUBRIC-PLACE · 판 배치 보류: ${reason}` });
+      continue;
+    }
+    const rubric = `RUBRIC-PLACE ${priority} · ${placement.version}: ${placement.reason}`;
+    if (options.mode === 'live') {
+      if (!options.adopt) throw new Error('편입 기록자가 설정되지 않았다');
+      options.adopt(candidate, placement.version, cellId, evidence);
+    }
+    decisions.push({ candidate, sources: members, status: options.mode === 'live' ? 'adopted' : 'would-adopt',
+      cellId, version: placement.version, rubric });
+    if (!isDirective) used++;
+  }
+  const unlinkedDirectives = [...directiveCandidates(options.historicalDirectives ?? []).filter(candidate =>
+    candidate.text && Number.isFinite(Date.parse(candidate.receivedAt)) && Date.parse(candidate.receivedAt) <= now.getTime()
+    && !linkFor(candidate, cells) && !arrivals.some(arrival => arrival.id === candidate.id)),
+    ...decisions.filter(decision => decision.status !== 'adopted')
+      .flatMap(decision => decision.sources.filter(source => source.source === 'directive'))]
+    .sort((a, b) => a.receivedAt.localeCompare(b.receivedAt));
+  const briefItems: AddBriefItem[] = [];
+  const summary = `들어온 요구 ${groups.size}(문별 지시 ${counts.directive} · 흡수 ${counts.intake} · 그라운딩 ${counts.grounding} · 조율 ${counts.coordination} · Linear ${counts.linear}) · 편입 ${decisions.filter(d => d.status === 'adopted').length} · 했을 것 ${decisions.filter(d => d.status === 'would-adopt').length} · 제안 ${decisions.filter(d => d.status === 'proposal').length}`;
+  if (arrivals.length || unlinkedDirectives.length) briefItems.push({ text: summary, domain: '흡수', priority: 'P1', source: 'requirement-funnel' });
+  for (const decision of decisions) {
+    const { candidate } = decision;
+    const status = decision.status === 'adopted' ? `편입 ${decision.cellId} · 판 ${decision.version}`
+      : decision.status === 'would-adopt' ? decision.version ? `했을 것 ${decision.cellId} · 판 ${decision.version}` : '편입 대상 · 판 배치 대기'
+        : `제안: ${decision.reason}`;
+    briefItems.push({ text: `${status} · ${candidate.text} · ${decision.rubric}`, domain: decision.status === 'proposal' ? '흡수' : '판',
+      priority: 'P1', source: 'requirement-funnel', evidence: decision.sources.map(member => `${member.link} (${member.receivedAt})`).join(' · ') });
+  }
+  // OP 10-06 22:59: the backlog can hold the whole directive history, so only the last 24 hours get named (one P0 line);
+  // the full backlog is a single count. Nothing recent → the count alone, at P1, so history cannot flood the brief.
+  if (unlinkedDirectives.length) {
+    const recent = unlinkedDirectives.filter(directive => now.getTime() - Date.parse(directive.receivedAt) <= 24 * 3_600_000);
+    const named = recent.slice(0, UNLINKED_DIRECTIVES_SHOWN);
+    const rest = recent.length - named.length;
+    const total = `전체 누계 ${unlinkedDirectives.length}`;
+    briefItems.push(recent.length
+      ? { text: `대표 지시 중 아직 칸 없는 것 — 최근 24시간 ${recent.length}: ${named.map(directive => `${directive.text} (${directive.receivedAt})`).join(' · ')}${rest > 0 ? ` · 외 ${rest}` : ''} · ${total}`,
+        domain: '판', priority: 'P0', source: 'requirement-funnel', evidence: named.map(directive => directive.link).join(' · ') }
+      : { text: `대표 지시 중 아직 칸 없는 것 — 최근 24시간 0 · ${total}`, domain: '판', priority: 'P1', source: 'requirement-funnel' });
+  }
+  return { counts, candidates: groups.size, decisions, unlinkedDirectives, briefItems };
+}
+
+/** Existing ledgers only; no source collector or sender is started here. */
+export function readRequirementFunnel(options: { stateDir?: string; now?: Date; mode?: 'shadow' | 'live'; dailyCap?: number;
+  allowedLicenses?: readonly string[]; grounding?: readonly IncomingRequirement[]; coordination?: readonly IncomingRequirement[];
+  linear?: readonly IncomingRequirement[]; placement?: PlacementDeps } = {}): RequirementFunnelResult {
+  const stateDir = options.stateDir ?? elanousStateRoot();
+  const now = options.now ?? new Date();
+  const config = (getUserConfig().raw.intake as { requirementFunnel?: { mode?: 'shadow' | 'live'; dailyCap?: number; allowedLicenses?: string[] } } | undefined)?.requirementFunnel;
+  const mode = options.mode ?? config?.mode ?? 'shadow';
+  if (mode !== 'shadow' && mode !== 'live') throw new Error(`알 수 없는 요구 깔때기 모드: ${mode}`);
+  const dailyCap = options.dailyCap ?? config?.dailyCap ?? DEFAULT_DAILY_CAP;
+  const allowedLicenses = options.allowedLicenses ?? config?.allowedLicenses;
+  let directives: DirectiveRow[] = [];
+  let historicalDirectives: DirectiveRow[] = [];
+  const since = new Date(Date.parse(`${dateKey(now, { timeZone: 'Asia/Seoul' })}T00:00:00+09:00`)).toISOString();
+  try {
+    const index = openDirectiveIndex(stateDir);
+    try {
+      directives = index.dailyRequirements(since, now.toISOString());
+      historicalDirectives = index.dailyRequirements('1970-01-01T00:00:00.000Z', since);
+    } finally { index.close(); }
+  } catch (error) {
+    // Public builds have no directive index; the other doors still report.
+    debug.log('intake.requirement-funnel', 'directives-unavailable', { error: error instanceof Error ? error.message : String(error) });
+  }
+  const schedules = listSchedules();
+  const cells = schedules.flatMap(schedule => listChecklist(schedule.version).items.map(item => ({ version: schedule.version, item })));
+  const ledger = loadIntakeLedger(stateDir);
+  const day = dateKey(now, { timeZone: 'Asia/Seoul' });
+  const todayCount = cells.filter(({ item }) => {
+    const adoptedAt = item.evidence?.match(/ABSORB-ADOPT@(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)/)?.[1];
+    return adoptedAt && dateKey(adoptedAt, { timeZone: 'Asia/Seoul' }) === day;
+  }).length;
+  const cardRequests: Record<'coordination' | 'linear', IncomingRequirement[]> = { coordination: [], linear: [] };
+  if (existsSync(cardIndexPath(stateDir))) {
+    const cards = new CardStore(stateDir, true);
+    try {
+      for (const card of cards.listCards()) {
+        const section = card.sections.find(entry => entry.key === 'intake');
+        if (!section) continue;
+        let raw: unknown;
+        try { raw = JSON.parse(section.content); } catch { continue; }
+        if (!raw || typeof raw !== 'object') continue;
+        const input = raw as { source?: string; text?: string; ref?: string; replyTo?: { surface?: string } };
+        const source = input.source === 'linear' ? 'linear' : input.source === 'coordination' ? 'coordination' : null;
+        if (!source || !input.text) continue;
+        cardRequests[source].push({ id: card.goalId, text: oneLine(input.text.split('\n')[0] ?? ''),
+          link: input.ref || card.goalId, receivedAt: card.createdAt });
+      }
+    } finally { cards.close(); }
+  }
+  const fromQueue = (name: string): IncomingRequirement[] => {
+    const path = join(stateDir, 'intake', name);
+    if (!existsSync(path)) return [];
+    return readFileSync(path, 'utf8').split('\n').flatMap(line => {
+      if (!line.trim()) return [];
+      try {
+        const value: unknown = JSON.parse(line);
+        if (!value || typeof value !== 'object') return [];
+        const row = value as Partial<IncomingRequirement> & { path?: string };
+        const item = row.id ? ledger.items.get(row.id) : undefined;
+        const text = row.text ?? item?.text ?? item?.title;
+        const link = row.link ?? item?.url ?? row.path;
+        const receivedAt = row.receivedAt ?? (row as { at?: string }).at ?? item?.observedAt;
+        return typeof row.id === 'string' && typeof text === 'string' && typeof link === 'string' && typeof receivedAt === 'string'
+          ? [{ ...row, id: row.id, text, link, receivedAt }] : [];
+      } catch { return []; }
+    });
+  };
+  // The grounding queue and the card store are cumulative; only today's rows are today's arrivals.
+  const today = (rows: readonly IncomingRequirement[]) => rows.filter(row => Date.parse(row.receivedAt) >= Date.parse(since));
+  return runRequirementFunnel({ sources: { directives, intake: [...ledger.items.values()].filter(item => Date.parse(item.observedAt) >= Date.parse(since)),
+    grounding: today(options.grounding ?? fromQueue('outbox/grounding.jsonl')),
+    coordination: today(options.coordination ?? cardRequests.coordination), linear: today(options.linear ?? cardRequests.linear) }, historicalDirectives, cells, now, mode,
+    dailyCap, adoptedToday: todayCount, allowedLicenses, placement: { ...options.placement, schedules },
+    adopt: (candidate, version, cellId, evidence) => {
+      placeCell({ id: cellId, title: candidate.text, owner: candidate.owner ?? 'OP', priority: candidate.priority ?? 'P1',
+        predecessors: [], ...(candidate.deadlineVersion ? { deadlineVersion: candidate.deadlineVersion } : {}) }, { ...options.placement, now, schedules });
+      setItem(version, cellId, { evidence: `${evidence} · ABSORB-ADOPT@${now.toISOString()}` }, 'OP');
+    } });
+}
+
+// ── `intake candidates` — 읽기 전용 요구 후보 목록(지시·흡수·소원 · 명시 루브릭만 점수) ──
+export interface FunnelCandidate {
+  source: 'directive' | 'intake' | 'wish';
+  id: string;
+  title: string;
+  score: number | null;
+  grade: 'P1' | 'P2' | 'P3' | 'P4' | null;
+}
+/** The candidate list keys directives by session — the funnel's local `DirectiveRow` plus the index's `session_id`. */
+export type FunnelDirectiveRow = DirectiveRow & { session_id: string };
+
+function funnelCandidate(source: FunnelCandidate['source'], id: string, title: string, original: string): FunnelCandidate {
+  const rubric = parseRubric(original);
+  const score = rubric === null ? null : rubricScore(rubric);
+  return { source, id, title: title.split(/\r?\n/, 1)[0]!.slice(0, 80), score, grade: score === null ? null : rubricGrade(score) };
+}
+
+export function collectFunnelCandidates({ directives, intakeItems, cards }: {
+  directives: readonly FunnelDirectiveRow[];
+  intakeItems: readonly IntakeItem[];
+  cards: readonly TaskCard[];
+}): FunnelCandidate[] {
+  return [
+    ...directives.map((row) => funnelCandidate('directive', `${row.session_id}:${row.line_no}`, row.text, row.text)),
+    ...intakeItems.filter((item) => item.status !== 'discarded')
+      .map((item) => funnelCandidate('intake', item.id, item.title ?? item.text ?? item.url ?? '', [item.title, item.text, item.url].filter(Boolean).join('\n'))),
+    ...cards.filter((card) => card.status === 'open' && card.goalId.startsWith('wish:'))
+      .map((card) => funnelCandidate('wish', card.goalId, card.title, card.title)),
+  ].sort((a, b) => a.score === null && b.score === null ? 0
+    : a.score === null ? 1 : b.score === null ? -1 : b.score - a.score);
+}

package/src/knowledge/know-find.ts

@@ -1,6 +1,6 @@
 import { createRequire } from 'node:module';
 import { LessonLedger, type LessonRow } from '../lessons/lesson-ledger.js';
-import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { DecisionLedger, type DecisionEntry, type SeatDecisionRecord } from '../decisions/decision-ledger.js';
 import { devVersion, listChecklist, type Checklist } from '../release-loop/checklist.js';
 import { debug } from '../debug/log.js';
 
@@ -31,6 +31,7 @@ export interface KnowResult {
 export interface KnowFindDeps {
   directives: (query: string) => DirectiveRow[];
   decisions: () => DecisionEntry[];
+  seatDecisions: () => SeatDecisionRecord[];
   checklist: (version: string) => Checklist;
   lessons: (query: string) => LessonRow[];
   versions: () => string[];
@@ -49,6 +50,7 @@ const defaults: KnowFindDeps = {
     try { return index.search(query); } finally { index.close(); }
   },
   decisions: () => new DecisionLedger().list({ status: 'all' }),
+  seatDecisions: () => new DecisionLedger().seatReport(),
   checklist: (version) => listChecklist(version),
   lessons: (query) => new LessonLedger().find(query),
   versions,
@@ -84,6 +86,13 @@ export function knowFind(query: string, deps: Partial<KnowFindDeps> = {}): KnowR
         ref: row.refs?.[0] ?? `decisions show ${row.id}` });
     }
   });
+  attempt('decision', () => {
+    for (const row of read.seatDecisions()) {
+      if (!matches([row.title, row.decision, row.delegation].join(' '), words)) continue;
+      rows.push({ source: 'decision', id: row.id, title: row.title, status: 'seat-posthoc',
+        at: row.decidedAt ?? row.recordedAt, current: false, ref: `decisions seat-report --seat ${row.seat}` });
+    }
+  });
   attempt('checklist', () => {
     for (const version of new Set(read.versions())) {
       for (const row of read.checklist(version).items) {

package/src/loops/budget.ts

@@ -61,3 +61,39 @@ export function decideSpawn({ seat, running, caps, gate, injectedCap }: SpawnBud
     ? { allow: true, reason: 'within-cap', cap }
     : { allow: false, reason: 'seat-cap', cap };
 }
+
+/** SEAT-CAP-STALE: why a run or a queue row is left out of a seat's running count (counting only — nothing is stopped). */
+export type SeatCapExclusionReason = 'stale' | 'soft-stopped' | 'unknown-seat' | 'dead-row';
+export const SEAT_CAP_STALE_RUN_MINUTES = 30;
+export const SEAT_CAP_UNKNOWN_SEAT_CAP = 2;
+/** A just-launched row has no process yet; it keeps its seat for this long. */
+export const SEAT_CAP_LAUNCH_GRACE_MINUTES = 5;
+
+export type SeatCapSubject =
+  | { kind: 'run'; seat?: OrchestratorSeat; progressAt?: number; stopReason?: string }
+  | { kind: 'row'; status: string; receipt: 'started' | 'finished' | 'not-started' | null; live: boolean; launchedAt?: number };
+
+export type SeatCapExclusion = { reason: SeatCapExclusionReason; idleMin: number | null } | null;
+
+/**
+ * Pure judgement: null = the subject holds a seat. A run without a seat goes to the unknown-seat bucket; a run whose
+ * supervisor already stopped (awaiting harvest) or whose last progress is older than staleRunMinutes is excluded; a
+ * launched row with no live process past the launch grace is a dead row. A run with no progress signal still counts.
+ */
+export function seatCapExclusion(subject: SeatCapSubject, now: number,
+  { staleRunMinutes = SEAT_CAP_STALE_RUN_MINUTES, launchGraceMinutes = SEAT_CAP_LAUNCH_GRACE_MINUTES }:
+  { staleRunMinutes?: number; launchGraceMinutes?: number } = {}): SeatCapExclusion {
+  const minutes = (at: number | undefined): number | null =>
+    at !== undefined && Number.isFinite(at) ? Math.max(0, Math.floor((now - at) / 60_000)) : null;
+  if (subject.kind === 'row') {
+    if (subject.status !== 'launched' && subject.status !== 'launching') return null;
+    if (subject.live || subject.receipt === 'finished' || subject.receipt === 'not-started') return null;
+    const idle = minutes(subject.launchedAt);
+    return idle !== null && now - subject.launchedAt! >= launchGraceMinutes * 60_000 ? { reason: 'dead-row', idleMin: idle } : null;
+  }
+  const idle = minutes(subject.progressAt);
+  if (!subject.seat) return { reason: 'unknown-seat', idleMin: idle };
+  if (subject.stopReason) return { reason: 'soft-stopped', idleMin: idle };
+  if (idle !== null && now - subject.progressAt! >= staleRunMinutes * 60_000) return { reason: 'stale', idleMin: idle };
+  return null;
+}

package/src/loops/orchestrator/degradation.ts

@@ -0,0 +1,57 @@
+// COORD-HA (0.2.19) — the signal the orchestrator tick reads for its degradation ladder (RFC loop map §A8b ④⑤):
+// L1 = no usable LLM (rules only) · L2 = the task board cannot take a write (no new assignment). The tick already acts on
+// `TickDeps.degradation`; until now nothing supplied it in production. Each probe answers «false» only on a measured
+// failure — an unknown is not a degradation.
+import { existsSync, mkdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { Database } from 'bun:sqlite';
+import { cardIndexPath, taskCardsDir } from '../../task-cards/card-store.js';
+import { resolveUsableLlm } from '../../llm/usable-llm.js';
+
+export interface DegradationSignal { llm: boolean; board: boolean; why: string[] }
+
+/** The task board takes a write: its folder is a directory a file can be created in (created and removed — a permission
+ *  bit is not proof · review r1), and its index can take a write lock (busy 2 s · rolled back). */
+export function probeBoardWritable(root: string): { ok: boolean; why?: string } {
+  const dir = taskCardsDir(root);
+  try {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    if (!statSync(dir).isDirectory()) return { ok: false, why: 'board dir not writable: not a directory' };
+    // A fresh name each time — a leftover from a crashed probe can never make a writable board look full (review r2).
+    const probe = join(dir, `.degradation-probe-${randomUUID()}`);
+    try { writeFileSync(probe, '', { flag: 'wx', mode: 0o600 }); }
+    finally { rmSync(probe, { force: true }); }
+  } catch (error) { return { ok: false, why: `board dir not writable: ${(error as NodeJS.ErrnoException).code ?? String(error)}` }; }
+  const index = cardIndexPath(root);
+  // No index yet: the card store creates it on first open — a writable folder is enough.
+  if (!existsSync(index)) return { ok: true };
+  let db: Database | undefined;
+  try {
+    db = new Database(index, { readwrite: true, create: false });
+    db.exec('PRAGMA busy_timeout = 2000');
+    db.exec('BEGIN IMMEDIATE');
+    db.exec('ROLLBACK');
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, why: `board index write lock: ${String(error instanceof Error ? error.message : error).slice(0, 160)}` };
+  } finally { try { db?.close(); } catch { /* closing a failed handle is best effort */ } }
+}
+
+export interface DegradationDeps {
+  usableLlm?: () => { usable: boolean; why: string };
+  board?: (root: string) => { ok: boolean; why?: string };
+}
+
+export function probeDegradation(root: string, deps: DegradationDeps = {}): DegradationSignal {
+  const why: string[] = [];
+  let llm = true;
+  try {
+    const usable = (deps.usableLlm ?? resolveUsableLlm)();
+    llm = usable.usable;
+    if (!llm) why.push(`llm: ${usable.why}`);
+  } catch (error) { why.push(`llm unknown: ${String(error).slice(0, 120)}`); }
+  const board = (deps.board ?? probeBoardWritable)(root);
+  if (!board.ok) why.push(board.why ?? 'board not writable');
+  return { llm, board: board.ok, why };
+}

package/src/loops/orchestrator/finish-rate.ts

@@ -1,8 +1,9 @@
 import { execFileSync } from 'node:child_process';
-import { readdirSync, realpathSync, statSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { debug } from '../../debug/log.js';
 import { loadRunLedger, resolveFederatedRunLedgerTargets } from '../../self-implement/run-ledger.js';
+import { withFileLockSync } from '../../storage/file-lock.js';
 import type { LogTarget } from '../../cli/logs-cli.js';
 
 const DAY_MS = 24 * 60 * 60 * 1_000;
@@ -14,6 +15,8 @@ export type FinishMetric = 'launched' | 'landed' | 'landingRate' | 'staleDrafts'
 export type FinishMetrics = {
   launched: number | null;
   launchedUnreadable?: number;
+  /** Launched Pod runs whose child ledger never came back (`pod-ledger-incomplete`) — counted in `launched`, result unknown. */
+  launchedIncomplete?: number;
   landed: number | null;
   landingRate: number | null;
   staleDrafts: number | null;
@@ -24,8 +27,81 @@ export type FinishMetrics = {
 export type FinishAdvice = { finishSlots: number; launchSlots: number; state: 'healthy' | 'backlogged' | 'unknown'; reasons: string[] };
 export type FinishThresholds = { landingRate?: number; staleDrafts?: number; conflictRatio?: number };
 
+export type FinishTrend = 'worsening' | 'improving' | 'flat' | 'unknown';
+export type FinishTrendInput = Pick<FinishMetrics, 'landingRate' | 'staleDrafts' | 'conflictRatio'>;
+export type FinishHistoryRow = {
+  hour: string; at: string; launched: number | null; landed: number | null;
+  landingRate: number | null; staleDrafts: number | null; conflictRatio: number | null; trend: FinishTrend;
+};
+
+/** FINISH-RATE 추세 — landingRate 는 내려가면 나쁨 · staleDrafts·conflictRatio 는 올라가면 나쁨.
+ *  양쪽 다 유한한 숫자인 지표만 비교한다(못 잰 값은 좋음도 나쁨도 아니다) · 임의 임계 없음.
+ *  나쁨 수 > 좋음 수 = worsening · 작으면 improving · 같으면 flat · 비교한 지표가 0 이면 unknown. */
+export function finishTrend(previous: FinishTrendInput | null, current: FinishTrendInput): FinishTrend {
+  if (!previous) return 'unknown';
+  let compared = 0, worse = 0, better = 0;
+  for (const key of ['landingRate', 'staleDrafts', 'conflictRatio'] as const) {
+    const before = previous[key], after = current[key];
+    if (typeof before !== 'number' || !Number.isFinite(before) || typeof after !== 'number' || !Number.isFinite(after)) continue;
+    compared++;
+    const delta = key === 'landingRate' ? before - after : after - before;
+    if (delta > 0) worse++;
+    else if (delta < 0) better++;
+  }
+  if (compared === 0) return 'unknown';
+  return worse > better ? 'worsening' : worse < better ? 'improving' : 'flat';
+}
+
+export function finishHistoryPath(root: string): string {
+  return join(root, 'harness', 'finish-history.jsonl');
+}
+
+/** «한 시간 한 줄» 이력 — 같은 UTC 시간 줄이 이미 있으면 안 쓴다(null) · trend 는 지금보다 이른 가장 최근 시간 줄 대비.
+ *  읽을 수 없는 줄은 건너뛴다(이력 한 줄이 깨졌다고 측정을 멈추지 않는다). 쓰기 실패는 호출자에게 던진다. */
+export function recordFinishHistory(root: string, metrics: FinishMetrics, now: Date): FinishHistoryRow | null {
+  const path = finishHistoryPath(root);
+  const hour = now.toISOString().slice(0, 13);
+  mkdirSync(join(root, 'harness'), { recursive: true });
+  // 확인과 덧붙이기를 한 잠금 안에서 — 같은 root 를 쓰는 두 틱이 같은 시간에 둘 다 «없음»을 보고 두 줄을 쓰지 않게.
+  const row = withFileLockSync(`${path}.lock`, (): FinishHistoryRow | null => {
+    const rows: FinishHistoryRow[] = [];
+    let text = '';
+    if (existsSync(path)) {
+      text = readFileSync(path, 'utf8');
+      for (const line of text.split('\n')) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line) as FinishHistoryRow;
+          if (parsed && typeof parsed.hour === 'string') rows.push(parsed);
+        } catch { /* a broken line is skipped */ }
+      }
+    }
+    if (rows.some((existing) => existing.hour === hour)) return null;
+    // 앞 시간 = 지금보다 이른 줄 중 «가장 최근 UTC 시간»(파일 순서가 아니다 — 늦게 덧붙은 옛 시간 줄이 있을 수 있다) · 같은 시간이면 마지막 줄.
+    let previous: FinishHistoryRow | null = null;
+    for (const existing of rows) if (existing.hour < hour && (!previous || existing.hour >= previous.hour)) previous = existing;
+    const next: FinishHistoryRow = {
+      hour, at: now.toISOString(), launched: metrics.launched, landed: metrics.landed,
+      landingRate: metrics.landingRate, staleDrafts: metrics.staleDrafts, conflictRatio: metrics.conflictRatio,
+      trend: finishTrend(previous, metrics),
+    };
+    // 부분 쓰기로 끝 개행이 없으면 먼저 보정한다 — 새 줄이 깨진 꼬리에 붙어 둘 다 못 읽게 되지 않게.
+    appendFileSync(path, `${text && !text.endsWith('\n') ? '\n' : ''}${JSON.stringify(next)}\n`);
+    return next;
+  });
+  if (!row) return null;
+  try {
+    debug.log('loop.orchestrator', 'finish-history', {
+      hour, trend: row.trend, landingRate: row.landingRate, staleDrafts: row.staleDrafts, conflictRatio: row.conflictRatio,
+    });
+  } catch { /* the row is written; observation is fail-soft */ }
+  return row;
+}
+
 type Start = { runId: string; startedAt: string };
-type StartObservation = { starts: readonly Start[]; unreadable: readonly { runId: string; reason: string }[]; unreadableDirectories?: number };
+type StartObservation = { starts: readonly Start[]; unreadable: readonly { runId: string; reason: string }[]; unreadableDirectories?: number;
+  /** Runs counted as launched although their child ledger never came back (reason = the host marker's data.reason). */
+  incomplete?: readonly { runId: string; reason: string }[] };
 type Pr = { number: number; headRefName: string; mergedAt?: string; createdAt?: string; mergeable?: string; labels?: { name: string }[] };
 export interface MeasureFinishDeps {
   listStarts?: (cutoff: number) => StartObservation;
@@ -41,6 +117,7 @@ function defaultListStarts(cutoff: number, targets?: readonly LogTarget[]): Star
   let unreadableDirectories = 0;
   let unresolvedDirectories = 0;
   const launchOnlyIds = new Set<string>();
+  const incomplete = new Map<string, { runId: string; reason: string }>();
   for (const { ledgerDirectory } of resolveFederatedRunLedgerTargets({ includeTest: true, ...(targets ? { targets } : {}) })) {
     let dir: string;
     try {
@@ -71,6 +148,20 @@ function defaultListStarts(cutoff: number, targets?: readonly LogTarget[]): Star
         continue;
       }
       const start = entries.find(entry => entry.event === 'start');
+      // ORCH-LIVE-1008 ①: the host writes `pod-ledger-incomplete` on a Pod child run's ledger when the child's own ledger
+      // never came back (OOM · logs unavailable · partial collection). The Job did run — it is a launch with an unknown
+      // result, not a ledger without a start. Its time is the marker's timestamp, else the ledger mtime.
+      const incompleteMarker = !start ? entries.find(entry => entry.event === 'pod-ledger-incomplete') : undefined;
+      if (incompleteMarker) {
+        // Only a real `start` (from any directory) outranks the marker; a host launch-only record does not — the same
+        // run read as launch-only first is still a launch whose result never came back.
+        if (starts.has(runId) && !launchOnlyIds.has(runId)) continue;
+        if (!starts.has(runId)) starts.set(runId, { runId, startedAt: incompleteMarker.timestamp ?? new Date(statSync(path).mtimeMs).toISOString() });
+        const why = (incompleteMarker.data as { reason?: unknown } | undefined)?.reason;
+        incomplete.set(runId, { runId, reason: typeof why === 'string' && why ? why : 'unknown' });
+        unreadable.delete(runId);
+        continue;
+      }
       // A Pod-dispatched launch leaves only a host launch record (launch-quota-policy · author-on-pod-receipt) — the run
       // itself starts inside the Pod. That is still a launch: its time is the record's timestamp, else the ledger mtime.
       const launchRecord = !start ? entries.find(entry => LAUNCH_ONLY_EVENTS.has(entry.event)) : undefined;
@@ -85,12 +176,14 @@ function defaultListStarts(cutoff: number, targets?: readonly LogTarget[]): Star
       if (launchRecord) launchOnlyIds.add(runId); else launchOnlyIds.delete(runId);
       starts.set(runId, { runId, startedAt });
       unreadable.delete(runId);
+      incomplete.delete(runId);
     }
   }
   debug.log('loop.orchestrator', 'finish-launch-population', {
     directories: directories.size + unresolvedDirectories, launched: starts.size, launchOnly: launchOnlyIds.size, childLedgers: childLedgers.size, unreadable: unreadable.size,
+    ...(incomplete.size > 0 ? { incomplete: incomplete.size } : {}),
   });
-  return { starts: [...starts.values()], unreadable: [...unreadable.values()], unreadableDirectories };
+  return { starts: [...starts.values()], unreadable: [...unreadable.values()], unreadableDirectories, incomplete: [...incomplete.values()] };
 }
 
 function defaultRunGh(args: string[]): string {
@@ -112,6 +205,7 @@ export function measureFinish(deps: MeasureFinishDeps = {}, now: Date = new Date
   const cutoff = now.getTime() - DAY_MS;
   let launched: number | null = null;
   let launchedUnreadable = 0;
+  let launchedIncomplete = 0;
   let landed: number | null = null;
   let staleDrafts: number | null = null;
   let conflictRatio: number | null = null;
@@ -124,6 +218,14 @@ export function measureFinish(deps: MeasureFinishDeps = {}, now: Date = new Date
       || observation.unreadable.some(entry => !entry || typeof entry.runId !== 'string' || typeof entry.reason !== 'string')) throw new Error('invalid run start observation');
     launched = new Set(observation.starts.filter(start => Date.parse(start.startedAt) >= cutoff && Date.parse(start.startedAt) <= now.getTime()).map(start => start.runId)).size;
     launchedUnreadable = observation.unreadable.length;
+    const incompleteRuns = (observation.incomplete ?? []).filter(entry => observation.starts.some(start => start.runId === entry.runId
+      && Date.parse(start.startedAt) >= cutoff && Date.parse(start.startedAt) <= now.getTime()));
+    launchedIncomplete = incompleteRuns.length;
+    if (launchedIncomplete > 0) {
+      const byReason: Record<string, number> = {};
+      for (const entry of incompleteRuns) byReason[entry.reason] = (byReason[entry.reason] ?? 0) + 1;
+      debug.log('loop.orchestrator', 'finish-ledger-incomplete', { count: launchedIncomplete, byReason, sample: incompleteRuns.slice(0, 5) });
+    }
     if (launchedUnreadable > 0) {
       reasons.launched = `${launchedUnreadable}개 원장 시작 줄 없음(하한값)`;
       debug.log('loop.orchestrator', 'finish-ledger-unreadable', { count: launchedUnreadable, sample: observation.unreadable.slice(0, 5) });
@@ -162,7 +264,7 @@ export function measureFinish(deps: MeasureFinishDeps = {}, now: Date = new Date
     : 'no harness runs launched in the last 24 hours';
   else if (landed > launched) reasons.landingRate = `landed exceeds launched — population mismatch (launched=${launched}, landed=${landed})`;
   else landingRate = landed / launched;
-  return { launched, ...(launchedUnreadable > 0 ? { launchedUnreadable } : {}), landed, landingRate, staleDrafts, conflictRatio, unknownMergeable, reasons };
+  return { launched, ...(launchedUnreadable > 0 ? { launchedUnreadable } : {}), ...(launchedIncomplete > 0 ? { launchedIncomplete } : {}), landed, landingRate, staleDrafts, conflictRatio, unknownMergeable, reasons };
 }
 
 /** Advice only: no launch cap, PR, or config is changed. */

package/src/loops/orchestrator/grid-place.ts

@@ -0,0 +1,11 @@
+interface GridCell { kind?: string }
+export interface GridHost { name: string; capabilities: ReadonlySet<string>; available: boolean }
+
+/** A proposal only: the caller owns the host inventory and the actual launch. */
+export function placeOnGrid(cell: GridCell, hosts: readonly GridHost[]): { host: string; reason?: never } | { host: null; reason: string } {
+  const kind = cell.kind ?? 'unknown';
+  const host = hosts.find(candidate => candidate.available && candidate.capabilities.has(kind));
+  if (host) return { host: host.name };
+  return { host: null, reason: hosts.some(candidate => candidate.capabilities.has(kind))
+    ? `no available host for ${kind}` : `no host with ${kind} capability` };
+}