elanous 0.2.12 → 0.2.14

package/src/loops/activity.ts

@@ -0,0 +1,203 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { Database } from 'bun:sqlite';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { LogStore, type LogStoreRow } from '../mss/logging/log-store.js';
+import { checkLoops } from './checker.js';
+import { defaultLoopRoot, listAllLoops, type AllLoopEntry } from './registry.js';
+import type { ScheduleRow } from '../domains/schedule-registry.js';
+
+export interface ActivityNode {
+  id: string;
+  kind: AllLoopEntry['kind'] | 'seat' | 'card' | 'event';
+  title: string;
+  state: string | null;
+  reason: string | null;
+  lastAt: string | null;
+  events: number;
+}
+export interface ActivityEdge {
+  from: string;
+  to: string;
+  kind: 'delegation' | 'request' | 'reply' | 'card';
+  count: number;
+  lastAt: string;
+}
+export interface LoopActivityResult {
+  since: string;
+  until: string;
+  nodes: ActivityNode[];
+  edges: ActivityEdge[];
+}
+export interface LoopActivityDeps {
+  listAllLoops?: (opts: { root: string; stateRoot: string; now: Date; schedules: ScheduleRow[] }) => AllLoopEntry[];
+  queryEvents?: (root: string, sinceMs: number, untilMs: number) => LogStoreRow[];
+  readJournal?: (root: string, name: string) => readonly Record<string, unknown>[];
+  readCards?: (root: string) => readonly { id: string; createdAt: string; sections: readonly { owner: string; createdAt: string }[] }[];
+}
+
+function readSchedules(root: string): ScheduleRow[] {
+  const path = join(root, 'schedules.db');
+  if (!existsSync(path)) return [];
+  const db = new Database(path, { readonly: true });
+  try {
+    if (!db.query("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'schedule_registry'").get()) return [];
+    const columns = (db.query('PRAGMA table_info(schedule_registry)').all() as Array<{ name: string }>).map(row => row.name);
+    if (!columns.includes('run_via')) return [];
+    return db.query('SELECT * FROM schedule_registry').all() as ScheduleRow[];
+  } finally { db.close(); }
+}
+
+function readEvents(root: string, sinceMs: number, untilMs: number): LogStoreRow[] {
+  const path = join(root, 'logs', 'logs.db');
+  if (!existsSync(path)) return [];
+  const store = LogStore.openReadOnly(path);
+  try { return store.queryAll({ categories: ['loop.', 'seat.loop'], sinceMs, untilMs }); }
+  finally { store.close(); }
+}
+
+function parseObject(value: string): Record<string, unknown> {
+  try {
+    const parsed: unknown = JSON.parse(value);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed as Record<string, unknown> : {};
+  } catch { return {}; }
+}
+
+function readJournal(root: string, name: string): Record<string, unknown>[] {
+  const path = join(root, 'seat-requests', name);
+  return existsSync(path) ? readFileSync(path, 'utf8').split('\n').filter(Boolean).map(parseObject) : [];
+}
+
+function readCards(root: string): { id: string; createdAt: string; sections: { owner: string; createdAt: string }[] }[] {
+  const dir = join(root, 'task-cards');
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter(file => file.endsWith('.jsonl')).flatMap(file => {
+    const entries = readFileSync(join(dir, file), 'utf8').split('\n').filter(Boolean).map(parseObject);
+    const created = entries.find(row => row.type === 'created');
+    if (!created || typeof created.id !== 'string' || typeof created.createdAt !== 'string') return [];
+    return [{ id: created.id, createdAt: created.createdAt,
+      sections: entries.filter(row => row.type === 'section' && typeof row.owner === 'string' && typeof row.createdAt === 'string')
+        .map(row => ({ owner: row.owner as string, createdAt: row.createdAt as string })) }];
+  });
+}
+
+function text(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function loopId(value: unknown): string | null {
+  const id = text(value);
+  if (!id) return null;
+  const seat = id.toUpperCase();
+  if (seat === 'OP' || seat === 'TC' || seat === 'UX') return `${seat.toLowerCase()}-seat`;
+  if (seat === 'MK' || seat === 'MK-SEAT') return 'cmo-seat';
+  return id;
+}
+
+function cardNodeId(value: unknown): string | null {
+  const id = text(value);
+  return id ? (id.startsWith('card:') ? id : `card:${id}`) : null;
+}
+
+/** Read-only registry/checker snapshot plus observed edges in the inclusive time window. */
+export function loopActivity({ since, until, root = effectiveInstanceRoot(), deps = {} }: {
+  since: string | Date;
+  until?: string | Date;
+  root?: string;
+  deps?: LoopActivityDeps;
+}): LoopActivityResult {
+  const end = until === undefined ? new Date() : new Date(until);
+  const duration = typeof since === 'string' ? /^(\d+)([mhd])$/.exec(since) : null;
+  const durationMs = duration ? Number(duration[1]) * ({ m: 60_000, h: 3_600_000, d: 86_400_000 }[duration[2]!] ?? NaN) : NaN;
+  const start = duration ? new Date(end.getTime() - durationMs) : new Date(since);
+  if (!Number.isFinite(start.getTime()) || !Number.isFinite(end.getTime()) || start > end) throw new Error('invalid loop activity window');
+  const inventory = (deps.listAllLoops ?? listAllLoops)({ root: deps.listAllLoops ? root : defaultLoopRoot(), stateRoot: root, now: end, schedules: deps.listAllLoops ? [] : readSchedules(root) });
+  const checked = checkLoops(inventory, end);
+  const byId = new Map(inventory.map(entry => [entry.id, entry]));
+  const nodes = new Map<string, ActivityNode>(checked.map(entry => [entry.id, {
+    id: entry.id, kind: byId.get(entry.id)?.kind ?? 'graph',
+    title: byId.get(entry.id)?.title ?? entry.id,
+    state: entry.state, reason: entry.reason, lastAt: entry.lastRunAt ?? null, events: 0,
+  }]));
+  const edges = new Map<string, ActivityEdge>();
+  const ensure = (id: string, kind: ActivityNode['kind'] = 'event'): ActivityNode => {
+    let node = nodes.get(id);
+    if (!node) {
+      node = { id, kind, title: id, state: null, reason: null, lastAt: null, events: 0 };
+      nodes.set(id, node);
+    }
+    return node;
+  };
+  const inWindow = (value: unknown): string | null => {
+    const ms = typeof value === 'string' ? Date.parse(value) : NaN;
+    return Number.isFinite(ms) && ms >= start.getTime() && ms <= end.getTime() ? new Date(ms).toISOString() : null;
+  };
+  const touch = (id: string, at: string, kind: ActivityNode['kind'] = 'event'): void => {
+    const node = ensure(id, kind);
+    node.events++;
+    if (!node.lastAt || at > node.lastAt) node.lastAt = at;
+  };
+  const connect = (from: string, to: string, kind: ActivityEdge['kind'], at: string): void => {
+    if (from === to) return;
+    ensure(from, from.startsWith('card:') ? 'card' : 'event');
+    ensure(to, to.startsWith('card:') ? 'card' : 'event');
+    const key = JSON.stringify([from, to, kind]);
+    const edge = edges.get(key);
+    if (edge) { edge.count++; if (at > edge.lastAt) edge.lastAt = at; }
+    else edges.set(key, { from, to, kind, count: 1, lastAt: at });
+  };
+  for (const row of (deps.queryEvents ?? readEvents)(root, start.getTime(), end.getTime())) {
+    const timestamp = Number.isFinite(row.ts_ms) ? row.ts_ms : Date.parse(row.ts);
+    if (!Number.isFinite(timestamp) || timestamp < start.getTime() || timestamp > end.getTime()) continue;
+    const data = parseObject(row.data ?? '');
+    const actor = row.category.startsWith('loop.') && !['loop.checker', 'loop.observe', 'loop.registry', 'loop.neighbors', 'loop.package'].includes(row.category)
+      ? loopId(row.category.slice('loop.'.length)) : row.category === 'seat.loop' ? loopId(data.seat) : null;
+    if (!actor) continue;
+    const at = new Date(timestamp).toISOString();
+    touch(actor, at);
+    if (row.event === 'exchange' && text(data.reason) === 'delegation') {
+      const to = loopId(data.to ?? data.targetLoopId);
+      if (to) connect(loopId(data.from) ?? actor, to, 'delegation', at);
+    } else if (row.category === 'loop.orchestrator' && row.event === 'exchange' && data.reason === 'queued') {
+      const to = loopId(data.targetLoopId);
+      if (to) connect(actor, to, 'delegation', at);
+    } else if (row.event === 'exchange' && (data.reason === 'request' || data.reason === 'reply' || data.reason === 'card')) {
+      const to = data.reason === 'card' && data.cardId != null
+        ? cardNodeId(data.cardId) : loopId(data.to ?? data.targetLoopId);
+      if (to) connect(loopId(data.from) ?? actor, to, data.reason, at);
+    }
+  }
+  for (const item of (deps.readJournal ?? readJournal)(root, 'requests.jsonl')) {
+    const at = inWindow(item.queuedAt);
+    const to = loopId(item.loopId ?? item.seat);
+    if (!at || !to) continue;
+    touch(to, at, 'seat');
+    const from = loopId(item.from) ?? (item.source === 'orchestrator' || item.source === 'orchestrator-traffic' ? 'orchestrator'
+      : item.source === 'loop-checker' ? 'checker' : null);
+    if (from) connect(from, to, 'request', at);
+  }
+  for (const item of (deps.readJournal ?? readJournal)(root, 'replies.jsonl')) {
+    const at = inWindow(item.repliedAt ?? item.createdAt);
+    const from = loopId(item.from ?? item.seat);
+    if (!at || !from) continue;
+    touch(from, at, 'seat');
+    const to = loopId(item.to);
+    if (to) connect(from, to, 'reply', at);
+  }
+  for (const card of (deps.readCards ?? readCards)(root)) {
+    const id = cardNodeId(card.id);
+    if (!id) continue;
+    const created = inWindow(card.createdAt);
+    if (created) touch(id, created, 'card');
+    for (const section of card.sections) {
+      const at = inWindow(section.createdAt);
+      const owner = loopId(section.owner);
+      if (!at || !owner) continue;
+      touch(id, at, 'card');
+      connect(owner, id, 'card', at);
+    }
+  }
+  return { since: start.toISOString(), until: end.toISOString(),
+    nodes: [...nodes.values()].sort((a, b) => a.id.localeCompare(b.id)),
+    edges: [...edges.values()].sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to) || a.kind.localeCompare(b.kind)) };
+}

package/src/loops/budget.ts

@@ -0,0 +1,32 @@
+import { ORCHESTRATOR_DEFAULTS, type OrchestratorSeat } from '../user-config.js';
+
+export interface SpawnBudgetInput {
+  seat: OrchestratorSeat;
+  /** Current running count for this seat; null/undefined means the ledger could not be measured. */
+  running: number | null | undefined;
+  /** Configured loops.orchestrator.seatCaps. Missing seats use the orchestrator defaults. */
+  caps?: Partial<Record<OrchestratorSeat, number>>;
+  /** Release-gate seat limits. Missing seats use the gate default of four. */
+  gate?: Partial<Record<OrchestratorSeat, number>>;
+}
+
+export interface SpawnBudgetDecision {
+  allow: boolean;
+  reason: 'within-cap' | 'seat-cap' | 'unknown-running';
+  cap: number;
+}
+
+/** A release gate can lower, but never raise, the configured per-seat cap. */
+export function decideSpawn({ seat, running, caps, gate }: SpawnBudgetInput): SpawnBudgetDecision {
+  const configured = caps?.[seat] ?? ORCHESTRATOR_DEFAULTS.seatCaps[seat];
+  const gated = gate?.[seat] ?? 4;
+  const cap = Number.isSafeInteger(configured) && configured >= 0 && Number.isSafeInteger(gated) && gated >= 0
+    ? Math.min(configured, gated)
+    : 0;
+  if (!Number.isSafeInteger(running) || running === null || running === undefined || running < 0) {
+    return { allow: false, reason: 'unknown-running', cap };
+  }
+  return running < cap
+    ? { allow: true, reason: 'within-cap', cap }
+    : { allow: false, reason: 'seat-cap', cap };
+}

package/src/loops/checker.ts

@@ -0,0 +1,180 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { Database } from 'bun:sqlite';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import * as registry from './registry.js';
+import { cronMatches } from '../domains/cron-match.js';
+import { resolveTimeZone } from '../time/format.js';
+import type { LoopEntry, LoopRun } from './registry.js';
+
+type LoopState = 'off' | 'unregistered' | 'failing' | 'late' | 'unknown' | 'alive';
+export type LoopScope = 'graph-only' | 'registry';
+export interface CheckEntry {
+  id: string;
+  owner?: string;
+  ownerSource?: 'header' | 'config' | 'seat' | 'default';
+  evidence?: 'log-mtime';
+  mode?: string;
+  expectEveryMinutes?: number;
+  /** The scheduled fire before the latest one (cron loops). A run older than this missed two scheduled fires. */
+  dueAt?: string;
+  lastRunAt?: string;
+  lastStatus?: string;
+  recentStatuses?: string[];
+  enabled: boolean;
+  registered: boolean;
+}
+export interface CheckResult extends CheckEntry {
+  state: LoopState;
+  reason: string;
+}
+export const LOOP_STATES = ['alive', 'late', 'failing', 'off', 'unregistered', 'unknown'] as const;
+export type LoopCounts = Record<LoopState, number>;
+
+export function checkLoops(entries: CheckEntry[], now: Date, opts: { failureStatuses?: readonly string[] } = {}): CheckResult[] {
+  const failures = opts.failureStatuses ?? ['failed'];
+  return entries.map(entry => {
+    let state: LoopState;
+    let reason: string;
+    const age = entry.lastRunAt ? now.getTime() - Date.parse(entry.lastRunAt) : NaN;
+    if (!entry.enabled) { state = 'off'; reason = 'disabled'; }
+    else if (!entry.registered) { state = 'unregistered'; reason = 'not registered'; }
+    else if (entry.recentStatuses?.length && entry.recentStatuses.length >= 3
+      && entry.recentStatuses.slice(0, 3).every(status => failures.includes(status))) {
+      state = 'failing'; reason = 'last 3 runs failed';
+    } else if (Number.isFinite(age) && entry.dueAt && Number.isFinite(Date.parse(entry.dueAt))) {
+      // Judge against the real schedule, not a fixed interval: overnight or weekend gaps are not lateness.
+      if (Date.parse(entry.lastRunAt!) < Date.parse(entry.dueAt)) { state = 'late'; reason = `missed the scheduled runs since ${entry.dueAt}`; }
+      else { state = 'alive'; reason = 'ran at or after the previous scheduled fire'; }
+    } else if (Number.isFinite(age) && entry.expectEveryMinutes !== undefined
+      && entry.expectEveryMinutes > 0 && age > entry.expectEveryMinutes * 2 * 60_000) {
+      state = 'late'; reason = `last run exceeds twice the expected ${entry.expectEveryMinutes}m interval`;
+    } else if (!entry.lastRunAt || !Number.isFinite(age)) { state = 'unknown'; reason = 'no valid run recorded'; }
+    else if (entry.expectEveryMinutes === undefined || !Number.isFinite(entry.expectEveryMinutes) || entry.expectEveryMinutes <= 0) {
+      state = 'unknown'; reason = 'expected interval unknown';
+    } else { state = 'alive'; reason = 'within expected interval'; }
+    return { ...entry, state, reason };
+  });
+}
+
+export function countLoopStates(results: CheckResult[]): LoopCounts {
+  const counts: LoopCounts = { alive: 0, late: 0, failing: 0, off: 0, unregistered: 0, unknown: 0 };
+  for (const result of results) counts[result.state]++;
+  return counts;
+}
+
+/** Latest cron fire at or before `at` (minute resolution, scans back up to one year). */
+export function previousLoopFire(cron: string, at: Date, timeZone: string = resolveTimeZone().timeZone): string | null {
+  if (cron.trim().split(/\s+/).length !== 5) return null;
+  let minute = Math.floor(at.getTime() / 60000) * 60000;
+  for (let i = 0; i < 527040; i++, minute -= 60000) {
+    if (cronMatches(cron, new Date(minute), { timeZone })) return new Date(minute).toISOString();
+  }
+  return null;
+}
+
+/** The fire before the latest scheduled fire — a run older than this has missed two scheduled fires. */
+export function dueBefore(cron: string, now: Date, timeZone?: string): string | null {
+  const latest = previousLoopFire(cron, now, timeZone);
+  return latest ? previousLoopFire(cron, new Date(Date.parse(latest) - 60000), timeZone) : null;
+}
+
+export interface RegistryAdapterDeps {
+  listLoops?: () => LoopEntry[];
+  listAllLoops?: () => CheckEntry[];
+  statusForLoop?: (id: string) => { recentRuns: Pick<LoopRun, 'status'>[] };
+  now?: Date;
+  timeZone?: string;
+}
+
+export function entriesFromRegistry(deps: RegistryAdapterDeps = {}): { entries: CheckEntry[]; scope: LoopScope } {
+  // An explicitly injected graph inventory remains the checker test/adapter fallback.
+  const all = deps.listAllLoops ?? (deps.listLoops ? undefined : registry.listAllLoops);
+  if (typeof all === 'function') return { entries: all(), scope: 'registry' };
+  const now = deps.now ?? new Date();
+  return { scope: 'graph-only', entries: (deps.listLoops ?? registry.listLoops)().map(loop => {
+    const first = loop.trigger.cron ? registry.nextLoopFire(loop.trigger.cron, now) : null;
+    const second = first && loop.trigger.cron ? registry.nextLoopFire(loop.trigger.cron, new Date(first)) : null;
+    const interval = first && second ? (Date.parse(second) - Date.parse(first)) / 60_000 : undefined;
+    const statuses = loop.lastRun
+      ? deps.statusForLoop ? deps.statusForLoop(loop.id).recentRuns.map(run => run.status)
+        : deps.listLoops ? [loop.lastRun.status]
+          : registry.loopStatus(loop.id).recentRuns.map(run => run.status)
+      : [];
+    const dueAt = loop.trigger.cron ? dueBefore(loop.trigger.cron, now, deps.timeZone) : null;
+    return { id: loop.id, owner: loop.owner ?? undefined, ownerSource: loop.ownerSource, enabled: loop.enabled, registered: true,
+      ...(interval !== undefined ? { expectEveryMinutes: interval } : {}),
+      ...(dueAt ? { dueAt } : {}),
+      ...(loop.lastRun ? { lastRunAt: loop.lastRun.at, lastStatus: loop.lastRun.status } : {}),
+      recentStatuses: statuses };
+  }) };
+}
+
+export interface CheckerDeps {
+  root?: string;
+  now?: Date;
+}
+
+/** Appends only new daily keys to the seat request journal; never rewrites existing lines. */
+export function notifyOwners(results: CheckResult[], deps: CheckerDeps = {}): number {
+  const eligible = results.filter(result => result.owner && (result.state === 'late' || result.state === 'failing'));
+  if (!eligible.length) return 0;
+  const now = deps.now ?? new Date();
+  const path = join(deps.root ?? effectiveInstanceRoot(), 'seat-requests', 'requests.jsonl');
+  mkdirSync(dirname(path), { recursive: true });
+  // SQLite's OS locks are released when a process dies, including after SIGKILL.
+  // The journal itself remains append-only; this database only serializes check + append.
+  const lock = new Database(`${path}.loop-checker.lock.sqlite`);
+  try {
+    lock.exec('PRAGMA busy_timeout = 10000');
+    lock.exec('BEGIN EXCLUSIVE');
+    try {
+      const existing = new Set<string>();
+      if (existsSync(path)) {
+        for (const line of readFileSync(path, 'utf8').split('\n')) {
+          if (line.trim()) {
+            const row = JSON.parse(line) as { key?: string };
+            if (row.key) existing.add(row.key);
+          }
+        }
+      }
+      let added = 0;
+      for (const result of eligible) {
+        const key = `loopcheck:${result.id}:${now.toISOString().slice(0, 10)}:${result.state}`;
+        if (existing.has(key)) continue;
+        const row = { key, receiptId: key, seat: result.owner, text: `${result.id} ${result.state} — 마지막 ${result.lastRunAt ?? '없음'} · ${result.reason}`,
+          status: 'queued', queuedAt: now.toISOString(), source: 'loop-checker' };
+        appendFileSync(path, JSON.stringify(row) + '\n');
+        existing.add(key);
+        added++;
+      }
+      lock.exec('COMMIT');
+      return added;
+    } catch (error) {
+      lock.exec('ROLLBACK');
+      throw error;
+    }
+  } finally { lock.close(); }
+}
+
+/** Persist the previous comparison only for explicit all-status checks. Notification is separate. */
+export function observeLoopCheck(results: CheckResult[], scope: LoopScope, deps: CheckerDeps = {}): LoopCounts {
+  const path = join(deps.root ?? effectiveInstanceRoot(), 'loop', 'checker', 'last.json');
+  let previous: Record<string, LoopState> = {};
+  try { previous = JSON.parse(readFileSync(path, 'utf8')) as Record<string, LoopState>; }
+  catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
+  const current: Record<string, LoopState> = {};
+  for (const { id, state } of results) {
+    current[id] = state;
+    if (previous[id] && previous[id] !== state) debug.log('loop.checker', 'state-change', { id, from: previous[id], to: state });
+  }
+  const counts = countLoopStates(results);
+  debug.log('loop.checker', 'checked', { counts, scope });
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${randomUUID()}.tmp`;
+  try { writeFileSync(tmp, JSON.stringify(current)); renameSync(tmp, path); }
+  catch (error) { if (existsSync(tmp)) unlinkSync(tmp); throw error; }
+  return counts;
+}

package/src/loops/contract/examples/orchestrator.loop.yaml

@@ -2,7 +2,7 @@ id: orchestrator
 version: 1.0.0
 kind: orchestrator
 role: docs/roles/OP.md
-graph: graphs/operate-loop.yaml
+graph: graphs/orchestrator/orchestrator.yaml
 orchestration:
   windows:
     - {at: '08:00', delegateTo: [op-seat, cmo-seat, tc-seat, ux-seat], fromLedger: release/checklist-and-seat-requests}

package/src/loops/loop-cli.ts

@@ -1,6 +1,10 @@
 import type { Command } from 'commander';
 import { writeStdoutJson } from '../cli/stdout-json.js';
-import { listLoops, loopStatus, runLoop, setLoopEnabled } from './registry.js';
+import { listAllLoops, listLoops, loopStatus, runLoop, setLoopEnabled, unregisteredCronLoops, type AllLoopEntry, type LoopRegistryOptions } from './registry.js';
+import { checkLoops, countLoopStates, entriesFromRegistry, LOOP_STATES, notifyOwners, observeLoopCheck, type RegistryAdapterDeps } from './checker.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { verifyLoopPackage } from './package/verify.js';
+import { loopActivity } from './activity.js';
 
 async function output(value: unknown, json: boolean): Promise<void> {
   if (json) await writeStdoutJson(JSON.stringify(value) + '\n');
@@ -14,12 +18,62 @@ function handle(action: () => Promise<void> | void): Promise<void> {
   });
 }
 
-export function registerLoopCommands(program: Command): void {
+function allLoopTable(entries: AllLoopEntry[]): void {
+  console.log('id\t층\t주인 자리\t모드\t기대 주기\t호스트\t울타리 역할\t관측 카테고리\t마지막 실행');
+  for (const entry of entries) {
+    const interval = entry.expectEveryMinutes === undefined ? '모름'
+      : entry.cronIrregular ? `불규칙 · 최대 ${entry.expectEveryMinutes}분` : `${entry.expectEveryMinutes}분`;
+    console.log([entry.id, entry.kind, entry.owner ?? '모름', entry.mode ?? '모름', interval,
+      entry.host ?? '모름', entry.fenceRole ?? '모름', entry.observationCategory ?? '모름', entry.lastRunAt ?? '모름'].join('\t'));
+  }
+}
+
+export function registerLoopCommands(program: Command, checkerDeps: RegistryAdapterDeps & { root?: string; registryOptions?: LoopRegistryOptions } = {}): void {
   const loop = program.command('loop').description('Inspect and control graph-backed loop agents');
-  loop.command('list').option('--json', 'Print JSON')
-    .action((opts: { json?: boolean }) => handle(() => output(listLoops(), !!opts.json)));
-  loop.command('status <id>').option('--json', 'Print JSON')
-    .action((id: string, opts: { json?: boolean }) => handle(() => output(loopStatus(id), !!opts.json)));
+  loop.command('list').option('--all', 'Show the full loop registry').option('--json', 'Print JSON')
+    .action((opts: { all?: boolean; json?: boolean }) => handle(async () => {
+      if (!opts.all) { await output(listLoops(checkerDeps.registryOptions), !!opts.json); return; }
+      const registryOpts = checkerDeps.registryOptions ?? {};
+      const entries = listAllLoops(registryOpts);
+      if (opts.json) { await output(entries, true); return; }
+      allLoopTable(entries);
+      const missing = unregisteredCronLoops(entries, registryOpts);
+      if (missing.length) console.log(`미등록 ${missing.length}: ${missing.map(row => `${row.id} (${row.command})`).join(', ')}`);
+    }));
+  loop.command('activity').description('Read loop and seat activity in a time window (default: last 24h)')
+    .option('--since <duration-or-date>', 'Start of window: duration (e.g. 24h) or ISO date', '24h')
+    .option('--json', 'Print JSON')
+    .action((opts: { since: string; json?: boolean }) => handle(async () => {
+      const activity = loopActivity({ since: opts.since, root: checkerDeps.root ?? effectiveInstanceRoot() });
+      if (opts.json) { await output(activity, true); return; }
+      console.log(`Loop activity ${activity.since} → ${activity.until}`);
+      console.log(`${activity.nodes.length} nodes · ${activity.edges.length} edges`);
+      console.log('Nodes (id · state · events · last activity)');
+      for (const node of activity.nodes) console.log(`${node.id} · ${node.state ?? '—'} · ${node.events} · ${node.lastAt ?? '—'}`);
+      console.log('Edges (from → to · kind · count · last activity)');
+      for (const edge of activity.edges) console.log(`${edge.from} → ${edge.to} · ${edge.kind} · ${edge.count} · ${edge.lastAt}`);
+    }));
+  loop.command('status [id]').option('--all', 'Check all registered loops')
+    .option('--json', 'Print JSON').option('--notify', 'Queue late/failing loops for their owners')
+    .action((id: string | undefined, opts: { all?: boolean; json?: boolean; notify?: boolean }) => handle(async () => {
+      if (!opts.all) {
+        if (!id) throw new Error('loop status requires an id or --all');
+        await output(loopStatus(id), !!opts.json);
+        return;
+      }
+      if (id) throw new Error('loop status --all does not take an id');
+      const now = checkerDeps.now ?? new Date();
+      const root = checkerDeps.root ?? effectiveInstanceRoot();
+      const { entries, scope } = entriesFromRegistry({ ...checkerDeps, now });
+      const results = checkLoops(entries, now);
+      const counts = countLoopStates(results);
+      observeLoopCheck(results, scope, { root, now });
+      if (opts.notify) notifyOwners(results, { root, now });
+      if (opts.json) { await output({ results, counts, scope }, true); return; }
+      console.log('id\tstate\tlast run\texpected interval\towner\treason');
+      for (const result of results) console.log(`${result.id}\t${result.state}\t${result.lastRunAt ?? '—'}\t${result.expectEveryMinutes === undefined ? '—' : `${result.expectEveryMinutes}m`}\t${result.owner ?? '—'}\t${result.reason}`);
+      console.log(`${LOOP_STATES.map(state => `${state} ${counts[state]}`).join(' · ')} · scope ${scope}`);
+    }));
   for (const [name, enabled] of [['start', true], ['stop', false]] as const) {
     loop.command(`${name} <id>`).option('--yes', 'Apply the crontab change (otherwise preview only)')
       .option('--json', 'Print JSON')
@@ -34,4 +88,16 @@ export function registerLoopCommands(program: Command): void {
       await output(state, !!opts.json);
       if (state.status !== 'done' && state.status !== 'awaiting-approval') process.exitCode = 1;
     }));
+  loop.command('package').description('Inspect a loop package without installing it')
+    .command('verify <dir>').option('--json', 'Print JSON')
+    .action((dir: string, opts: { json?: boolean }) => handle(async () => {
+      const result = verifyLoopPackage(dir);
+      if (opts.json) await output(result, true);
+      else {
+        if (result.ok) console.log('OK');
+        else for (const error of result.errors) console.log(error);
+        console.log(`loop-package ${String(result.merged?.id ?? '?')} ${String(result.merged?.version ?? '?')} ${result.ok ? 'ok' : 'refused'} errors=${result.errors.length}`);
+      }
+      if (!result.ok) process.exitCode = 1;
+    }));
 }

package/src/loops/neighbors.ts

@@ -0,0 +1,40 @@
+import { debug } from '../debug/log.js';
+
+/** The neighbor fields validated by src/loops/contract/validate.ts. */
+export interface Neighbor {
+  id: string;
+  exchange: ('status' | 'request' | 'decision' | 'blocked')[];
+  heartbeat: { everyMinutes: number; missedTicks: number };
+  onAbsent: { action: 'delegate' | 'defer' | 'escalate'; delegateTo: string };
+}
+
+export interface NeighborJudgment {
+  state: 'present' | 'absent' | 'unknown';
+  action?: Neighbor['onAbsent'];
+  reason: string;
+}
+
+/** lastSeenAt is the latest ACK of a heartbeat or envelope, not the last send attempt. */
+export function judgeNeighbor({ neighbor, lastSeenAt, lastSendError, now }: {
+  neighbor: Neighbor;
+  lastSeenAt?: string | null;
+  lastSendError?: unknown;
+  now: Date;
+}): NeighborJudgment {
+  const seen = lastSeenAt ? Date.parse(lastSeenAt) : NaN;
+  let result: NeighborJudgment;
+  if (lastSendError != null) {
+    result = { state: 'unknown', reason: 'send-failed' };
+  } else if (!Number.isFinite(seen) || !Number.isFinite(now.getTime()) || seen > now.getTime()) {
+    result = { state: 'unknown', reason: 'last-ack-unknown' };
+  } else if (now.getTime() - seen >= neighbor.heartbeat.everyMinutes * neighbor.heartbeat.missedTicks * 60_000) {
+    result = { state: 'absent', action: neighbor.onAbsent, reason: 'heartbeat-missed' };
+  } else {
+    result = { state: 'present', reason: 'within-heartbeat-window' };
+  }
+  // The validated neighbor entry does not carry its owning loop id; do not invent one.
+  debug.log('loop.neighbors', 'judged', {
+    loop: null, neighbor: neighbor.id, state: result.state, action: result.action, reason: result.reason,
+  });
+  return result;
+}

package/src/loops/observe.ts

@@ -0,0 +1,59 @@
+import { debug } from '../debug/log.js';
+import { recordFailureEvent } from '../self-implement/heal-intake.js';
+
+/** Event vocabulary of the loop-agent manifest observability contract. */
+export const LOOP_EVENTS = [
+  'tick', 'posture-change', 'resolution-change', 'grounding', 'heartbeat',
+  'absent', 'exchange', 'spawn', 'reap', 'promote', 'hitl',
+] as const;
+
+const LOOP_ID = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const REQUIRED_CONTEXT = ['runId', 'profile', 'reason', 'sourceRef'] as const;
+
+function validId(id: unknown): id is string {
+  return typeof id === 'string' && LOOP_ID.test(id);
+}
+
+function reject(reason: 'invalid-loop-id' | 'invalid-event' | 'invalid-data'): void {
+  // Never include untrusted identifiers, event names or payloads in a log category.
+  debug.log('loop.observe', 'rejected', { reason });
+}
+
+/** Category matches observability.category in the loop-agent manifest. */
+export function loopCategory(id: string): string {
+  if (!validId(id)) {
+    reject('invalid-loop-id');
+    throw new Error('invalid loop id');
+  }
+  return `loop.${id}`;
+}
+
+/** Emit an RFC loop event, retaining absent context as a measurable list. */
+export function loopEvent(loopId: string, event: string, data: Record<string, unknown>): void {
+  if (!validId(loopId)) {
+    reject('invalid-loop-id');
+    return;
+  }
+  if (typeof event !== 'string' || !LOOP_EVENTS.some(name => name === event)) {
+    reject('invalid-event');
+    return;
+  }
+  if (data === null || typeof data !== 'object' || Array.isArray(data)
+    || Object.getPrototypeOf(data) !== Object.prototype && Object.getPrototypeOf(data) !== null
+    || (Object.hasOwn(data, 'loopId') && data.loopId !== loopId)) {
+    reject('invalid-data');
+    return;
+  }
+  const missingRequired = REQUIRED_CONTEXT.filter(field =>
+    typeof data[field] !== 'string' || !(data[field] as string).trim());
+  debug.log(`loop.${loopId}`, event, { ...data, loopId, missingRequired });
+  if (event === 'tick' && (data.outcome === 'failed' || data.status === 'failed')) {
+    try {
+      recordFailureEvent({ source: 'loop-tick', kind: event, ref: loopId,
+        summary: `Loop ${loopId} tick failed`, at: new Date().toISOString() });
+    } catch (error) {
+      try { debug.log('heal.intake', 'record-failed', { source: 'loop-tick', kind: event, ref: loopId, error: String(error) }, { level: 'error' }); }
+      catch { /* Heal reporting must not change the tick outcome. */ }
+    }
+  }
+}