elanous 0.2.13 → 0.2.15

package/src/loops/registry.ts

@@ -1,5 +1,7 @@
 import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { isAbsolute, join, relative, resolve } from 'node:path';
+import { hostname } from 'node:os';
 import { parse as parseYaml } from 'yaml';
 import type { Database } from 'bun:sqlite';
 import { debug } from '../debug/log.js';
@@ -8,7 +10,10 @@ import { cronMatches } from '../domains/cron-match.js';
 import { resolveTimeZone } from '../time/format.js';
 import { inventoryCrontab, listSchedules, openSchedulesDb, type ScheduleRow } from '../domains/schedule-registry.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { getUserConfig, type UserConfig } from '../user-config.js';
 import { runGraph, type GraphRunState } from '../graph-runner/runner.js';
+import { FENCE_ROLES } from '../hq/hq.js';
+import { dueBefore, type CheckEntry } from './checker.js';
 
 export interface LoopRun {
   at: string;
@@ -22,6 +27,9 @@ export interface LoopEntry {
   id: string;
   title: string;
   description: string | null;
+  owner?: string | null;
+  ownerSource?: 'header' | 'config' | 'seat' | 'seat-arg' | 'default';
+  mode?: string | null;
   file: string;
   trigger: { cron: string | null; events: string[] };
   jobs: Array<{ id: string; cron: string | null; enabled: boolean; entryScript?: boolean }>;
@@ -33,9 +41,13 @@ export interface LoopRegistryOptions {
   root?: string;
   stateRoot?: string;
   now?: Date;
+  /** Inject a parsed config for isolated inventory checks. */
+  config?: UserConfig;
   /** An already-inventoried registry; keeps focused tests isolated. */
   schedules?: ScheduleRow[];
   scheduleAction?: (action: 'create' | 'enable' | 'disable', args: Record<string, unknown>) => Promise<unknown>;
+  /** Home used to expand `~`/`$HOME` in cron redirects; tests inject a temp dir instead of writing the real HOME. */
+  home?: string;
 }
 
 function graphFiles(dir: string): string[] {
@@ -55,10 +67,16 @@ const LOOP_MARKER = /#\s*elanous-loop=([A-Za-z0-9][\w.-]*)\s*$/;
 export function graphJobMatches(command: string | null, file: string, root: string, graphId?: string): boolean {
   if (!command) return false;
   if (graphId && command.match(LOOP_MARKER)?.[1] === graphId) return true;
-  const invocation = /(?:^|&&\s*|;\s*)(?:(?:\S*\/)?(?:bun|node)\s+(?:\S*\/)?bin\/elanous\.mjs|(?:\S*\/)?elanous)\s+(?:--test(?:=\S+|\s+\S+)\s+)?graph\s+run\s+(['"]?)([^\s'";&|]+)\1(?=\s|$|[;&|])/g;
-  for (const match of command.matchAll(invocation)) {
-    const arg = match[2]!;
-    if (resolve(root, arg) === file || (isAbsolute(arg) && resolve(arg) === file)) return true;
+  for (const segment of shellSegments(command)) {
+    for (const words of launchedCommands(segment)) {
+      const { script, args } = launchedScript(words);
+      if (!isElanousExecutable(script)) continue;
+      const graph = args[0]?.text === '--test' ? (args[1]?.text === 'graph' ? 1 : 2)
+        : args[0]?.text.startsWith('--test=') ? 1 : 0;
+      if (args[graph]?.text !== 'graph' || args[graph + 1]?.text !== 'run' || !args[graph + 2]) continue;
+      const arg = args[graph + 2]!.text;
+      if (resolve(root, arg) === file || (isAbsolute(arg) && resolve(arg) === file)) return true;
+    }
   }
   return false;
 }
@@ -66,9 +84,16 @@ export function graphJobMatches(command: string | null, file: string, root: stri
 /** `cron_entry` identifies the script actually launched by cron, not text in another command's arguments. */
 function cronEntryMatches(command: string | null, entry: string): boolean {
   if (!command) return false;
-  const invocation = command.match(/^(?:cd\s+\S+\s*&&\s*)?(?:(?:\S*\/)?(?:bun|node)\s+\S*cron-run\.ts\s+--schedule-id\s+\S+\s+--shell\s+)?(?:(?:\S*\/)?(?:bash|zsh|sh)\s+)?(['"]?)([^\s'";&|]+\.sh)\1(?=\s|$|[;&|])/);
-  const script = invocation?.[2];
-  return !!script && (script === entry || script.endsWith(`/${entry}`));
+  return shellSegments(command).some(segment => launchedCommands(segment).some(words => {
+    let index = 0;
+    if (/(?:^|\/)(?:bun|node)$/.test(words[0]?.text ?? '') && /(?:^|\/)cron-run\.ts$/.test(words[1]?.text ?? '')) {
+      index = words.findIndex(word => word.text === '--shell') + 1;
+      if (index === 0) return false;
+    }
+    if (/(?:^|\/)(?:sh|bash|zsh)$/.test(words[index]?.text ?? '')) index++;
+    const script = words[index]?.text;
+    return !!script && /\.sh$/.test(script) && (script === entry || script.endsWith(`/${entry}`));
+  }));
 }
 
 function recentRuns(id: string, stateRoot: string, count = 5): LoopRun[] {
@@ -112,6 +137,46 @@ function schedules(opts: LoopRegistryOptions): ScheduleRow[] {
   } finally { db.close(); }
 }
 
+type OwnerSource = NonNullable<LoopEntry['ownerSource']>;
+function resolveOwner(id: string, title: string, config: UserConfig, header?: unknown, seat?: string, seatSource: OwnerSource = 'seat'): { owner: string; ownerSource: OwnerSource } {
+  if (typeof header === 'string' && /^(OP|TC|MK|UX)$/.test(header)) return { owner: header, ownerSource: 'header' };
+  const owners = config.loops?.owners;
+  const configured = owners && (Object.hasOwn(owners, id) ? owners[id] : Object.hasOwn(owners, title) ? owners[title] : undefined);
+  if (configured) return { owner: configured, ownerSource: 'config' };
+  if (seat) return { owner: seat, ownerSource: seatSource };
+  return { owner: config.loops?.defaultOwner ?? 'OP', ownerSource: 'default' };
+}
+
+/** Output redirects in the installed cron line (including a quoted hq-fence payload) estimate runs, not success. */
+function cronLogMtime(command: string, home: string = homedir()): { at?: string; targets: number } {
+  const expandHome = (path: string) => path.replace(/^~(?=\/)/, home).replace(/^\$HOME(?=\/)/, home);
+  const operand = String.raw`(?:'([^']+)'|"([^"]+)"|([^\s;|&'"<>]+))`;
+  const cdPattern = new RegExp(String.raw`(?:^|[\s'"])cd\s+${operand}\s*&&`, 'g');
+  const redirectPattern = new RegExp(String.raw`(?:[12]|&)?>{1,2}\s*${operand}`, 'g');
+  const cds: Array<{ index: number; cwd: string }> = [];
+  for (const match of command.matchAll(cdPattern)) {
+    const path = expandHome(match[1] ?? match[2] ?? match[3]!);
+    cds.push({ index: match.index, cwd: resolve(cds.at(-1)?.cwd ?? home, path) });
+  }
+  let latest: number | undefined;
+  let targets = 0;
+  for (const match of command.matchAll(redirectPattern)) {
+    const path = expandHome(match[1] ?? match[2] ?? match[3]!);
+    if (path === '/dev/null') continue;
+    const cwd = [...cds].reverse().find(cd => cd.index < match.index)?.cwd ?? home;
+    const target = resolve(cwd, path);
+    targets++;
+    try {
+      const stat = statSync(target);
+      if (stat.isFile()) latest = Math.max(latest ?? -Infinity, stat.mtimeMs);
+    } catch (error) {
+      debug.log('loops.registry', 'cron-log-unavailable', { path: target, error: String(error) });
+    }
+  }
+  if (latest === undefined) debug.log('loops.registry', 'cron-log-unavailable', { command, targets, reason: 'no-output-files' });
+  return { at: latest === undefined ? undefined : new Date(latest).toISOString(), targets };
+}
+
 /** Where loop graphs live and where their cron line `cd`s — the same rule as the other elanous crons:
  *  the installed package when there is one, else this checkout. Never the caller's cwd: a loop started
  *  from a disposable worktree would schedule a cron into a directory that is about to disappear (🅣 09-29). */
@@ -125,6 +190,7 @@ export function listLoops(opts: LoopRegistryOptions = {}): LoopEntry[] {
   const root = resolve(opts.root ?? defaultLoopRoot());
   const stateRoot = opts.stateRoot ?? effectiveInstanceRoot();
   const rows = schedules(opts);
+  const config = opts.config ?? getUserConfig();
   const loops: LoopEntry[] = [];
   for (const file of graphFiles(join(root, 'graphs'))) {
     let doc: Record<string, unknown> | null;
@@ -149,8 +215,11 @@ export function listLoops(opts: LoopRegistryOptions = {}): LoopEntry[] {
       ...(entryRows.includes(row) ? { entryScript: true } : {}) }));
     const active = matched.filter(row => !!row.enabled && !!row.cron);
     const next = active.map(row => nextLoopFire(row.cron!, opts.now ?? new Date())).filter((v): v is string => v !== null).sort()[0] ?? null;
-    const entry: LoopEntry = { id: doc.graph_id, title: typeof header?.title === 'string' ? header.title : doc.graph_id,
-      description: typeof header?.description === 'string' ? header.description : null, file: relative(root, file),
+    const title = typeof header?.title === 'string' ? header.title : doc.graph_id;
+    const entry: LoopEntry = { id: doc.graph_id, title,
+      description: typeof header?.description === 'string' ? header.description : null,
+      ...resolveOwner(doc.graph_id, title, config, header?.owner),
+      mode: typeof header?.mode === 'string' ? header.mode : null, file: relative(root, file),
       trigger: { cron: declaredCron, events }, jobs, enabled: matched.some(row => !!row.enabled),
       lastRun: recentRuns(doc.graph_id, stateRoot, 1)[0] ?? null, nextRun: next };
     loops.push(entry);
@@ -159,6 +228,463 @@ export function listLoops(opts: LoopRegistryOptions = {}): LoopEntry[] {
   return loops;
 }
 
+export interface AllLoopEntry extends CheckEntry {
+  kind: 'graph' | 'seat' | 'cron-shell' | 'orchestrator' | 'unregistered';
+  title: string;
+  cron?: string;
+  command?: string;
+  /** True when the cron's fire gaps vary (e.g. `0 9,17 * * *`); `expectEveryMinutes` is then the longest gap. */
+  cronIrregular?: boolean;
+  fenceRole?: string;
+  host?: string;
+  observationCategory?: string;
+}
+
+/** Inspect only words of the launched command. Quoted arguments are kept whole, not searched for flags. */
+function launchedWords(command: string): Array<{ text: string; quoted: boolean }> {
+  const launched = command.replace(/^cd\s+(?:'[^']*'|"[^"]*"|\S+)\s*&&\s*/, '');
+  const words: Array<{ text: string; quoted: boolean }> = [];
+  let text = '';
+  let quoted = false;
+  let quote: string | null = null;
+  for (let i = 0; i < launched.length; i++) {
+    const ch = launched[i]!;
+    if (quote) {
+      if (ch === quote) quote = null;
+      else if (ch === '\\' && quote === '"' && i + 1 < launched.length) text += launched[++i];
+      else text += ch;
+    } else if (ch === "'" || ch === '"') { quote = ch; quoted = true; }
+    else if (ch === '\\' && i + 1 < launched.length) { text += launched[++i]; }
+    else if (ch === ';' || ch === '|' || ch === '&') break;
+    else if (/\s/.test(ch)) {
+      if (text || quoted) { words.push({ text, quoted }); text = ''; quoted = false; }
+    } else text += ch;
+  }
+  if (text || quoted) words.push({ text, quoted });
+  return words;
+}
+
+type LaunchWord = { text: string; quoted: boolean };
+
+function isElanousExecutable(script: string): boolean {
+  return /^(?:eln|elanous|elanous\.mjs)$/.test(script.split('/').pop() ?? '');
+}
+
+/** Skip only leading global CLI options, leaving the action words untouched. */
+function elanousActionStart(args: LaunchWord[]): number {
+  let start = 0;
+  while (args[start] && !args[start]!.quoted) {
+    const option = args[start]!.text;
+    if (option === '--test' || option.startsWith('--test=')) { start++; continue; }
+    if (option === '--config-dir' || option === '--state-dir') { start += 2; continue; }
+    if (option.startsWith('--config-dir=') || option.startsWith('--state-dir=')) { start++; continue; }
+    break;
+  }
+  return start;
+}
+
+/** Include every launched segment of a wrapper's quoted shell payload, in execution order. */
+function launchedCommandsWithFence(command: string): Array<{ words: LaunchWord[]; fenceRole?: string }> {
+  const launches: Array<{ words: LaunchWord[]; fenceRole?: string }> = [];
+  launchedCommand(command, undefined, (words, fenceRole) => { if (words.length) launches.push({ words, ...(fenceRole ? { fenceRole } : {}) }); });
+  return launches;
+}
+
+function launchedCommands(command: string): LaunchWord[][] {
+  return launchedCommandsWithFence(command).map(({ words }) => words);
+}
+
+/** Only executable-prefix wrappers are stripped; a quoted argument mentioning a loop is not a launch. */
+function launchedCommand(command: string, onFence?: (role: string) => void,
+  onLaunch?: (words: LaunchWord[], fenceRole?: string) => void, inheritedFenceRole?: string): LaunchWord[] {
+  const words = launchedWords(command);
+  let activeFenceRole = inheritedFenceRole;
+  const markFence = (role: string) => { activeFenceRole = role; onFence?.(role); };
+  const wrappers: Record<string, { values: readonly string[]; positionals: number }> = {
+    env: { values: ['-u', '--unset', '-C', '--chdir', '-S', '--split-string'], positionals: 0 },
+    flock: { values: ['-w', '--wait', '-E', '--conflict-exit-code'], positionals: 1 },
+    nice: { values: ['-n', '--adjustment'], positionals: 0 },
+    timeout: { values: ['-s', '--signal', '-k', '--kill-after'], positionals: 1 },
+    'hq-fence': { values: [], positionals: 0 },
+  };
+  let offset = 0;
+  while (offset < words.length) {
+    if (/(?:^|\/)(?:bun|node)$/.test(words[offset]?.text ?? '')
+      && /(?:^|\/)cron-run\.ts$/.test(words[offset + 1]?.text ?? '')
+      && words[offset + 2]?.text === '--schedule-id' && words[offset + 4]?.text === '--shell') {
+      offset += 5;
+      continue;
+    }
+    const name = words[offset]!.text.split('/').pop()!;
+    const spec = wrappers[name];
+    if (!spec || words[offset]!.quoted) {
+      const { script, args } = launchedScript(words.slice(offset));
+      if (!isElanousExecutable(script) || args[0]?.text !== 'hq' || args[1]?.text !== 'fence') break;
+      const separator = args.findIndex(word => word.text === '--' && !word.quoted);
+      if (separator < 0) break;
+      for (let i = 2; i < separator; i++) {
+        const role = args[i]?.text === '--role' && i + 1 < separator ? args[i + 1]?.text
+          : args[i]?.text.startsWith('--role=') ? args[i]!.text.slice('--role='.length) : undefined;
+        if (role) { markFence(role); break; }
+      }
+      offset = words.length - args.length + separator + 1;
+      continue;
+    }
+    if (name === 'hq-fence') {
+      let commandAt = offset + 1;
+      if (words[commandAt]?.text === '--role' && !words[commandAt]?.quoted) {
+        const role = words[commandAt + 1]?.text;
+        if (role && FENCE_ROLES.includes(role as typeof FENCE_ROLES[number])) {
+          markFence(role);
+          commandAt += words[commandAt + 2]?.text === '--' ? 3 : 2;
+        }
+      } else if (FENCE_ROLES.includes(words[commandAt]?.text as typeof FENCE_ROLES[number]) && !words[commandAt]?.quoted) {
+        markFence(words[commandAt]!.text);
+        commandAt++;
+      }
+      if (words[commandAt]?.quoted && words[commandAt]!.text.includes(' ')) {
+        const parts = shellSegments(words[commandAt]!.text);
+        for (const part of parts.slice(0, -1)) {
+          launchedCommand(part, onFence, onLaunch, activeFenceRole);
+        }
+        return launchedCommand(parts.at(-1) ?? '', onFence, onLaunch, activeFenceRole);
+      }
+      offset = commandAt;
+      continue;
+    }
+    let index = offset + 1;
+    while (index < words.length) {
+      const word = words[index]!;
+      if (word.text === '--' && !word.quoted) { index++; break; }
+      if (name === 'env' && /^[A-Za-z_][A-Za-z_0-9]*=/.test(word.text)) { index++; continue; }
+      if (name === 'nice' && /^-\d+$/.test(word.text) && !word.quoted) { index++; continue; }
+      if (!word.text.startsWith('-') || word.quoted) break;
+      const flag = word.text.split('=')[0]!;
+      index += spec.values.includes(flag) && !word.text.includes('=') ? 2 : 1;
+    }
+    index += spec.positionals;
+    if (name === 'flock' && words[index]?.text === '-c' && !words[index]?.quoted) {
+      const payload = words[index + 1]?.text;
+      if (!payload) return [];
+      // The payload is its own shell line: each segment may launch a loop.
+      const parts = shellSegments(payload);
+      for (const part of parts.slice(0, -1)) {
+        launchedCommand(part, onFence, onLaunch, activeFenceRole);
+      }
+      return launchedCommand(parts.at(-1) ?? '', onFence, onLaunch, activeFenceRole);
+    }
+    if (index >= words.length) break;
+    offset = index;
+  }
+  const launch = words.slice(offset);
+  if (launch.length) onLaunch?.(launch, activeFenceRole);
+  return launch;
+}
+
+/** Split a shell line at top-level `&&`, `||`, `;` and `|` only — separators inside quotes stay in their word. */
+export function shellSegments(command: string): string[] {
+  const segments: string[] = [];
+  let current = '';
+  let quote: '"' | "'" | null = null;
+  for (let i = 0; i < command.length; i++) {
+    const ch = command[i]!;
+    if (quote) {
+      current += ch;
+      if (ch === '\\' && quote === '"' && i + 1 < command.length) { current += command[++i]; continue; }
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '\\' && i + 1 < command.length) { current += ch + command[++i]; continue; }
+    if (ch === '"' || ch === "'") { quote = ch; current += ch; continue; }
+    const two = command.slice(i, i + 2);
+    if (two === '&&' || two === '||') { segments.push(current); current = ''; i++; continue; }
+    if (ch === ';' || ch === '|' || ch === '\n') { segments.push(current); current = ''; continue; }
+    current += ch;
+  }
+  segments.push(current);
+  return segments.map(segment => segment.trim()).filter(Boolean);
+}
+
+function cronFenceRole(command: string): string | undefined {
+  for (const segment of shellSegments(command)) {
+    let role: string | undefined;
+    launchedCommand(segment, value => { role = value; });
+    if (role) return role;
+  }
+  return undefined;
+}
+
+function fenceCommandTitle(command: string, role: string): string | undefined {
+  const launches = shellSegments(command).flatMap(segment => launchedCommands(segment));
+  const inner = launches.at(-1);
+  if (!inner?.length) return undefined;
+  const { script, args } = launchedScript(inner);
+  const executable = script.split('/').pop();
+  const action = elanousCronName(command) ?? (executable === 'git' ? [executable, args[0]?.text].filter(Boolean).join(' ')
+    : /^(?:sh|bash|zsh)$/.test(executable ?? '') ? args[0]?.text.split('/').pop() : executable);
+  return action ? `${action} (hq-fence ${role})` : undefined;
+}
+
+function launchedScript(words: LaunchWord[]): { script: string; args: LaunchWord[] } {
+  const offset = /^(?:.*\/)?(?:bun|node)$/.test(words[0]?.text ?? '') ? 1 : 0;
+  return { script: words[offset]?.text ?? '', args: words.slice(offset + 1) };
+}
+
+/** Return each launched action with its own fence role; one fenced segment cannot cover a sibling. */
+export function cronLaunchedActionsWithFence(command: string): Array<{ script: string; args: string[]; fenceRole?: string }> {
+  return shellSegments(command).flatMap(segment => launchedCommandsWithFence(segment).map(({ words, fenceRole }) => {
+    const { script, args } = launchedScript(words);
+    return { script, args: args.slice(isElanousExecutable(script) ? elanousActionStart(args) : 0).map(word => word.text),
+      ...(fenceRole ? { fenceRole } : {}) };
+  }));
+}
+
+/** Recognize direct .sh execution or sh/bash/zsh with option flags and a script or -c payload. */
+function isCronShellCommand(command: string): boolean {
+  return shellSegments(command).some(segment => launchedCommands(segment).some(words => {
+    const executable = words[0]?.text ?? '';
+    if (/\.sh$/.test(executable)) return true;
+    if (!/(?:^|\/)(?:sh|bash|zsh)$/.test(executable)) return false;
+    let index = 1;
+    let inline = false;
+    while (words[index] && /^-[a-zA-Z]+$/.test(words[index]!.text) && !words[index]!.quoted) {
+      inline ||= words[index]!.text.includes('c');
+      index++;
+    }
+    if (words[index]?.text === '--') index++;
+    return !!words[index] && (inline || /\.sh$/.test(words[index]!.text));
+  }));
+}
+
+function launchedSeat(command: string): string | undefined {
+  for (const segment of shellSegments(command)) {
+    for (const words of launchedCommands(segment)) {
+      const { script, args } = launchedScript(words);
+      const named = script.match(/(?:^|\/)(op|tc|mk|ux)-seat(?:\.[\w-]+)?$/i)?.[1];
+      if (named) return named.toUpperCase();
+      if (!/(?:^|\/)seat-loop(?:\.[\w-]+)?$/i.test(script)) continue;
+      for (let i = 0; i < args.length; i++) {
+        const arg = args[i]!;
+        if (arg.quoted) continue;
+        const seat = arg.text === '--seat' ? (!args[i + 1]?.quoted ? args[i + 1]?.text : undefined)
+          : arg.text.startsWith('--seat=') ? arg.text.slice('--seat='.length) : undefined;
+        if (seat && /^(OP|TC|MK|UX)$/i.test(seat)) return seat.toUpperCase();
+      }
+    }
+  }
+  return undefined;
+}
+
+function seatLoopCommand(command: string): { seat?: string; matched: boolean } {
+  for (const segment of shellSegments(command)) {
+    for (const words of launchedCommands(segment)) {
+      const { script, args } = launchedScript(words);
+      if (!isElanousExecutable(script)) continue;
+      const action = args.slice(elanousActionStart(args));
+      if (action[0]?.quoted || action[0]?.text !== 'seat' || action[1]?.quoted || action[1]?.text !== 'loop') continue;
+      if (!action.slice(2).some(word => !word.quoted && word.text === '--once')) continue;
+      const seatAt = action.findIndex((word, index) => index >= 2 && !word.quoted && word.text === '--seat');
+      const seat = seatAt >= 0 && !action[seatAt + 1]?.quoted ? action[seatAt + 1]?.text
+        : action.slice(2).find(word => !word.quoted && word.text.startsWith('--seat='))?.text.slice('--seat='.length);
+      return { matched: true, ...(seat && /^(OP|TC|MK|UX)$/.test(seat) ? { seat } : {}) };
+    }
+  }
+  return { matched: false };
+}
+
+function launchedOrchestrator(command: string): boolean {
+  return shellSegments(command).some(segment => launchedCommands(segment).some(words =>
+    /(?:^|\/)(?:\w+-)?orchestrator(?:\.[\w-]+)?$/i.test(launchedScript(words).script)));
+}
+
+/** Name only recognizable CLI entry points. Unknown actions remain visible via the unregistered cron warning. */
+function elanousCronName(command: string): string | undefined {
+  const known = new Set(['hq', 'harness', 'card', 'loop', 'graph', 'config', 'logs', 'where', '--version']);
+  for (const segment of shellSegments(command)) {
+    for (const words of launchedCommands(segment)) {
+      const { script, args } = launchedScript(words);
+      if (!isElanousExecutable(script)) continue;
+      const start = elanousActionStart(args);
+      const first = args[start];
+      const second = args[start + 1];
+      if (!first || first.quoted || !first.text || !known.has(first.text)) continue;
+      return second && !second.quoted && !second.text.startsWith('-') && !/^(?:\d*>|\d*>>|<|<<|&>|\|)$/.test(second.text)
+        ? `${first.text} ${second.text}` : first.text;
+    }
+  }
+  return undefined;
+}
+
+/** Number only unclaimed named jobs, in installed schedule order, for inventory and warning lookup alike. */
+function namedCronIds(rows: ScheduleRow[], graphClaimed: Set<string>): Map<string, string> {
+  const counts = new Map<string, number>();
+  const ids = new Map<string, string>();
+  const candidates = rows.filter(row => !graphClaimed.has(row.id) && row.source === 'crontab'
+    && row.run_via === 'crontab' && row.disabled_reason !== 'vanished'
+    && !launchedSeat(row.command ?? '') && !seatLoopCommand(row.command ?? '').matched && !launchedOrchestrator(row.command ?? '')
+    && !isCronShellCommand(row.command ?? '') && !!elanousCronName(row.command ?? ''));
+  // Reserve the existing owner-key slots before assigning newly recognized commands.
+  const established = (command: string): boolean => {
+    const name = elanousCronName(command);
+    if (!name) return false;
+    if (name === 'harness queue') return /\bqueue\s+tick\b/.test(command);
+    return ['hq heartbeat', 'hq arbiter-check', 'card intake-scan', 'loop status', 'loop list'].includes(name);
+  };
+  for (const row of [...candidates.filter(row => established(row.command ?? '')),
+    ...candidates.filter(row => !established(row.command ?? ''))]) {
+    const name = elanousCronName(row.command ?? '')!;
+    const base = `elanous:${name.replace(/\s+/g, '-')}`;
+    const count = (counts.get(base) ?? 0) + 1;
+    counts.set(base, count);
+    ids.set(row.id, `${base}${count > 1 ? `-${count}` : ''}`);
+  }
+  return ids;
+}
+
+/** Gaps between consecutive actual fires, rather than a guess based on cron text. A cron whose gaps vary
+ *  (e.g. `0 9,17 * * *` = 8h then 16h) is irregular: report the longest gap so «late» never fires early. */
+const CRON_PERIOD_SAMPLES = 8;
+function cronPeriod(cron: string | null, now: Date): { minutes: number; irregular: boolean } | undefined {
+  if (!cron) return undefined;
+  const fires: number[] = [];
+  let at = now;
+  for (let i = 0; i <= CRON_PERIOD_SAMPLES; i++) {
+    const next = nextLoopFire(cron, at);
+    if (!next) break;
+    fires.push(Date.parse(next));
+    at = new Date(next);
+  }
+  if (fires.length < 2) return undefined;
+  const gaps = fires.slice(1).map((fire, i) => (fire - fires[i]!) / 60_000);
+  const longest = Math.max(...gaps);
+  return { minutes: longest, irregular: gaps.some(gap => gap !== gaps[0]) };
+}
+
+function periodFields(period: { minutes: number; irregular: boolean } | undefined): Pick<AllLoopEntry, 'expectEveryMinutes' | 'cronIrregular'> {
+  if (!period) return {};
+  return { expectEveryMinutes: period.minutes, ...(period.irregular ? { cronIrregular: true } : {}) };
+}
+
+/** Inventory all installed loop agents without changing the graph-only `listLoops` contract. */
+export function listAllLoops(opts: LoopRegistryOptions = {}): AllLoopEntry[] {
+  const now = opts.now ?? new Date();
+  const config = opts.config ?? getUserConfig();
+  const rows = schedules(opts).filter(row => row.source === 'crontab' && row.run_via === 'crontab' && row.disabled_reason !== 'vanished');
+  const graphOpts = { ...opts, now, schedules: rows };
+  const graphLoops = listLoops(graphOpts);
+  const claimed = new Set<string>();
+  const all: AllLoopEntry[] = graphLoops.map(loop => {
+    for (const job of loop.jobs) claimed.add(job.id);
+    // The installed job's cron is what actually runs — a disabled install still beats the declared trigger.
+    const cron = loop.jobs.find(job => job.enabled && job.cron)?.cron ?? loop.jobs.find(job => job.cron)?.cron ?? loop.trigger.cron;
+    const runs = recentRuns(loop.id, opts.stateRoot ?? effectiveInstanceRoot());
+    const lastRun = runs[0] ?? null;
+    const period = cronPeriod(cron, now);
+    const dueAt = cron ? dueBefore(cron, now) : null;
+    const installed = rows.filter(row => loop.jobs.some(item => item.id === row.id));
+    const fenceRole = installed.map(row => cronFenceRole(row.command ?? '')).find((role): role is string => !!role);
+    const graphDoc = parseYaml(readFileSync(join(resolve(opts.root ?? defaultLoopRoot()), loop.file), 'utf8')) as Record<string, unknown> | null;
+    const header = graphDoc?.loop && typeof graphDoc.loop === 'object' && !Array.isArray(graphDoc.loop)
+      ? graphDoc.loop as Record<string, unknown> : {};
+    const declaredHost = typeof header.host === 'string' && header.host ? header.host : undefined;
+    const declaredCategory = typeof header.observationCategory === 'string' && header.observationCategory ? header.observationCategory : undefined;
+    return { kind: 'graph', id: loop.id, title: loop.title, owner: loop.owner ?? undefined, ownerSource: loop.ownerSource,
+      ...(declaredHost || installed.length ? { host: declaredHost ?? hostname() } : {}),
+      observationCategory: declaredCategory ?? 'graph.runner',
+      ...(fenceRole ? { fenceRole } : {}),
+      mode: loop.mode ?? undefined, enabled: loop.enabled, registered: loop.jobs.length > 0,
+      ...(cron ? { cron } : {}), ...periodFields(period),
+      ...(dueAt ? { dueAt } : {}),
+      ...(lastRun ? { lastRunAt: lastRun.at, lastStatus: lastRun.status } : {}),
+      recentStatuses: runs.map(run => run.status) };
+  });
+  const namedIds = namedCronIds(rows, claimed);
+  for (const row of rows) {
+    if (claimed.has(row.id)) continue;
+    const command = row.command ?? '';
+    const seat = launchedSeat(command);
+    const seatArg = seatLoopCommand(command).seat;
+    const orchestrator = launchedOrchestrator(command);
+    const shell = isCronShellCommand(command);
+    const namedId = namedIds.get(row.id);
+    const fenceRole = cronFenceRole(command);
+    const fencedGitPush = fenceRole === 'git-push' && fenceCommandTitle(command, fenceRole) === 'git push (hq-fence git-push)';
+    const kind: AllLoopEntry['kind'] = seat || seatArg ? 'seat' : orchestrator ? 'orchestrator' : 'cron-shell';
+    if (kind === 'cron-shell' && !shell && !namedId && !fencedGitPush) continue;
+    const cron = row.cron;
+    const period = cronPeriod(cron, now);
+    const dueAt = cron ? dueBefore(cron, now) : null;
+    const id = seatArg ? `elanous:seat-loop:${seatArg}` : seat ? `${seat.toLowerCase()}-seat:${row.id}` : namedId ?? row.id;
+    if (seatArg && all.some(entry => entry.id === id)) continue;
+    const title = seatArg ? `${seatArg} seat loop` : seat ? `${seat} seat` : row.note || (fenceRole ? fenceCommandTitle(command, fenceRole) : undefined) || (namedId ? elanousCronName(command) : undefined) || row.name;
+    const { at: logMtime, targets } = (kind === 'cron-shell' || seatArg) && command ? cronLogMtime(command, opts.home) : { at: undefined, targets: 0 };
+    const recorded = row.last_run && Number.isFinite(Date.parse(row.last_run)) ? row.last_run : undefined;
+    const picked = logMtime && (!recorded || Date.parse(logMtime) >= Date.parse(recorded)) ? 'log-mtime'
+      : recorded ? 'registry' : 'none';
+    debug.log('loops.registry', 'cron-last-run', { id, targets, picked });
+    all.push({ kind, id, title,
+      ...resolveOwner(id, title, config, undefined, seatArg ?? seat, seatArg ? 'seat-arg' : 'seat'), ...(fenceRole ? { fenceRole } : {}),
+      host: hostname(), observationCategory: row.category,
+      enabled: !!row.enabled, registered: true,
+      ...(cron ? { cron } : {}), ...(command ? { command } : {}),
+      ...periodFields(period),
+      ...(dueAt ? { dueAt } : {}),
+      ...(picked === 'log-mtime' ? { lastRunAt: logMtime, evidence: picked }
+        : picked === 'registry' ? { lastRunAt: recorded, evidence: picked } : {}),
+      ...(row.last_status ? { lastStatus: row.last_status } : {}),
+      recentStatuses: row.last_status ? [row.last_status] : [] });
+  }
+  const warnings = unregisteredCronLoops(all, graphOpts);
+  for (const row of warnings) {
+    const title = `미등록: ${row.command ?? row.id}`;
+    all.push({ kind: 'unregistered', id: row.id, title,
+      ...resolveOwner(row.id, title, config), host: hostname(), observationCategory: row.category,
+      enabled: !!row.enabled, registered: false,
+      ...(row.cron ? { cron: row.cron } : {}), ...(row.command ? { command: row.command } : {}),
+      ...periodFields(cronPeriod(row.cron, now)), recentStatuses: [] });
+  }
+  const bySource: Record<OwnerSource, number> = { header: 0, config: 0, seat: 0, 'seat-arg': 0, default: 0 };
+  for (const loop of all) bySource[loop.ownerSource!]++;
+  debug.log('loop.check', 'ownership', { total: all.length, bySource });
+  debug.log('loops.registry', 'list-all', { count: all.length });
+  return all;
+}
+
+/** An unclaimed cron line with any elanous marker must surface as an unregistered warning. */
+function looksElanousRelated(command: string): boolean {
+  return /(?:^|[^\w.-])(?:elanous(?:\.mjs)?|eln|hq-fence)(?=$|[^\w.-])|(?:^|\/)\.elanous(?:\/|$)/i.test(command);
+}
+
+/** Crontab elanous loop launches not represented by any graph, seat, shell or orchestrator row. */
+export function unregisteredCronLoops(entries: AllLoopEntry[], opts: LoopRegistryOptions = {}): ScheduleRow[] {
+  const graphJobs = new Map(listLoops(opts).map(loop => [loop.id, loop.jobs.map(job => job.id)]));
+  const rows = schedules(opts);
+  const graphClaimed = new Set([...graphJobs.values()].flat());
+  const namedRows = new Map([...namedCronIds(rows, graphClaimed)].map(([rowId, name]) => [name, rowId]));
+  const accounted = entries.flatMap(entry => entry.kind === 'graph'
+    ? graphJobs.get(entry.id) ?? []
+    : entry.kind === 'unregistered' ? []
+      : [entry.kind === 'seat' && entry.id.startsWith('elanous:seat-loop:')
+        ? rows.find(row => row.command === entry.command && row.cron === entry.cron)?.id ?? entry.id
+        : entry.kind === 'seat' ? entry.id.slice(entry.id.indexOf(':') + 1)
+          : namedRows.get(entry.id) ?? entry.id]);
+  const claimed = new Set(accounted);
+  const related = rows.filter(row => row.source === 'crontab' && row.run_via === 'crontab'
+    && row.disabled_reason !== 'vanished' && row.disabled_reason !== 'manual'
+    && !!row.cron && looksElanousRelated(row.command ?? ''));
+  const warnings = related.filter(row => !claimed.has(row.id));
+  const relatedIds = new Set(related.map(row => row.id));
+  const registeredCount = accounted.filter(id => relatedIds.has(id)).length;
+  const counts = new Map<string, number>();
+  for (const id of accounted) counts.set(id, (counts.get(id) ?? 0) + 1);
+  const lines = related.filter(row => (counts.get(row.id) ?? 0) > 1);
+  if (related.length !== registeredCount + warnings.length || lines.length) {
+    debug.log('loops.registry', 'unaccounted', { lines: lines.map(row => row.raw ?? row.command ?? row.id) });
+    for (const row of lines) if (!warnings.includes(row)) warnings.push(row);
+  }
+  return warnings;
+}
+
 export function loopStatus(id: string, opts: LoopRegistryOptions = {}): LoopEntry & { recentRuns: LoopRun[] } {
   const loop = listLoops(opts).find(entry => entry.id === id);
   if (!loop) throw new Error(`loop not found: ${id}`);