elanous 0.2.0 → 0.2.5

package/src/domains/schedule-registry.ts

@@ -17,6 +17,8 @@ import { createHash } from 'node:crypto';
 import { dirname, join } from 'node:path';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { prevScheduledFire } from './cron-match.js';
+import { debug } from '../debug/log.js';
+import { deriveScheduleName, ensureScheduleRunsSchema, recordScheduleRun } from './schedule-runs.js';
 
 /** 스케줄 레지스트리 DB 정본 경로 — state-dir 존중(lazy · Phase B). prod(ELANOUS_STATE_DIR
  *  미설정)=`~/.elanous/schedules.db`(무변경) · 격리 test 인스턴스=자기 루트(빈 시작). 종전
@@ -38,6 +40,7 @@ export interface ScheduleRow {
   category: ScheduleCategory;
   domain: string | null;   // finance | <future>
   enabled: number;
+  disabled_reason?: string | null; // vanished (inventory) | manual (explicit off) | null
   last_seen: string | null;
   last_run: string | null;
   note: string | null;
@@ -59,14 +62,14 @@ export function openSchedulesDb(path: string = schedulesDbPath()): Database {
   if (path !== ':memory:') mkdirSync(dirname(path), { recursive: true });
   const db = new Database(path);
   db.run('PRAGMA busy_timeout = 2000');
-  const schemaObjects = db.prepare(`SELECT name FROM sqlite_master WHERE name IN ('schedule_registry', 'idx_sched_cat')`).all() as Array<{ name: string }>;
+  const schemaObjects = db.prepare(`SELECT name FROM sqlite_master WHERE name IN ('schedule_registry', 'idx_sched_cat', 'schedule_runs', 'idx_schedule_runs_schedule_fired')`).all() as Array<{ name: string }>;
   const schemaNames = new Set(schemaObjects.map(({ name }) => name));
   if (!schemaNames.has('schedule_registry')) {
     db.run(`CREATE TABLE IF NOT EXISTS schedule_registry(
       id TEXT PRIMARY KEY, name TEXT NOT NULL, source TEXT NOT NULL,
       cron TEXT, interval_ms INT, command TEXT,
       category TEXT NOT NULL, domain TEXT,
-      enabled INT DEFAULT 1, last_seen TEXT, last_run TEXT,
+      enabled INT DEFAULT 1, disabled_reason TEXT, last_seen TEXT, last_run TEXT,
       note TEXT, managed_by TEXT DEFAULT 'manual', raw TEXT,
       run_via TEXT DEFAULT 'crontab',
       last_status TEXT, last_exit INT, last_duration_ms INT,
@@ -77,6 +80,7 @@ export function openSchedulesDb(path: string = schedulesDbPath()): Database {
   // 마이그레이션 — 기존 DB에 없는 컬럼 추가(S2 run_via + 실행관측성 P1).
   const cols = (db.prepare(`PRAGMA table_info(schedule_registry)`).all() as Array<{ name: string }>).map(c => c.name);
   if (!cols.includes('run_via')) db.run(`ALTER TABLE schedule_registry ADD COLUMN run_via TEXT DEFAULT 'crontab'`);
+  if (!cols.includes('disabled_reason')) db.run(`ALTER TABLE schedule_registry ADD COLUMN disabled_reason TEXT`);
   // 실행 결과 추적(P1) — "발화만 기록"에서 "성공/실패·소요·경로까지" 확장.
   if (!cols.includes('last_status')) db.run(`ALTER TABLE schedule_registry ADD COLUMN last_status TEXT`);
   if (!cols.includes('last_exit')) db.run(`ALTER TABLE schedule_registry ADD COLUMN last_exit INT`);
@@ -85,6 +89,8 @@ export function openSchedulesDb(path: string = schedulesDbPath()): Database {
   if (!cols.includes('last_error')) db.run(`ALTER TABLE schedule_registry ADD COLUMN last_error TEXT`);
   // 오토파일럿 계보(AL2) — 이 크론을 만든 미션(apm_id). null=오토파일럿 산물 아님.
   if (!cols.includes('autopilot_id')) db.run(`ALTER TABLE schedule_registry ADD COLUMN autopilot_id TEXT`);
+  // 다시 열 때는 DDL 을 안 돌린다(기존 규칙) — 이력 표·색인이 이미 있으면 건너뛴다.
+  if (!schemaNames.has('schedule_runs') || !schemaNames.has('idx_schedule_runs_schedule_fired')) ensureScheduleRunsSchema(db);
   return db;
 }
 
@@ -134,6 +140,7 @@ export interface RunResult {
   durationMs?: number | null;      // 소요(ms)
   via?: string;                    // tick | catchup | manual
   error?: string | null;           // 에러 요약(있으면)
+  runId?: string | null;           // 외부 실행과의 상관관계
 }
 /** 직전 실행 상태 조회(자기기억 이상 온셋 dedup 용·데몬 경로). 없으면 null. */
 export function getLastStatus(db: Database, id: string): string | null {
@@ -142,12 +149,24 @@ export function getLastStatus(db: Database, id: string): string | null {
 }
 
 export function markResult(db: Database, id: string, r: RunResult): void {
+  const at = r.at ?? new Date().toISOString();
+  const via = r.via ?? 'tick';
   db.run(
     `UPDATE schedule_registry SET last_run=?, last_status=?, last_exit=?,
        last_duration_ms=?, last_via=?, last_error=? WHERE id=?`,
-    [r.at ?? new Date().toISOString(), r.status, r.exit ?? null,
-     r.durationMs ?? null, r.via ?? 'tick', r.error ?? null, id],
+    [at, r.status, r.exit ?? null,
+     r.durationMs ?? null, via, r.error ?? null, id],
   );
+  const row = db.query(`SELECT name FROM schedule_registry WHERE id = ?`).get(id) as { name: string } | null;
+  if (!row) return;
+  try {
+    recordScheduleRun(db, id, {
+      at, status: r.status, exit: r.exit ?? null,
+      durationMs: r.durationMs ?? null, via, runId: r.runId ?? process.env.ELANOUS_RUN_ID ?? null,
+    });
+  } catch (error) {
+    debug.log('schedule.registry', 'run-history-write-failed', { id, error: String(error) });
+  }
 }
 
 // ── 스케줄 헬스(P2 관측성) — "무엇이 밀렸나/실패했나" 순수 판정 ──────────
@@ -268,24 +287,42 @@ export function cronEntryId(cron: string, effectiveCommand: string): string {
 }
 
 /** ★ 관측성 래퍼 unwrap (RFC-scheduler-execution-observability·2026-07-15) — crontab 라인이
- *  `bun scripts/cron-run.ts scripts/X.ts --a` 로 래핑돼도 id/name 파생은 안쪽 실제 target 기준으로.
- *  `scripts/cron-run.ts ` 토큰만 제거 → 래핑 전 원본과 동일 문자열 → id(sha1) 불변·마이그레이션 0.
+ *  `bun scripts/cron-run.ts --schedule-id <id> scripts/X.ts --a` 로 래핑돼도 id/name 파생은 안쪽 실제 target 기준으로.
+ *  래퍼와 그 id 인자만 제거 → 래핑 전 원본과 동일 문자열 → id(sha1) 불변·마이그레이션 0.
  *  순수·멱등(비래핑 라인은 그대로 반환). */
 export function unwrapCronCommand(command: string): string {
-  return command.replace(/(?:[^\s]*\/)?cron-run\.ts\s+/, '');
+  const shell = command.replace(/(?:\S*\/)?bun\s+(?:\S*\/)?cron-run\.ts\s+(?:--schedule-id\s+\S+\s+)?--shell\s+/, '');
+  if (shell !== command) return shell;
+  return command.replace(/(?:[^\s]*\/)?cron-run\.ts\s+(?:--schedule-id\s+\S+\s+)?/, '');
 }
 
-/** crontab 라인을 관측성 래퍼로 감싼다(P3) — `bun scripts/X.ts` → `bun scripts/cron-run.ts scripts/X.ts`.
+/** crontab 라인을 관측성 래퍼로 감싼다(P3) — `bun scripts/X.ts` → `bun scripts/cron-run.ts --schedule-id <id> scripts/X.ts`.
  *  bun .ts 잡만(.sh 는 bun 미실행·skip). 이미 래핑됐거나 cron-run 자신이면 그대로. 순수·멱등. */
 export function wrapCronLine(line: string): string {
   if (/cron-run\.ts/.test(line)) return line;                 // 이미 래핑
+  const parsed = parseCronLine(line);
+  if (!parsed) return line;
+  const id = cronEntryId(parsed.cron, parsed.command);
   // bun 직후의 target(상대 scripts/X.ts 또는 절대 .../scripts/X.ts) 앞에 래퍼 삽입. cron-run 자신 제외.
-  return line.replace(/(\bbun\s+)(\S*scripts\/(?!cron-run\b)[\w.-]+\.ts)/, '$1scripts/cron-run.ts $2');
+  return line.replace(/(\bbun\s+)(\S*scripts\/(?!cron-run\b)[\w.-]+\.ts)/, (_match, bun: string, target: string) =>
+    `${bun}scripts/cron-run.ts --schedule-id ${id} ${target}`);
+}
+
+/** 셸 해석기가 명시된 .sh 발화만 래핑한다. 원래 해석기 토큰과 인자를 그대로 보존한다. */
+export function wrapShellCronLine(line: string, opts: { bun: string; cronRun: string }): string {
+  if (/cron-run\.ts/.test(line)) return line;
+  const parsed = parseCronLine(line);
+  if (!parsed) return line;
+  const id = cronEntryId(parsed.cron, parsed.command);
+  return line.replace(/^(\s*\S+(?:\s+\S+){4}\s+(?:cd\s+\S+\s+&&\s+)?)((?:\S*\/)?(?:bash|zsh|sh))(?=\s+\S+\.sh(?:\s|$))/, (_match, prefix: string, interpreter: string) =>
+    `${prefix}${opts.bun} ${opts.cronRun} --schedule-id ${id} --shell ${interpreter}`);
 }
 
-/** wrapCronLine 역 — 래퍼 제거(가역). 비래핑 라인은 그대로. */
+/** wrapCronLine / wrapShellCronLine 역 — 래퍼와 id 인자 제거(가역). 비래핑 라인은 그대로. */
 export function unwrapCronLine(line: string): string {
-  return line.replace(/(\bbun\s+)(?:\S*\/)?cron-run\.ts\s+/, '$1');
+  const shell = line.replace(/(?:\S*\/)?bun\s+(?:\S*\/)?cron-run\.ts\s+(?:--schedule-id\s+\S+\s+)?--shell\s+/, '');
+  if (shell !== line) return shell;
+  return line.replace(/(\bbun\s+)(?:\S*\/)?cron-run\.ts\s+(?:--schedule-id\s+\S+\s+)?/, '$1');
 }
 
 /** ★ 삭제 안전 가드(2026-07-15) — 대상 행의 crontab 라인(raw)을 다른 활성 행이 공유하나? 순수.
@@ -298,9 +335,11 @@ export function sharesCrontabLine(rows: readonly { id: string; raw?: string | nu
 /** 스크립트 basename 추출 (scripts/foo.ts|sh → foo). 없으면 커맨드 첫 토큰. 래퍼는 unwrap 후 파생. */
 export function scriptName(command: string): string {
   const c = unwrapCronCommand(command);
+  const noCd = c.replace(/^cd\s+\S+\s*&&\s*/, '');
+  const shellTarget = noCd.match(/^(?:\S*\/)?(?:bash|zsh|sh)\s+(\S+\.sh)(?=\s|$)/);
+  if (shellTarget) return shellTarget[1]!.split('/').pop()!.replace(/\.sh$/, '');
   const m = c.match(/scripts\/([\w.-]+?)\.(?:ts|sh|mjs|js)\b/);
   if (m) return m[1]!;
-  const noCd = c.replace(/^cd\s+\S+\s*&&\s*/, '');
   const tokens = noCd.split(/\s+/);
   // bun/node 런처면 다음 토큰(실 스크립트)을 이름 원천으로 — `bun bin/elanous.mjs` → elanous.mjs(bun 아님).
   let head = tokens[0] ?? c;
@@ -323,7 +362,10 @@ export function inferCategory(command: string): ScheduleCategory {
 
 /** 현재 crontab 원문 반환(없으면 ''). */
 export function readCrontab(): string {
-  try { return execFileSync('crontab', ['-l'], { encoding: 'utf-8' }); }
+  // ⛔ stderr 를 물려받지 않는다 — 크론이 없는 기계에서 「no crontab for <user>」가 TUI 화면 한가운데 찍혔다
+  //   (2026-09-26 베어 Ubuntu 26.04 실측 · UX 17). 크론 없음은 정상이라 빈 문자열이다.
+  // env 명시 — bun 은 env 없이 부르면 «기동 시» PATH 로 찾는다(시험이 PATH 앞에 둔 가짜 crontab 을 지나쳐 실물을 연다).
+  try { return execFileSync('crontab', ['-l'], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'], env: process.env }); }
   catch { return ''; } // no crontab for user
 }
 
@@ -333,7 +375,9 @@ export function readCrontab(): string {
 export function inventoryCrontab(db: Database, opts: { crontab?: string; now?: string } = {}): { total: number; added: number; disabled: number; vanished: number } {
   const text = opts.crontab ?? readCrontab();
   const now = opts.now ?? new Date().toISOString();
-  const existing = new Set((db.prepare(`SELECT id FROM schedule_registry`).all() as Array<{ id: string }>).map(r => r.id));
+  const existing = new Map((db.prepare(`SELECT id, name, command, source, run_via FROM schedule_registry`).all() as Array<{
+    id: string; name: string; command: string | null; source: string; run_via: string;
+  }>).map(r => [r.id, r]));
   let total = 0, added = 0, disabled = 0, vanished = 0;
   const seenIds = new Set<string>();
   for (const line of text.split('\n')) {
@@ -348,9 +392,9 @@ export function inventoryCrontab(db: Database, opts: { crontab?: string; now?: s
       const off = parseDisabledCronLine(line);
       if (!off) continue;
       const offId = cronEntryId(off.cron, unwrapCronCommand(off.command));
-      if (!existing.has(offId)) continue;
+      if (existing.get(offId)?.source !== 'crontab' || existing.get(offId)?.run_via === 'trigger') continue;
       seenIds.add(offId);
-      db.run(`UPDATE schedule_registry SET enabled = 0, last_seen = ? WHERE id = ?`, [now, offId]);
+      db.run(`UPDATE schedule_registry SET enabled = 0, disabled_reason = 'manual', last_seen = ? WHERE id = ?`, [now, offId]);
       disabled++;
       continue;
     }
@@ -359,19 +403,32 @@ export function inventoryCrontab(db: Database, opts: { crontab?: string; now?: s
     //   → 래핑 전후 id(sha1) 동일·last_run/계보/adopt 승계·마이그레이션 0. command/raw 는 실제 라인 보존.
     const eff = unwrapCronCommand(parsed.command);
     const id = cronEntryId(parsed.cron, eff);
-    const name = scriptName(eff);
+    const prior = existing.get(id);
+    const name = prior && prior.command === parsed.command ? prior.name : deriveScheduleName(eff);
     const category = inferCategory(eff);
     seenIds.add(id);
-    if (!existing.has(id)) added++;
+    // A lingering crontab line after migration is not a request to override the
+    // trigger's state (including an explicit disable). Keep the migrated row intact.
+    if (prior?.run_via === 'trigger') continue;
+    if (!prior) added++;
     db.run(
       `INSERT INTO schedule_registry (id, name, source, cron, command, category, domain, enabled, last_seen, managed_by, raw)
        VALUES (?, ?, 'crontab', ?, ?, ?, 'finance', 1, ?, 'manual', ?)
        ON CONFLICT(id) DO UPDATE SET
          name=excluded.name, cron=excluded.cron, command=excluded.command,
-         category=excluded.category, enabled=1, last_seen=excluded.last_seen, raw=excluded.raw`,
+         category=excluded.category, enabled=1, disabled_reason=NULL, last_seen=excluded.last_seen, raw=excluded.raw`,
       [id, name, parsed.cron, parsed.command, category, now, line.trim()],
     );
   }
+  // Only repair rows with recorded inventory provenance. Legacy disabled rows have
+  // no disable reason; last_via='trigger' alone cannot distinguish manual disable.
+  const repair = db.prepare(`SELECT id FROM schedule_registry WHERE source = 'crontab'
+    AND run_via = 'trigger' AND enabled = 0 AND last_via = 'trigger'
+    AND disabled_reason = 'vanished'`).all() as Array<{ id: string }>;
+  for (const { id } of repair) {
+    db.run(`UPDATE schedule_registry SET source = 'trigger', enabled = 1, disabled_reason = NULL WHERE id = ?`, [id]);
+    debug.log('schedule.registry', 'trigger-row-repaired', { id });
+  }
   // ⭐ 줄이 통째로 지워진 crontab-origin 행 — 주석도 활성도 아니니 루프가 안 본다.
   //   ⛔ 행을 지우지 않는다(prune 계약). 끄기만 한다.
   //   ⛔ source='crontab' 만 — inventoryInternalSchedules 가 넣는 내부 행은 crontab 에
@@ -379,11 +436,11 @@ export function inventoryCrontab(db: Database, opts: { crontab?: string; now?: s
   //   ⛔ 빈 문자열은 읽기 실패와 같다 — 「전부 사라졌다」로 읽으면 한 번의 실패가 전 스케줄을 끈다.
   if (text !== '') {
     const missing = db.prepare(
-      `SELECT id FROM schedule_registry WHERE source = 'crontab' AND enabled = 1`,
+      `SELECT id FROM schedule_registry WHERE source = 'crontab' AND enabled = 1 AND run_via != 'trigger'`,
     ).all() as Array<{ id: string }>;
     for (const row of missing) {
       if (seenIds.has(row.id)) continue;
-      db.run(`UPDATE schedule_registry SET enabled = 0 WHERE id = ?`, [row.id]);
+      db.run(`UPDATE schedule_registry SET enabled = 0, disabled_reason = 'vanished' WHERE id = ?`, [row.id]);
       vanished++;
     }
   }
@@ -534,25 +591,23 @@ export function installedCronRoot(
  * 크론 `cd` 대상. 🩸 2026-09-24: 전역 `elanous`·데몬이 설치본으로 옮긴 뒤 `import.meta.dir` 는 판 폴더
  * (`~/.local/share/elanous/versions/<판>/node_modules/elanous`)로 풀린다 — 그 경로를 크론에 박으면
  * 야간 정리(#20214)가 그 판을 지우는 날 크론이 조용히 죽는다.
- * ⇒ 설치본이면 ① 리더 트리(`~/.elanous/leader.json` — 종전 크론이 `cd` 하던 체크아웃) ② 없으면 고정 경로 `current`.
+ * ⇒ 설치본이면 설정 `ops.cronRepoRoot` 우선, 없으면 고정 경로 `current`.
  * 설치본이 아니면(체크아웃) 그대로.
  */
 export function cronRepoRoot(
   codeRoot: string,
-  deps: { home?: string; exists?: (p: string) => boolean; readLeader?: () => string | null } = {},
+  deps: { exists?: (p: string) => boolean; configuredRoot?: () => string | undefined } = {},
 ): string {
   const exists = deps.exists ?? existsSync;
   const m = /^(.*)\/versions\/[^/]+\/node_modules\/elanous\/?$/.exec(codeRoot.replace(/\\/g, '/'));
   if (!m || hasGitAbove(codeRoot, exists)) return codeRoot;
-  const home = deps.home ?? homedir();
-  const leader = (deps.readLeader ?? (() => {
+  const configured = (deps.configuredRoot ?? (() => {
     try {
-      const raw = JSON.parse(readFileSync(join(home, '.elanous', 'leader.json'), 'utf-8')) as { tree?: unknown };
-      return typeof raw.tree === 'string' ? raw.tree : null;
-    } catch { return null; }
-  }))();
-  if (leader && exists(leader)) return leader;
-  return `${m[1]}/current/node_modules/elanous`;
+      const { getUserConfig } = require('../user-config.js') as typeof import('../user-config.js');
+      return getUserConfig().ops?.cronRepoRoot;
+    } catch { return undefined; }
+  }))()?.trim();
+  return configured || `${m[1]}/current/node_modules/elanous`;
 }
 
 function hasGitAbove(dir: string, exists: (p: string) => boolean): boolean {
@@ -583,7 +638,7 @@ export function buildCronLine(
   cron: string, command: string,
   opts: { repo?: string; bun?: string; logName?: string } = {},
 ): string {
-  const repo = opts.repo ?? repoRoot();
+  const repo = opts.repo ?? repoRoot(); // default cron cwd → cronRepoRoot → ops.cronRepoRoot or installed current
   const bun = opts.bun ?? process.execPath; // 데몬은 bun 하에서 구동
   const cmd = command.trim();
   // cron의 기본 PATH에는 ~/.bun/bin이 없을 수 있다. 직접 실행과 cd/세미콜론 뒤의
@@ -644,6 +699,6 @@ export function applyCrontab(text: string, opts: { backupDir?: string; now?: str
   const stamp = (opts.now ?? new Date().toISOString()).replace(/[:.]/g, '-');
   const backup = join(dir, `crontab-cronmanage-${stamp}.bak`);
   try { writeFileSync(backup, readCrontab()); } catch { /* 최초엔 빈 crontab */ }
-  execFileSync('crontab', ['-'], { input: text.replace(/\n*$/, '\n'), encoding: 'utf-8' });
+  execFileSync('crontab', ['-'], { input: text.replace(/\n*$/, '\n'), encoding: 'utf-8', env: process.env });
   return backup;
 }

package/src/domains/schedule-runs.ts

@@ -0,0 +1,132 @@
+import type { Database } from 'bun:sqlite';
+
+/** A fired execution belongs to the stable registry id, not to a derived (and possibly shared) name. */
+export interface ScheduleRun {
+  id: number;
+  schedule_id: string;
+  fired_at: string;
+  status: string;
+  exit: number | null;
+  duration_ms: number | null;
+  via: string;
+  run_id: string | null;
+  log_ref: string | null;
+}
+
+export interface ScheduleRunResult {
+  at?: string;
+  status: string;
+  exit?: number | null;
+  durationMs?: number | null;
+  via?: string;
+  runId?: string | null;
+  logRef?: string | null;
+}
+
+/** Called by the schedules.db opener; also usable with an isolated in-memory Database. */
+export function ensureScheduleRunsSchema(db: Database): void {
+  db.run(`CREATE TABLE IF NOT EXISTS schedule_runs (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    schedule_id TEXT NOT NULL,
+    fired_at TEXT NOT NULL,
+    status TEXT NOT NULL,
+    exit INTEGER,
+    duration_ms INTEGER,
+    via TEXT NOT NULL,
+    run_id TEXT,
+    log_ref TEXT
+  )`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_schedule_runs_schedule_fired
+    ON schedule_runs(schedule_id, fired_at DESC, id DESC)`);
+}
+
+function utcScheduleTime(value: string, field: 'at' | 'before' | 'cursor.firedAt'): string {
+  const match = /^(\d{4})-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d)(?:\.\d{1,9})?(?:Z|([+-])(\d\d):(\d\d))$/.exec(value);
+  if (!match) throw new RangeError(`${field} must be an ISO timestamp`);
+  const [, y, mo, d, h, mi, s, , tzH, tzM] = match;
+  const year = Number(y), month = Number(mo), day = Number(d);
+  const daysInMonth = [31, year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28,
+    31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  if (month < 1 || month > 12 || day < 1 || day > daysInMonth[month - 1]!
+    || Number(h) > 23 || Number(mi) > 59 || Number(s) > 59
+    || (tzH !== undefined && (Number(tzH) > 23 || Number(tzM) > 59))
+    || !Number.isFinite(Date.parse(value))) {
+    throw new RangeError(`${field} must be an ISO timestamp`);
+  }
+  // 기록 시각(at)은 ms 로 맞춰 저장하고, 조회 경계(before·cursor)는 원문 그대로 SQL julianday 에 넘긴다(ms 아래 자릿수 보존).
+  return field === 'at' ? new Date(value).toISOString() : value;
+}
+
+/** Append a fire; retain the newest 500 per schedule (including simultaneous fires). */
+export function recordScheduleRun(db: Database, scheduleId: string, result: ScheduleRunResult): void {
+  const firedAt = utcScheduleTime(result.at ?? new Date().toISOString(), 'at');
+  db.transaction(() => {
+    db.run(`INSERT INTO schedule_runs
+      (schedule_id, fired_at, status, exit, duration_ms, via, run_id, log_ref)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+      scheduleId, firedAt, result.status,
+      result.exit ?? null, result.durationMs ?? null, result.via ?? 'unknown',
+      result.runId ?? null, result.logRef ?? null,
+    ]);
+    db.run(`DELETE FROM schedule_runs WHERE schedule_id = ? AND id NOT IN (
+      SELECT id FROM schedule_runs WHERE schedule_id = ?
+      ORDER BY fired_at DESC, id DESC LIMIT 500
+    )`, [scheduleId, scheduleId]);
+  })();
+}
+
+/** Exclusive ISO before filter, or a (firedAt, id) cursor for lossless equal-time paging. */
+/** ISO 시각 → 1970 이후 나노초(BigInt) — 오프셋·소수 9자리까지 보존(SQLite julianday 는 ms 아래를 버린다). 못 읽으면 null. */
+function instantNs(value: string): bigint | null {
+  const m = /^(\d{4})-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d)(?:\.(\d{1,9}))?(?:Z|([+-])(\d\d):(\d\d))$/.exec(value);
+  if (!m) return null;
+  const [, y, mo, d, h, mi, sec, frac = '', sign, tzH = '0', tzM = '0'] = m;
+  const ms = Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi), Number(sec));
+  if (!Number.isFinite(ms)) return null;
+  const offsetMin = sign ? (sign === '-' ? -1 : 1) * (Number(tzH) * 60 + Number(tzM)) : 0;
+  return (BigInt(ms) - BigInt(offsetMin) * 60_000n) * 1_000_000n + BigInt(frac.padEnd(9, '0'));
+}
+
+export function listScheduleRuns(
+  db: Database, scheduleId: string,
+  opts: { limit?: number; before?: string; cursor?: { firedAt: string; id: number } } = {},
+): ScheduleRun[] {
+  const limit = opts.limit ?? 50;
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 500) throw new RangeError('limit must be an integer from 1 to 500');
+  const before = opts.before === undefined ? undefined : instantNs(utcScheduleTime(opts.before, 'before'));
+  const cursor = opts.cursor === undefined ? undefined : {
+    ns: instantNs(utcScheduleTime(opts.cursor.firedAt, 'cursor.firedAt')), id: opts.cursor.id,
+  };
+  if (cursor && (!Number.isSafeInteger(cursor.id) || cursor.id < 1)) throw new RangeError('cursor.id must be a positive safe integer');
+  // 표가 아직 없으면(이력 도입 전 DB · 읽기만 하는 경로) 빈 이력이다.
+  if (!db.prepare(`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'schedule_runs'`).get()) return [];
+  // 스케줄마다 최근 500줄만 남기므로 그 스케줄 행을 모두 읽어 «순간»으로 거르고 정렬한다 — 오프셋·소수 자릿수가 다른 옛 기록이 섞여도 경계가 맞다.
+  const rows = db.prepare(`SELECT id, schedule_id, fired_at, status, exit, duration_ms, via, run_id, log_ref
+    FROM schedule_runs WHERE schedule_id = ?`).all(scheduleId) as ScheduleRun[];
+  const withNs = rows.map((row) => ({ row, ns: instantNs(String(row.fired_at)) }))
+    .filter((r): r is { row: ScheduleRun; ns: bigint } => r.ns !== null)
+    .filter(({ ns }) => before === undefined || before === null || ns < before)
+    .filter(({ row, ns }) => !cursor || cursor.ns === null || ns < cursor.ns || (ns === cursor.ns && Number(row.id) < cursor.id));
+  withNs.sort((a, b) => (a.ns === b.ns ? (Number(b.row.id) > Number(a.row.id) ? 1 : -1) : (b.ns > a.ns ? 1 : -1)));
+  return withNs.slice(0, limit).map(({ row }) => row);
+}
+
+/** Prefer the actual task/subcommand over its shell, Bun, and elanous launchers. */
+export function deriveScheduleName(command: string): string {
+  let cmd = command.trim();
+  cmd = cmd.replace(/^cd\s+\S+\s*&&\s*/, '');
+  cmd = cmd.replace(/^(?:(?:env\s+)?[A-Za-z_][A-Za-z_0-9]*=\S+\s+)+/, '');
+  cmd = cmd.replace(/^(?:\S*\/)?(?:bun(?:\s+run)?|node)\s+/, '');
+  cmd = cmd.replace(/^(?:\S*\/)?(?:scripts\/)?cron-run\.ts\s+(?:(?:--schedule-id\s+\S+|--shell\s+\S+)\s+)*/, '');
+  cmd = cmd.replace(/^(?:\S*\/)?(?:bun(?:\s+run)?|node)\s+/, '');
+  cmd = cmd.replace(/^(?:\S*\/)?(?:bash|zsh|sh)\s+/, '');
+  cmd = cmd.replace(/^(?:\S*\/)?bin\/elanous\.mjs\s+|^elanous\s+/, '');
+  const tokens = cmd.split(/\s+/);
+  const head = tokens[0] ?? '';
+  if (/\.(?:ts|js|mjs|sh)$/.test(head)) {
+    const script = head.split('/').pop()!.replace(/\.(?:ts|js|mjs|sh)$/, '');
+    const arg = tokens[1];
+    return script === 'bot-routine' && arg && !arg.startsWith('-') ? `${script} ${arg}` : script;
+  }
+  return tokens.slice(0, head === 'harness' ? 3 : 2).filter(Boolean).join(' ') || command.trim();
+}

package/src/domains/schedule-state.ts

@@ -0,0 +1,152 @@
+import { execFileSync } from 'node:child_process';
+import { cronMatches, matchField } from './cron-match.js';
+import { calendarFields, resolveTimeZone } from '../time/format.js';
+import { parseCronLine, unwrapCronCommand, type ScheduleRow } from './schedule-registry.js';
+
+export type ScheduleState = 'live' | 'firing' | 'stale' | 'off';
+/** Next scheduled instants in the runner's configured timezone, including DST folds/gaps. */
+export function nextRuns(cron: string, now: Date, count = 5, opts?: { timeZone?: string }): string[] {
+  const fields = cron.trim().split(/\s+/);
+  if (fields.length !== 5 || !fields.every(f => /^[\d*,\-/]+$/.test(f)) ||
+      !Number.isFinite(now.getTime()) || !Number.isInteger(count) || count < 1) return [];
+  const [minute, hour, dom, month, dow] = fields as [string, string, string, string, string];
+  if (count > 5) return [];
+  const minutes = Array.from({ length: 60 }, (_, i) => i).filter(i => matchField(minute, i, 0, 59));
+  const hours = Array.from({ length: 24 }, (_, i) => i).filter(i => matchField(hour, i, 0, 23));
+  if (!minutes.length || !hours.length || !Array.from({ length: 12 }, (_, i) => i + 1).some(i => matchField(month, i, 1, 12))) return [];
+  const timeZone = opts?.timeZone ?? resolveTimeZone().timeZone;
+  const start = calendarFields(now, { timeZone });
+  const result: number[] = [];
+  // Five leap-day occurrences can span 20 years. For the API's count=5,
+  // even impossible dates require only ~14,600 cheap calendar checks.
+  const firstDay = Date.UTC(start.year, start.month - 1, start.day);
+  const endDay = Date.UTC(start.year + Math.max(6, Math.min(count, 5) * 8), start.month - 1, start.day);
+  for (let day = firstDay; day < endDay && result.length < count; day += 86_400_000) {
+    const date = new Date(day);
+    const mon = date.getUTCMonth() + 1, dateNum = date.getUTCDate();
+    if (!matchField(month, mon, 1, 12)) continue;
+    const weekday = date.getUTCDay();
+    const domMatches = matchField(dom, dateNum, 1, 31);
+    const dowMatches = matchField(dow.replace(/7/g, '0'), weekday, 0, 6);
+    if (dom !== '*' && dow !== '*' ? !(domMatches || dowMatches) : !(domMatches && dowMatches)) continue;
+
+    // UTC noon of this wall date and its neighbors cover ordinary DST folds/gaps.
+    // Validate each projected instant with the runner's canonical cron matcher.
+    const offsets = new Set<number>();
+    for (const delta of [-12, 12, 36]) {
+      const sample = day + delta * 3_600_000;
+      const wall = calendarFields(new Date(sample), { timeZone });
+      offsets.add((Date.UTC(wall.year, wall.month - 1, wall.day, wall.hour, wall.minute) - sample) / 60_000);
+    }
+    const candidates: number[] = [];
+    for (const h of hours) for (const m of minutes) {
+      const wallMs = day + h * 3_600_000 + m * 60_000;
+      for (const offset of offsets) {
+        const ms = wallMs - offset * 60_000;
+        if (ms > now.getTime()) candidates.push(ms);
+      }
+    }
+    candidates.sort((a, b) => a - b);
+    for (const ms of candidates) {
+      if (ms === result[result.length - 1]) continue;
+      if (cronMatches(cron, new Date(ms), { timeZone })) result.push(ms);
+      if (result.length === count) break;
+    }
+  }
+  return result.map(ms => new Date(ms).toISOString());
+}
+
+function futureRuns(row: ScheduleRow, now: Date): string[] {
+  if (row.cron) return nextRuns(row.cron, now, 5);
+  if (row.interval_ms && row.interval_ms > 0) {
+    const origin = row.last_run ? Date.parse(row.last_run) : now.getTime();
+    const base = Number.isFinite(origin) ? origin : now.getTime();
+    const first = base + (Math.floor((now.getTime() - base) / row.interval_ms) + 1) * row.interval_ms;
+    return Array.from({ length: 5 }, (_, i) => new Date(first + i * row.interval_ms!).toISOString());
+  }
+  return [];
+}
+
+/** Only actual scheduler ownership confers liveness; registry.enabled is not evidence. */
+export function computeScheduleState({ row, crontabLines, triggerRegistered, launchdLoaded, now, nextRuns: upcoming, timeZone }: {
+  row: ScheduleRow;
+  crontabLines: readonly string[];
+  triggerRegistered: boolean;
+  launchdLoaded: boolean;
+  now: Date;
+  nextRuns: readonly string[];
+  timeZone?: string;
+}): ScheduleState {
+  const inCrontab = crontabLines.some(line => {
+    const parsed = parseCronLine(line);
+    return !!parsed && parsed.cron === row.cron &&
+      (unwrapCronCommand(parsed.command).trim() === unwrapCronCommand(row.command ?? '').trim() ||
+        (!!row.raw && line.trim() === row.raw.trim()));
+  });
+  const owned = inCrontab || triggerRegistered || launchdLoaded;
+  if (!owned) return 'off';
+  const last = row.last_run ? Date.parse(row.last_run) : NaN;
+  const interval = row.interval_ms && row.interval_ms > 0 ? row.interval_ms : null;
+  const first = upcoming.length ? Date.parse(upcoming[0]!) : NaN;
+  const second = upcoming.length > 1 ? Date.parse(upcoming[1]!) : NaN;
+  const period = interval ?? (Number.isFinite(first) && Number.isFinite(second) ? second - first : null);
+  // No recorded fire means a miss cannot be measured — that is `no-history` (a card flag), not `stale` (a suspected miss).
+  if (!Number.isFinite(last)) return 'live';
+  if (row.cron) {
+    // Only due instants after the last fire can be missed. In particular, a
+    // weekday cron has no missing fires over the weekend, however long it is.
+    const due = nextRuns(row.cron, new Date(last), 3, { timeZone });
+    if (due.length === 3 && Date.parse(due[2]!) <= now.getTime()) return 'stale';
+  } else if (period && period > 0 && now.getTime() - last > 2 * period) return 'stale';
+  if (period && period > 0 && now.getTime() - last <= period) return 'firing';
+  return 'live';
+}
+
+function normalizedCommand(command: string | null): string {
+  return unwrapCronCommand(command ?? '').trim()
+    .replace(/\s*>>?\s*\S+(?:\s+2>&1)?\s*$/, '')
+    .replace(/^(?:cd\s+\S+\s*&&\s*)?(?:\S*\/)?(?:bun|node)\s+/, '')
+    .replace(/\s+/g, ' ');
+}
+
+/** Mark every concurrently owned copy, not historical/off copies. */
+export function findDuplicates<T extends { command: string | null; state: ScheduleState; flags?: string[] }>(rows: T[]): T[] {
+  const byCommand = new Map<string, T[]>();
+  for (const row of rows) {
+    if (row.state === 'off') continue;
+    const key = normalizedCommand(row.command);
+    if (key) byCommand.set(key, [...(byCommand.get(key) ?? []), row]);
+  }
+  for (const group of byCommand.values()) {
+    if (group.length < 2) continue;
+    for (const row of group) row.flags = [...new Set([...(row.flags ?? []), 'duplicate'])];
+  }
+  return rows;
+}
+
+export function displayName(command: string): string {
+  let text = command.trim().replace(/^cd\s+(?:'[^']+'|"[^"]+"|\S+)\s*&&\s*/, '');
+  text = text.replace(/^(?:(?:export\s+)?[\w]+=(?:'[^']*'|"[^"]*"|\S+)\s+)+/, '');
+  text = text.replace(/^(?:\S*\/)?(?:bun|node)\s+/, '');
+  text = text.replace(/^(?:\S*\/)?scripts\/cron-run\.ts\s+(?:--shell\s+(?:bash|sh|zsh)\s+)?/, '');
+  text = text.replace(/^(?:\S*\/)?bin\/elanous\.mjs\s*/, '');
+  text = text.replace(/^(?:\S*\/)?scripts\//, 'scripts/');
+  text = text.replace(/^elanous\s+/, '');
+  return text.replace(/\s*>>?\s*\S+(?:\s+2>&1)?\s*$/, '').trim() || command.trim();
+}
+
+export interface LaunchdEntry { label: string; pid: number | null; lastExit: number | null }
+
+/** launchctl list only; never load/unload services. */
+export function listLaunchdElanous({ run = () => execFileSync('launchctl', ['list'], { encoding: 'utf8' }) }: {
+  run?: () => string;
+} = {}): LaunchdEntry[] {
+  try {
+    return run().split('\n').slice(1).map(line => {
+      const m = /^\s*(-|\d+)\s+(-|\d+)\s+(com\.elanous\.[^\s]+)\s*$/.exec(line);
+      return m ? { label: m[3]!, pid: m[1] === '-' ? null : Number(m[1]), lastExit: m[2] === '-' ? null : Number(m[2]) } : null;
+    }).filter((entry): entry is LaunchdEntry => entry !== null);
+  } catch { return []; }
+}
+
+export { futureRuns };

package/src/domains/telegram-kind-route.ts

@@ -0,0 +1,21 @@
+// 발송 목적(kind) → 텔레그램 채널 역할 · 대상. 가벼운 모듈(telegram.ts 를 import 하지 않는다 — outbound-alert 순환 방지).
+// 표에 없는 kind 는 undefined → 부르는 쪽이 옛 reportChannel 로 간다(투자 알림 등 기존 동작 그대로).
+import type { UserConfig } from '../user-config.js';
+import { channelForRole, resolveTelegramChannels } from './telegram-channels.js';
+
+export const DEFAULT_KIND_ROLES: Readonly<Record<string, string>> = {
+  intake: 'system', 'ops-report': 'system', 'ops-alert': 'system', 'ops-health': 'system',
+};
+
+export function roleForKind(cfg: UserConfig, kind?: string): string | undefined {
+  if (!kind) return undefined;
+  return cfg.telegram.kindRoles?.[kind] ?? DEFAULT_KIND_ROLES[kind];
+}
+
+/** The channel for a purpose kind — only with explicit `telegram.channels` and a mapped role. */
+export function kindRouteTarget(cfg: UserConfig, kind?: string): { botToken: string; chatId: number } | null {
+  const role = roleForKind(cfg, kind);
+  if (!role || !cfg.telegram.channels?.length) return null;
+  const ch = channelForRole(resolveTelegramChannels(cfg.telegram), role);
+  return ch?.botToken && Number.isFinite(ch.chatId) ? { botToken: ch.botToken, chatId: ch.chatId } : null;
+}

package/src/element-registry/address.ts

@@ -11,9 +11,7 @@
 //   tool:Bash               → { kind:'tool',    id:'Bash' }
 //
 // Permissive: accepts optional leading '@'. Unknown prefixes return null
-// so callers can fall back to kind-specific legacy parsers (e.g.
-// virtual-windows/addressing.ts still handles bare `pane:hex` +
-// combined `win:N/pane:hex` forms).
+// so callers can fall back to kind-specific parsers.
 
 import { ADDR_PREFIX_TO_KIND, KIND_PREFIX, type ElementKind, type ParsedElementAddress } from './types.js';