elanous 0.2.13 → 0.2.15

package/src/domains/alert-audit.ts

@@ -0,0 +1,271 @@
+// 대표에게 가는 알림·브리핑 전수 재고 (ALERT-AUDIT).
+//
+// «전달 ok» 는 발송 시도 기록이다. 도착은 배송 원장의 채널 ok 한 건뿐이다.
+// 발송 설정이 꺼져 있으면 시도 기록만 남고 도착은 0건이 된다 — 그 칸을
+// claimed-without-arrival 로 표시한다. 같은 내용이 둘 이상의 채널·봇에
+// 도착하면 overlap, 레지스트리에 있는데 아무도 안 보내면 gap.
+
+import type { ScheduleRow } from './schedule-registry.js';
+import type { DeliveryRow } from '../nexus/outbound/delivery-ledger.js';
+
+export type AlertSenderKind = 'loop' | 'cron' | 'script';
+export type AlertMark = 'claimed-without-arrival' | 'overlap' | 'gap' | 'overlap-unknown' | 'none';
+
+export interface AlertSenderRef {
+  kind: AlertSenderKind;
+  id: string;
+}
+
+export interface AlertRegistrySender {
+  kind: AlertSenderKind;
+  id: string;
+  /** 대표에게 보내는 알림·브리핑이면 true. false 는 대조 모집단에서 빠진다. */
+  representative: boolean;
+  what: string;
+  when: string;
+  channel: string;
+  bot: string;
+  /** 같은 내용으로 겹치는지 가르는 키. 비면 겹침은 미상이다. */
+  contentKey?: string;
+}
+
+export interface AlertClaim {
+  sender: AlertSenderRef;
+  what: string;
+  when: string;
+  channel: string;
+  bot: string;
+  contentKey?: string;
+  /** «전달 ok» 류의 발송 기록. 도착 증거가 아니다. */
+  recordedOk: boolean;
+  /** 발송 기록 시각. 도착이 없을 때 표의 «언제»는 이 시각이다. */
+  at?: string;
+}
+
+export interface AlertArrival {
+  sender: AlertSenderRef;
+  what: string;
+  channel: string;
+  bot: string;
+  contentKey?: string;
+  /** 채널이 실제로 받았다고 원장에 남은 시각. */
+  arrivedAt: string;
+  ok: boolean;
+}
+
+export interface AlertAuditInput {
+  registry: readonly AlertRegistrySender[];
+  /** 크론 레지스트리. representative 크론 발신자가 여기 없으면 누락이다. */
+  crons: readonly Pick<ScheduleRow, 'id' | 'name' | 'cron' | 'command' | 'enabled'>[];
+  /** 루프 레지스트리 id. representative 루프 발신자가 여기 없으면 누락이다. */
+  loops: readonly { id: string }[];
+  claims: readonly AlertClaim[];
+  arrivals: readonly AlertArrival[];
+}
+
+export interface AlertAuditRow {
+  who: string;
+  senderKind: AlertSenderKind;
+  senderId: string;
+  what: string;
+  when: string;
+  channel: string;
+  bot: string;
+  lastArrivedAt: string | null;
+  marks: AlertMark[];
+}
+
+export interface AlertAudit {
+  rows: AlertAuditRow[];
+  /** 레지스트리 representative 발신자 중 크론·루프 대조에서 빠진 수. 스크립트는 대조 대상이 아니다. */
+  missingFromRegistry: number;
+  missingSenders: AlertSenderRef[];
+  claimedWithoutArrival: AlertAuditRow[];
+  overlaps: AlertAuditRow[];
+  gaps: AlertAuditRow[];
+  /** contentKey 를 모르는 도착이 있어 겹침을 판정하지 못한 행. */
+  overlapUnknown: AlertAuditRow[];
+  verdict: 'pass' | 'fail';
+}
+
+export interface DeliveryArrivalView {
+  sender: AlertSenderRef;
+  what: string;
+  channel: string;
+  bot: string;
+  contentKey?: string;
+}
+
+const MARK_ORDER: AlertMark[] = ['claimed-without-arrival', 'overlap', 'gap', 'overlap-unknown'];
+
+function senderKey(sender: AlertSenderRef): string {
+  return `${sender.kind}:${sender.id}`;
+}
+
+/** 세 표시(+미상)를 MARK_ORDER 순으로 남긴다. none 은 표시가 없을 때만. */
+export function markOrder(marks: readonly AlertMark[]): AlertMark[] {
+  const ordered = MARK_ORDER.filter(mark => marks.includes(mark));
+  return ordered.length ? ordered : ['none'];
+}
+
+function knownContentKey(item: { contentKey?: string }): string | null {
+  const key = item.contentKey?.trim();
+  return key ? key : null;
+}
+
+function latestIso(values: readonly string[]): string | null {
+  const finite = values.filter(value => Number.isFinite(Date.parse(value)));
+  if (!finite.length) return null;
+  return finite.reduce((best, value) => Date.parse(value) > Date.parse(best) ? value : best);
+}
+
+function marksOf(row: { claimedWithoutArrival: boolean; overlap: boolean; gap: boolean; overlapUnknown: boolean }): AlertMark[] {
+  return markOrder([
+    ...(row.claimedWithoutArrival ? ['claimed-without-arrival' as const] : []),
+    ...(row.overlap ? ['overlap' as const] : []),
+    ...(row.gap ? ['gap' as const] : []),
+    ...(row.overlapUnknown ? ['overlap-unknown' as const] : []),
+  ]);
+}
+
+/** 배송 원장에서 ok 채널만 도착으로 읽는다. 실패 채널·빈 채널은 도착이 아니다. */
+export function arrivalsFromDeliveries(
+  rows: readonly DeliveryRow[],
+  view: (row: DeliveryRow) => DeliveryArrivalView | null,
+): AlertArrival[] {
+  const arrivals: AlertArrival[] = [];
+  for (const row of rows) {
+    let channels: Array<{ type?: unknown; ok?: unknown; bot?: unknown }> = [];
+    try { channels = JSON.parse(row.channels) as typeof channels; } catch { channels = []; }
+    const mapped = view(row);
+    if (!mapped) continue;
+    const okChannels = channels.filter(channel => channel.ok === true);
+    if (!okChannels.length) continue;
+    const bots = [...new Set(okChannels.map(channel => typeof channel.bot === 'string' && channel.bot ? channel.bot : mapped.bot))];
+    for (const bot of bots) {
+      arrivals.push({
+        sender: mapped.sender,
+        what: mapped.what,
+        channel: mapped.channel,
+        bot,
+        ...(mapped.contentKey ? { contentKey: mapped.contentKey } : {}),
+        arrivedAt: row.ts,
+        ok: true,
+      });
+    }
+  }
+  return arrivals;
+}
+
+/** 발신자 전수를 한 장으로 접는다. 판정은 누락 0 이고, 세 표시는 행에 남는다. */
+export function auditAlerts(input: AlertAuditInput): AlertAudit {
+  const cronIds = new Set(input.crons.map(row => row.id));
+  const loopIds = new Set(input.loops.map(row => row.id));
+  const representative = input.registry.filter(sender => sender.representative);
+  const missingSenders = representative.filter(sender => {
+    if (sender.kind === 'cron') return !cronIds.has(sender.id);
+    if (sender.kind === 'loop') return !loopIds.has(sender.id);
+    return false;
+  }).map(sender => ({ kind: sender.kind, id: sender.id }));
+
+  const arrivalsBySender = new Map<string, AlertArrival[]>();
+  for (const arrival of input.arrivals) {
+    if (!arrival.ok) continue;
+    const key = senderKey(arrival.sender);
+    const list = arrivalsBySender.get(key) ?? [];
+    list.push(arrival);
+    arrivalsBySender.set(key, list);
+  }
+  const claimsBySender = new Map<string, AlertClaim[]>();
+  for (const claim of input.claims) {
+    const key = senderKey(claim.sender);
+    const list = claimsBySender.get(key) ?? [];
+    list.push(claim);
+    claimsBySender.set(key, list);
+  }
+
+  const overlapKeys = new Set<string>();
+  const byContent = new Map<string, Set<string>>();
+  for (const arrival of input.arrivals) {
+    if (!arrival.ok) continue;
+    const key = knownContentKey(arrival);
+    if (!key) continue;
+    const routes = byContent.get(key) ?? new Set<string>();
+    routes.add(`${arrival.channel}|${arrival.bot}`);
+    byContent.set(key, routes);
+    if (routes.size >= 2) overlapKeys.add(key);
+  }
+
+  const rows: AlertAuditRow[] = representative.map(sender => {
+    const key = senderKey(sender);
+    const arrivals = arrivalsBySender.get(key) ?? [];
+    const claims = claimsBySender.get(key) ?? [];
+    const recordedOk = claims.some(claim => claim.recordedOk);
+    const claimedWithoutArrival = recordedOk && arrivals.length === 0;
+    const gap = !recordedOk && arrivals.length === 0;
+    const registryKey = knownContentKey(sender);
+    const arrivalKeys = arrivals.map(arrival => arrival.contentKey !== undefined ? knownContentKey(arrival) : registryKey);
+    const claimKeys = claims.map(claim => claim.contentKey !== undefined ? knownContentKey(claim) : registryKey);
+    const overlap = arrivalKeys.some(contentKey => contentKey !== null && overlapKeys.has(contentKey));
+    const overlapUnknown = !overlap && (
+      arrivals.some((_, index) => arrivalKeys[index] === null)
+      || (arrivals.length === 0 && claims.some((_, index) => claimKeys[index] === null && claims[index]?.recordedOk))
+    );
+    const last = latestIso(arrivals.map(arrival => arrival.arrivedAt));
+    const recorded = claims.find(claim => claim.recordedOk) ?? claims[0];
+    const channel = arrivals[0]?.channel ?? recorded?.channel ?? sender.channel;
+    const bot = arrivals[0]?.bot ?? recorded?.bot ?? sender.bot;
+    const what = arrivals[0]?.what ?? recorded?.what ?? sender.what;
+    const when = last ?? recorded?.at ?? recorded?.when ?? sender.when;
+    return {
+      who: `${sender.kind}:${sender.id}`,
+      senderKind: sender.kind,
+      senderId: sender.id,
+      what,
+      when,
+      channel,
+      bot,
+      lastArrivedAt: last,
+      marks: marksOf({ claimedWithoutArrival, overlap, gap, overlapUnknown }),
+    };
+  }).sort((a, b) => a.who.localeCompare(b.who) || a.what.localeCompare(b.what));
+
+  const claimedWithoutArrival = rows.filter(row => row.marks.includes('claimed-without-arrival'));
+  const overlaps = rows.filter(row => row.marks.includes('overlap'));
+  const gaps = rows.filter(row => row.marks.includes('gap'));
+  const overlapUnknown = rows.filter(row => row.marks.includes('overlap-unknown'));
+  return {
+    rows,
+    missingFromRegistry: missingSenders.length,
+    missingSenders,
+    claimedWithoutArrival,
+    overlaps,
+    gaps,
+    overlapUnknown,
+    verdict: missingSenders.length === 0 ? 'pass' : 'fail',
+  };
+}
+
+/** 한 장의 표. 세 표시가 비면 «없음» 과 그 근거를 표 아래에 적는다. */
+export function formatAlertAudit(audit: AlertAudit): string {
+  const header = '| 누가 | 무엇을 | 언제 | 채널 | 봇 | 마지막 도착 | 표시 |';
+  const rule = '| --- | --- | --- | --- | --- | --- | --- |';
+  const body = audit.rows.map(row => {
+    const marks = markOrder(row.marks).filter(mark => mark !== 'none').join(', ') || 'none';
+    const arrived = row.lastArrivedAt ?? '없음';
+    return `| ${row.who} | ${row.what} | ${row.when} | ${row.channel} | ${row.bot} | ${arrived} | ${marks} |`;
+  });
+  const lines = [header, rule, ...body, '', `대조 누락: ${audit.missingFromRegistry}`, `판정: ${audit.verdict}`];
+  const note = (label: string, found: readonly AlertAuditRow[], emptyReason: string) => {
+    if (found.length) lines.push(`${label}: ${found.map(row => row.who).join(', ')}`);
+    else lines.push(`${label}: 없음 — ${emptyReason}`);
+  };
+  note('보낸다고 기록됐는데 도착 증거가 없는 것', audit.claimedWithoutArrival, 'recordedOk 인 발신자마다 도착이 있다');
+  if (audit.overlapUnknown.length) {
+    lines.push(`겹치는 것: 미상 — contentKey 를 모르는 도착이 있어 겹침을 판정하지 않음 (${audit.overlapUnknown.map(row => row.who).join(', ')})`);
+  } else {
+    note('겹치는 것', audit.overlaps, '같은 contentKey 가 둘 이상의 채널·봇에 도착한 적이 없다');
+  }
+  note('아무도 안 보내는 것', audit.gaps, 'representative 발신자는 모두 발송 기록이 있거나 도착이 있다');
+  return `${lines.join('\n')}\n`;
+}

package/src/domains/core-tools.ts

@@ -30,7 +30,7 @@ import { LOGS_QUERY_SPEC, dispatchLogsQuery } from './logs-tool.js';
 import { MISSION_DECIDE_SPEC, dispatchMissionDecide } from '../autopilot/mission-decide-tool.js';
 import { COO_ADMIN_SPEC, dispatchCooAdmin } from './coo-admin-tool.js';
 import { RELEASE_STATUS_SPEC, RELEASE_CHANGE_SPEC, dispatchReleaseStatus, dispatchReleaseChange } from './release-tool.js';
-import { OPS_SEATS_SPEC, DECISIONS_PENDING_SPEC, dispatchOpsSeats, dispatchDecisionsPending } from './ops-facts-tool.js';
+import { OPS_SEATS_SPEC, DECISIONS_PENDING_SPEC, PROACT_METER_SPEC, dispatchOpsSeats, dispatchDecisionsPending, dispatchProactMeter } from './ops-facts-tool.js';
 
 /** memory_recall — 크로스서피스 기억(자기 발송 원장 회상). 도메인 무관(domain 필터는 옵션).
  *  finance-tools 에서 L2 로 이관(2026-07-08). */
@@ -142,7 +142,7 @@ const SELF_RECALL_BUDGET_SPEC: LLMToolSpec = {
     },
   },
 };
-export const CORE_TOOL_SPECS: LLMToolSpec[] = [SCHEDULE_MANAGE_SPEC, SESSION_MANAGE_SPEC, MEMORY_RECALL_SPEC, FACT_CHECK_SPEC, SELF_RECALL_BUDGET_SPEC, CONTEXT_NOW_SPEC, AUTOPILOT_MISSION_SPEC, OPS_STATUS_SPEC, SE_BUILD_SPEC, LOGS_QUERY_SPEC, MISSION_DECIDE_SPEC, COO_ADMIN_SPEC, RELEASE_STATUS_SPEC, RELEASE_CHANGE_SPEC, OPS_SEATS_SPEC, DECISIONS_PENDING_SPEC];
+export const CORE_TOOL_SPECS: LLMToolSpec[] = [SCHEDULE_MANAGE_SPEC, SESSION_MANAGE_SPEC, MEMORY_RECALL_SPEC, FACT_CHECK_SPEC, SELF_RECALL_BUDGET_SPEC, CONTEXT_NOW_SPEC, AUTOPILOT_MISSION_SPEC, OPS_STATUS_SPEC, SE_BUILD_SPEC, LOGS_QUERY_SPEC, MISSION_DECIDE_SPEC, COO_ADMIN_SPEC, RELEASE_STATUS_SPEC, RELEASE_CHANGE_SPEC, OPS_SEATS_SPEC, DECISIONS_PENDING_SPEC, PROACT_METER_SPEC];
 
 export interface CoreTools {
   specs: LLMToolSpec[];
@@ -159,10 +159,11 @@ export function buildCoreTools(recallSearch?: RecallSearch): CoreTools {
     names,
     dispatch: async (name, args, onPartial, context) => {
       const h = CORE_TOOL_HANDLERS[name];
-      if (!h && name !== 'release_change' && name !== 'ops_seats' && name !== 'decisions_pending') return { error: `unknown core tool: ${name}` };
+      if (!h && name !== 'release_change' && name !== 'ops_seats' && name !== 'decisions_pending' && name !== 'proact_meter') return { error: `unknown core tool: ${name}` };
       if (name === 'release_change') return dispatchReleaseChange(args, context);
       if (name === 'ops_seats') return dispatchOpsSeats(args, context);
       if (name === 'decisions_pending') return dispatchDecisionsPending(context);
+      if (name === 'proact_meter') return dispatchProactMeter(args, context);
       if (name === 'memory_recall' || name === 'self_recall') {
         return runRecall(name, args, context ?? { surface: 'skill' }, recallSearch, onPartial);
       }

package/src/domains/ops-facts-tool.ts

@@ -2,6 +2,7 @@ import type { LLMToolSpec } from '../llm.js';
 import type { ToolRuntimeContext } from '../tool-runtime/types.js';
 import { debug } from '../debug/log.js';
 import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
+import { readProactMeter, type ProactMeter } from '../decisions/proact-meter.js';
 import { buildSeatsBoard, todayKst, type SeatsSources } from '../nexus/api/ops-seats.js';
 import { liveSeatsSources } from '../nexus/api/ops-seats-sources.js';
 
@@ -11,6 +12,12 @@ export const OPS_SEATS_SPEC: LLMToolSpec = {
   parameters: { type: 'object', properties: { date: { type: 'string', description: '조회할 KST 날짜 YYYY-MM-DD. 생략하면 KST 오늘.' } }, required: [] },
 };
 
+export const PROACT_METER_SPEC: LLMToolSpec = {
+  name: 'proact_meter',
+  description: '오너 전용 읽기 — 선제성 기준선. 지난 7 KST일마다 대표가 시키지 않고 시스템이 먼저 낸 수(offered), 그중 채택된 수(adopted), 대표가 먼저 물어서야 드러난 수(asked). 표본은 결정·지시·조율·루프 원문 링크를 가진다. 못 읽은 원천은 sources.read=false 이며 0이 아니다.',
+  parameters: { type: 'object', properties: { days: { type: 'number', description: 'KST 일수. 생략하면 7.' } }, required: [] },
+};
+
 export const DECISIONS_PENDING_SPEC: LLMToolSpec = {
   name: 'decisions_pending',
   description: '오너 전용 읽기 — 결정 원장의 열린 결정을 기한 순으로 조회한다. 결정 선택·기록은 하지 않는다.',
@@ -21,13 +28,14 @@ export interface OpsFactsDeps {
   seatsSources?: () => SeatsSources;
   listDecisions?: (filters: { status: 'open' }) => DecisionEntry[];
   today?: () => string;
+  readProact?: (days: number) => ProactMeter;
 }
 
 function ownerVerified(context?: ToolRuntimeContext): boolean {
   return context?.requestOrigin !== 'external-agent' && !!context?.sessionId && !!context?.verifiedOwner?.id.trim();
 }
 
-function logCall(tool: 'ops_seats' | 'decisions_pending', ok: boolean, nulls: number): void {
+function logCall(tool: 'ops_seats' | 'decisions_pending' | 'proact_meter', ok: boolean, nulls: number): void {
   debug.log('ops.facts', 'call', { tool, ok, nulls });
 }
 
@@ -56,6 +64,28 @@ export async function dispatchOpsSeats(args: Record<string, unknown>, context?:
   }
 }
 
+/** Seven KST days. An unreadable ledger stays sources.read=false; it is not a zero day. */
+export function dispatchProactMeter(args: Record<string, unknown>, context?: ToolRuntimeContext, deps: OpsFactsDeps = {}) {
+  if (!ownerVerified(context)) {
+    logCall('proact_meter', false, 0);
+    return { error: '오너 확인이 필요한 조회다' };
+  }
+  const days = args.days === undefined ? 7 : args.days;
+  if (typeof days !== 'number' || !Number.isInteger(days) || days < 1 || days > 31) {
+    logCall('proact_meter', false, 0);
+    return { error: 'days 는 1 이상 31 이하의 정수여야 한다' };
+  }
+  try {
+    const meter = (deps.readProact ?? ((n: number) => readProactMeter({ days: n })))(days);
+    const unread = Object.values(meter.sources).filter(source => !source.read).length;
+    logCall('proact_meter', true, unread);
+    return meter;
+  } catch {
+    logCall('proact_meter', false, 1);
+    return { error: '선제성 원장을 읽지 못했다', days: null };
+  }
+}
+
 /** Only the five requested fields leave the decision ledger. Undated entries follow dated entries. */
 export function dispatchDecisionsPending(context?: ToolRuntimeContext, deps: OpsFactsDeps = {}) {
   if (!ownerVerified(context)) {

package/src/domains/outbound-alert.ts

@@ -448,7 +448,7 @@ function reportUndeliverable(kind: string, daemonPath: DaemonPathClass | 'not-fo
   try { debug.log('outbound.send', 'undeliverable', { kind: safeObservationLabel(kind), daemonPath, universe, root }); } catch { /* fail-soft */ }
   const hint = universe === 'prod'
     ? '운영 데몬이 떠 있는지 확인: elanous nexus show'
-    : '운영으로 보내려면 설치본 elanous 로 실행하거나 ELANOUS_STATE_DIR=~/.elanous ELANOUS_CONFIG_DIR=~/.elanous 를 준다';
+    : '운영으로 보내려면 설치본 elanous 로 실행하거나 ELANOUS_STATE_DIR=~/.elanous 와 --config-dir ~/.elanous 를 준다';
   try { console.error(`[outbound] ⛔ 못 보냄(${kind}) — 데몬 ${daemonPath} · 직접 발송도 실패(토큰 없음 또는 전송 실패) · 이 프로세스의 우주 ${universe} (${root}) · ${hint}`); } catch { /* fail-soft */ }
 }
 

package/src/elanous-config-dir.ts

@@ -15,18 +15,41 @@
 // Resolution order:
 //   1. Programmatic override set via `setElanousConfigDir(dir)` (incl.
 //      from the `--config-dir` CLI flag).
-//   2. `~/.elanous` — default daily-driver root.
+//   2. State-dir via `effectiveInstanceRoot()` (including isolated source trees).
+//   3. `~/.elanous` for the installed daily-driver root.
 
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { resolve } from 'node:path';
 
 let override: string | undefined;
+let checkedIgnoredEnv = false;
+
+function normalizedDir(dir: string): string {
+  const trimmed = dir.trim();
+  const expanded = trimmed === '~' ? homedir() : trimmed.startsWith('~/') ? `${homedir()}${trimmed.slice(1)}` : trimmed;
+  return resolve(expanded);
+}
+
+function warnIfIgnoredEnv(resolved: string, source: 'flag' | 'state-dir' | 'default'): void {
+  if (checkedIgnoredEnv) return;
+  checkedIgnoredEnv = true;
+  const env = process.env.ELANOUS_CONFIG_DIR;
+  if (env === undefined || normalizedDir(env) === normalizedDir(resolved)) return;
+  console.error(`ELANOUS_CONFIG_DIR 는 읽지 않습니다 — 설정 폴더 = ${resolved} · 그 폴더를 쓰려면 --config-dir ${normalizedDir(env)}`);
+  try {
+    const { debug } = require('./debug/log.js') as typeof import('./debug/log.js');
+    debug.log('config.dir', 'env-ignored', { env, resolved, source });
+  } catch { /* logging must not change config resolution */ }
+}
 
 /** Resolve the current elanous config / daemon root directory. Caller
  *  decides what subpath to append (`workflows/`, `config.json`,
  *  `acp-token`, ...). */
 export function getElanousConfigDir(): string {
-  if (override !== undefined) return override;
+  if (override !== undefined) {
+    warnIfIgnoredEnv(override, 'flag');
+    return override;
+  }
   // ★ §4d (P3 · 2026-07-26) — **config-dir 은 state-dir 을 따라간다.**
   //
   //   `ELANOUS_STATE_DIR` 은 env 라 전 자손에 자동 전파되는데 config-dir 은 argv 재부착 **7곳**
@@ -41,7 +64,9 @@ export function getElanousConfigDir(): string {
   //     (`configDirFollowingStateDir` 은 §4d 계약을 문서화·테스트하는 순수 함수로 남는다 —
   //      실제 해석 경로는 이 리졸버 하나다.)
   const { effectiveInstanceRoot } = require('./instance/resolve.js') as typeof import('./instance/resolve.js');
-  return effectiveInstanceRoot();
+  const resolved = effectiveInstanceRoot();
+  warnIfIgnoredEnv(resolved, process.env.ELANOUS_STATE_DIR?.trim() ? 'state-dir' : 'default');
+  return resolved;
 }
 
 /** Programmatic override. Trims, rejects empty/blank. Child processes

package/src/execution-loop/launch-gate.ts

@@ -30,19 +30,32 @@ export function activeRunsForGoal(goalId: string, deps: ActiveRunsForGoalDeps =
     if (observation.completeness !== 'complete') unknownReasons.add(`ledger observation ${observation.completeness}`);
     for (const root of observation.pty.unreadable) unknownReasons.add(`unreadable PTY: ${root}`);
     const active = new Set<string>();
+    let skippedTerminal = 0;
     for (const run of observation.entries) {
-      if (run.status === 'ended-unclosed') continue;
-      if (run.ledgerDirectories.length === 0) { unknown = true; unknownReasons.add(`${run.runId}: ledger directory absent`); continue; }
+      if (run.status === 'ended-unclosed') { skippedTerminal += 1; continue; }
+      const hasObservedPty = run.ptyRefs.length > 0;
+      const live = run.status === 'running' && hasObservedPty;
+      if (run.ledgerDirectories.length === 0) {
+        if (hasObservedPty) { unknown = true; unknownReasons.add(`${run.runId}: ledger directory absent`); }
+        else skippedTerminal += 1;
+        continue;
+      }
       let identified = false;
       for (const directory of run.ledgerDirectories) {
         try {
           const ledger = loadLedger(run.runId, directory);
-          if (ledger === null) { unknown = true; unknownReasons.add(`${run.runId}: ledger unavailable`); continue; }
+          if (ledger === null) {
+            if (hasObservedPty) { unknown = true; unknownReasons.add(`${run.runId}: ledger unavailable`); }
+            continue;
+          }
           const ids = new Set(ledger.flatMap((entry) => entry.goalId ? [entry.goalId] : []));
-          if (ids.size !== 1) { unknown = true; unknownReasons.add(`${run.runId}: expected one goalId, found ${ids.size}`); continue; }
+          if (ids.size !== 1) {
+            if (hasObservedPty) { unknown = true; unknownReasons.add(`${run.runId}: expected one goalId, found ${ids.size}`); }
+            continue;
+          }
           identified = true;
           let matches = ids.has(goalId);
-          if (!matches && goalId.startsWith('request-') && run.status === 'running' && run.ptyRefs.length > 0) {
+          if (!matches && goalId.startsWith('request-') && live) {
             const document = ledger.find((entry) => entry.event === 'start')?.data.goalFile;
             if (typeof document === 'string') {
               try {
@@ -52,20 +65,22 @@ export function activeRunsForGoal(goalId: string, deps: ActiveRunsForGoalDeps =
             }
           }
           if (matches) {
-            if (run.status === 'running' && run.ptyRefs.length > 0) active.add(run.runId);
+            if (live) active.add(run.runId);
             else { unknown = true; unknownReasons.add(`${run.runId}: matching ledger without live PTY`); }
           }
-        } catch { unknown = true; unknownReasons.add(`${run.runId}: ledger read failed`); }
+        } catch {
+          if (hasObservedPty) { unknown = true; unknownReasons.add(`${run.runId}: ledger read failed`); }
+        }
       }
-      if (!identified) unknown = true;
+      if (!identified && !hasObservedPty) skippedTerminal += 1;
     }
     // Positive evidence wins even if a different process or store is unreadable.
-    if (active.size > 0) return [...active].sort();
-    if (unknown) {
-      try { debug.log('execution-loop.launch-gate', 'active-runs-unknown', { goalId, reasons: [...unknownReasons] }); } catch { /* observation is fail-soft */ }
-      return 'unknown';
-    }
-    return [];
+    const result: ActiveRunsForGoal = active.size > 0 ? [...active].sort() : unknown ? 'unknown' : [];
+    try {
+      debug.log('execution-loop.launch-gate', 'active-runs-result', { goalId, result, skippedTerminal });
+      if (result === 'unknown') debug.log('execution-loop.launch-gate', 'active-runs-unknown', { goalId, reasons: [...unknownReasons], skippedTerminal });
+    } catch { /* observation is fail-soft */ }
+    return result;
   } catch (error) {
     try { debug.log('execution-loop.launch-gate', 'active-runs-unknown', { goalId, reasons: [error instanceof Error ? error.message : String(error)] }); } catch { /* observation is fail-soft */ }
     return 'unknown';