elanous 0.2.34 → 0.2.35

package/src/dashboard/render/theme-resolver.ts

@@ -33,6 +33,12 @@ import { getTheme } from '../../themes/index.js';
 // same shape `pluginHost.loadThemeTokens` produces — not a full ThemeTokens.
 export type PluginThemeLoader = (id: string) => ThemeTokenInput | null | undefined;
 
+export interface PluginThemeAppliedEvent {
+  id: string;
+  tokensCount: number;
+  source: 'plugin';
+}
+
 export interface ResolveActiveThemeOptions {
   /** Raw `dashboard.theme` value from user-config. Shape is flexible:
    *  `null` | `string` | `{ active: string, ... }` | `{ tokens: {...} }`. */
@@ -44,17 +50,19 @@ export interface ResolveActiveThemeOptions {
    *  (so a broken plugin doesn't crash the dashboard) but reported
    *  here for visibility. */
   onPluginError?: (message: string) => void;
+  /** Called after plugin tokens have been merged into the resolved theme. */
+  onPluginApplied?: (event: PluginThemeAppliedEvent) => void;
 }
 
 /** Resolve the active dashboard theme from user-config, with preset
  *  + plugin + default fallback layers. Pure function — no I/O. */
 export function resolveActiveTheme(opts: ResolveActiveThemeOptions): ThemeTokens {
-  const { raw, loadPlugin, onPluginError } = opts;
+  const { raw, loadPlugin, onPluginError, onPluginApplied } = opts;
 
   // Extract active name + user overrides from the raw user-config
   // value. The config shape evolved over time — handle all known
   // forms defensively.
-  const activeName = extractActiveName(raw);
+  const activeName = getActiveThemeName(raw);
   const rawOverrides: ThemeTokenInput | undefined = extractOverrides(raw);
 
   // Branch 1: preset registry hit.
@@ -70,10 +78,20 @@ export function resolveActiveTheme(opts: ResolveActiveThemeOptions): ThemeTokens
     try {
       const contributed = loadPlugin(activeName);
       if (contributed) {
-        return mergeThemeTokens(
+        const resolved = mergeThemeTokens(
           mergeThemeTokens(DEFAULT_THEME_TOKENS, contributed),
           rawOverrides ?? {},
         );
+        try {
+          onPluginApplied?.({
+            id: activeName,
+            tokensCount: countTokenLeaves(contributed),
+            source: 'plugin',
+          });
+        } catch {
+          // Observation failures must not discard an already-resolved theme.
+        }
+        return resolved;
       }
     } catch (err: unknown) {
       const message =
@@ -86,7 +104,18 @@ export function resolveActiveTheme(opts: ResolveActiveThemeOptions): ThemeTokens
   return resolveThemeTokens(raw);
 }
 
-function extractActiveName(raw: unknown): string | null {
+function countTokenLeaves(value: unknown, isRoot = true): number {
+  if (value === null || value === undefined) return 0;
+  if (typeof value !== 'object') return 1;
+  if (Array.isArray(value)) {
+    return value.reduce((count, item) => count + countTokenLeaves(item, false), 0);
+  }
+  return Object.entries(value as Record<string, unknown>)
+    .filter(([key]) => !isRoot || key !== 'name')
+    .reduce((count, [, item]) => count + countTokenLeaves(item, false), 0);
+}
+
+export function getActiveThemeName(raw: unknown): string | null {
   if (typeof raw === 'string') return raw.trim() || null;
   if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
     const active = (raw as Record<string, unknown>).active;

package/src/domains/schedule-registry.ts

@@ -381,9 +381,17 @@ 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 Map((db.prepare(`SELECT id, name, command, source, run_via FROM schedule_registry`).all() as Array<{
+  const nowMs = Date.parse(now);
+  const existing = new Map((db.prepare(`SELECT id, name, command, source, run_via, cron, category, enabled, disabled_reason, last_seen, raw FROM schedule_registry`).all() as Array<{
     id: string; name: string; command: string | null; source: string; run_via: string;
+    cron: string | null; category: string; enabled: number;
+    disabled_reason: string | null; last_seen: string | null; raw: string | null;
   }>).map(r => [r.id, r]));
+  const lastSeenDue = (lastSeen: string | null): boolean => {
+    if (!lastSeen) return true;
+    const lastSeenMs = Date.parse(lastSeen);
+    return !Number.isFinite(lastSeenMs) || !Number.isFinite(nowMs) || nowMs - lastSeenMs >= 10 * 60_000;
+  };
   let total = 0, added = 0, disabled = 0, vanished = 0;
   const seenIds = new Set<string>();
   for (const line of text.split('\n')) {
@@ -398,8 +406,10 @@ 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.get(offId)?.source !== 'crontab' || existing.get(offId)?.run_via === 'trigger') continue;
+      const prior = existing.get(offId);
+      if (prior?.source !== 'crontab' || prior.run_via === 'trigger') continue;
       seenIds.add(offId);
+      if (prior.enabled === 0 && prior.disabled_reason === 'manual' && !lastSeenDue(prior.last_seen)) continue;
       db.run(`UPDATE schedule_registry SET enabled = 0, disabled_reason = 'manual', last_seen = ? WHERE id = ?`, [now, offId]);
       disabled++;
       continue;
@@ -417,6 +427,10 @@ export function inventoryCrontab(db: Database, opts: { crontab?: string; now?: s
     // trigger's state (including an explicit disable). Keep the migrated row intact.
     if (prior?.run_via === 'trigger') continue;
     if (!prior) added++;
+    const unchanged = prior?.source === 'crontab' && prior.name === name && prior.cron === parsed.cron
+      && prior.command === parsed.command && prior.category === category
+      && prior.enabled === 1 && prior.disabled_reason == null && prior.raw === line.trim();
+    if (unchanged && !lastSeenDue(prior.last_seen)) continue;
     db.run(
       `INSERT INTO schedule_registry (id, name, source, cron, command, category, domain, enabled, last_seen, managed_by, raw)
        VALUES (?, ?, 'crontab', ?, ?, ?, 'finance', 1, ?, 'manual', ?)

package/src/git-fs/idle-refresh.ts

@@ -0,0 +1,76 @@
+import { debug } from '../debug/log.js';
+
+/** Keep git status responsive while active, then back off after two idle minutes. */
+export function dashboardIdleMs(now: number, lastInputAt: number, streaming: boolean): number {
+  // A model turn is active work even when it produces no terminal input.
+  // Do not age the dashboard into idle cadence until that stream finishes.
+  return streaming ? 0 : Math.max(0, now - lastInputAt);
+}
+
+export function gitDirtyRefreshIntervalMs(idleMs: number): number {
+  return idleMs >= 2 * 60_000 ? 60_000 : 5_000;
+}
+
+// CLASSIC-IDLE-GIT-POLL (대표 10-21 «classic 백그라운드가 너무 무겁다») — a classic TUI left alone for five
+// minutes spawned 63 git children (dirty probe ⊕ snapshot keep-warm). After this many idle ms the poller
+// stops spawning git; the next input (or any activity that resets the idle clock) warms once and resumes.
+export const GIT_POLL_IDLE_PAUSE_MS = 2 * 60_000;
+
+export interface IdleGitPollState { active: boolean; reason: string }
+
+export interface IdleGitPollDeps {
+  /** Idle ms right now (`dashboardIdleMs` — a running stream counts as active). */
+  idleMs: () => number;
+  /** One regular pass while active: dirty probe ⊕ snapshot keep-warm. */
+  poll: (idleMs: number) => void;
+  /** The one warm when polling resumes after a pause. */
+  warm: () => void;
+  /** Run the warm off the input path (default: a 0ms timer — after the key has been handled and painted). */
+  defer?: (fn: () => void) => void;
+  /** Transition record (default: `debug.log('git-fs.idle', 'poll-state', …)`). */
+  log?: (state: IdleGitPollState) => void;
+  pauseAfterMs?: number;
+}
+
+export interface IdleGitPoll {
+  /** The periodic timer body: pauses once idle, resumes (with one warm) when activity is back. */
+  tick(): void;
+  /** Called on the input path. Costs one boolean check while active; when paused it only schedules the warm. */
+  noteActivity(reason?: string): void;
+  isActive(): boolean;
+}
+
+export function createIdleGitPoll(deps: IdleGitPollDeps): IdleGitPoll {
+  const pauseAfterMs = deps.pauseAfterMs ?? GIT_POLL_IDLE_PAUSE_MS;
+  const log = deps.log ?? ((state: IdleGitPollState) => debug.log('git-fs.idle', 'poll-state', state));
+  const defer = deps.defer ?? ((fn: () => void) => {
+    const timer = setTimeout(fn, 0);
+    (timer as unknown as { unref?: () => void }).unref?.();
+  });
+  let active = true;
+  const setActive = (next: boolean, reason: string): boolean => {
+    if (active === next) return false;
+    active = next;
+    try { log({ active, reason }); } catch { /* observation must not break polling */ }
+    return true;
+  };
+  const warm = (): void => { try { deps.warm(); } catch { /* fail-soft */ } };
+  return {
+    tick() {
+      const idleMs = deps.idleMs();
+      if (idleMs >= pauseAfterMs) {
+        setActive(false, 'idle');
+        return;
+      }
+      // Activity that did not come through `noteActivity` (a stream, an edit) — resume here.
+      if (setActive(true, 'activity')) warm();
+      deps.poll(idleMs);
+    },
+    noteActivity(reason = 'input') {
+      if (active) return;
+      setActive(true, reason);
+      defer(warm);
+    },
+    isActive: () => active,
+  };
+}

package/src/git-fs/index.ts

@@ -94,6 +94,8 @@ interface CacheEntry {
   dirty: DirtyCount | null;
   aheadBehind: AheadBehind | null;
   lastDirtyProbeAt: number;
+  /** Prevent an older asynchronous probe from replacing a synchronous refresh. */
+  dirtyVersion: number;
   watcher: GitFileWatcher;
   listeners: Set<() => void>;
 }
@@ -139,6 +141,7 @@ function ensureEntry(cwd: string): CacheEntry | null {
     dirty: null,
     aheadBehind: null,
     lastDirtyProbeAt: 0,
+    dirtyVersion: 0,
     watcher,
     listeners: new Set(),
   };
@@ -212,6 +215,8 @@ export function refreshDirty(
       lastDirtyProbeAt: entry.lastDirtyProbeAt,
     };
   }
+  // A synchronous save wins over any asynchronous probe that began before it.
+  entry.dirtyVersion += 1;
   entry.dirty = probeDirty(entry.located.root);
   entry.aheadBehind = probeAheadBehind(entry.located.root);
   entry.lastDirtyProbeAt = Date.now();
@@ -268,13 +273,19 @@ function probeDirtyAsyncFor(entry: CacheEntry, opts: { fresh: boolean }): Promis
   const running = dirtyInFlight.get(entry);
   if (running && !opts.fresh) return running;
   const root = entry.located.root;
-  const start = (): Promise<GitStatusView> => Promise.all([probeDirtyAsync(root), probeAheadBehindAsync(root)])
-    .then(([dirty, aheadBehind]) => {
-      entry.dirty = dirty;
-      entry.aheadBehind = aheadBehind;
-      entry.lastDirtyProbeAt = Date.now();
-      return viewOf(entry);
-    });
+  const start = (): Promise<GitStatusView> => {
+    const version = entry.dirtyVersion;
+    return Promise.all([probeDirtyAsync(root), probeAheadBehindAsync(root)])
+      .then(([dirty, aheadBehind]) => {
+        if (entry.dirtyVersion === version) {
+          entry.dirtyVersion += 1;
+          entry.dirty = dirty;
+          entry.aheadBehind = aheadBehind;
+          entry.lastDirtyProbeAt = Date.now();
+        }
+        return viewOf(entry);
+      });
+  };
   const probe = (running ? running.then(start, start) : start())
     .finally(() => { if (dirtyInFlight.get(entry) === probe) dirtyInFlight.delete(entry); });
   dirtyInFlight.set(entry, probe);

package/src/git-fs/worktree.ts

@@ -24,15 +24,51 @@ const GIT_TIMEOUT_MS = 30_000;
  *  ⛔ 깊이 없이 얕은 저장소로 다른 브랜치를 fetch 하면 그 브랜치의 «전 이력»을 받는다(실측 193s vs 4s · 30s 에 SIGTERM). */
 const SHALLOW_BASE_FETCH_DEPTH = 50;
 const WORKTREE_ADD_TIMEOUT_MS = 5 * 60_000;
+const WORKTREE_ADD_TIMEOUT_PER_TRACKED_FILE_MS = 600_000 / 25_000;
+const WORKTREE_ADD_TIMEOUT_MAX_MS = 15 * 60_000;
+const TRACKED_FILE_COUNT_MAX_BUFFER = 16 * 1024 * 1024;
 
 export interface WorktreeAddDeps {
   spawn?: (command: string, args: string[], options: { cwd: string; encoding: 'utf8'; timeout: number; maxBuffer: number }) => SpawnSyncReturns<string>;
+  countTrackedFiles?: (repoRoot: string, ref?: string) => number | null;
 }
 
-function worktreeAddTimeoutMs(): number {
+function countTrackedFiles(repoRoot: string, ref?: string): number | null {
+  const args = ref ? ['ls-tree', '-r', '-z', '--name-only', ref] : ['ls-files', '-z'];
+  const result = spawnSync('git', args, {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    timeout: GIT_TIMEOUT_MS,
+    maxBuffer: TRACKED_FILE_COUNT_MAX_BUFFER,
+  });
+  if (result.status !== 0 || result.error) return null;
+  const output = result.stdout ?? '';
+  if (output.length === 0) return 0;
+  let count = 0;
+  for (const character of output) if (character === '\0') count++;
+  return count;
+}
+
+type WorktreeAddTimeout = { ms: number; trackedFileCount: number | null; source: 'config' | 'tracked-files' | 'fallback' };
+
+function worktreeAddTimeoutForTrackedFileCount(trackedFileCount: number | null): WorktreeAddTimeout {
+  if (trackedFileCount === null || !Number.isSafeInteger(trackedFileCount) || trackedFileCount < 0) {
+    return { ms: WORKTREE_ADD_TIMEOUT_MS, trackedFileCount: null, source: 'fallback' };
+  }
+  const scaledMs = Math.ceil(trackedFileCount * WORKTREE_ADD_TIMEOUT_PER_TRACKED_FILE_MS);
+  return { ms: Math.min(WORKTREE_ADD_TIMEOUT_MAX_MS, Math.max(WORKTREE_ADD_TIMEOUT_MS, scaledMs)), trackedFileCount, source: 'tracked-files' };
+}
+
+export function worktreeAddTimeoutForRepo(
+  repoRoot: string,
+  countTrackedFilesForRepo: (repoRoot: string, ref?: string) => number | null = countTrackedFiles,
+  trackedFileRef?: string,
+): WorktreeAddTimeout {
   const seconds = getUserConfig().harness?.worktreeAddTimeoutSec;
-  return typeof seconds === 'number' && Number.isSafeInteger(seconds) && seconds > 0 && seconds <= 2_147_483
-    ? seconds * 1000 : WORKTREE_ADD_TIMEOUT_MS;
+  if (typeof seconds === 'number' && Number.isSafeInteger(seconds) && seconds > 0 && seconds <= 2_147_483) {
+    return { ms: seconds * 1000, trackedFileCount: null, source: 'config' };
+  }
+  return worktreeAddTimeoutForTrackedFileCount(countTrackedFilesForRepo(repoRoot, trackedFileRef));
 }
 
 function worktreeAddFailureLines(stderr: string): { lastProgress: string | null; details: string[] } {
@@ -729,7 +765,9 @@ export function createWorktree(opts: CreateWorktreeOpts, deps: WorktreeAddDeps =
   // ★ 병렬 안전 재시도(2026-07-21) — 동시 worktree add 가 git 락에서 경쟁하면 즉시 실패 → 락/일시적
   //   에러면 백오프 재시도(패자가 승자의 락 해제를 기다렸다 성공). non-transient 는 재시도 없이 throw.
   const MAX_ATTEMPTS = 6;
-  const addTimeoutMs = worktreeAddTimeoutMs();
+  const addTimeout = worktreeAddTimeoutForRepo(repoRoot, deps.countTrackedFiles ?? countTrackedFiles, baseCheckout);
+  const addTimeoutMs = addTimeout.ms;
+  debug.log('git-fs.worktree', 'add.start', { branch, timeoutMs: addTimeoutMs, trackedFileCount: addTimeout.trackedFileCount, timeoutSource: addTimeout.source });
   const addSpawn = deps.spawn ?? spawnSync;
   for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
     const res = addSpawn(

package/src/graph-kinds/registry.ts

@@ -20,13 +20,13 @@ export interface NodeKindEntry {
   run?: NodeKindRun;
 }
 
-export const HARNESS_CORE_KINDS = ['agent', 'gate', 'git', 'judge', 'observe', 'hitl', 'subgraph', 'prompt'] as const;
+export const HARNESS_CORE_KINDS = ['agent', 'gate', 'git', 'judge', 'observe', 'hitl', 'subgraph', 'prompt', 'classify'] as const;
 
 // Workflow validation, the palette, and executor variant labels read the same keys.
 export const WORKFLOW_CORE_KINDS = ['prompt', 'bash', 'skill', 'cft', 'approval', 'if', 'switch', 'iteration', 'classify', 'extract', 'set', 'filter', 'template', 'http', 'showroom', 'task', 'scheduleTrigger', 'webhookTrigger', 'discordTrigger', 'telegramTrigger', 'manualTrigger', 'chatTrigger', 'subworkflow', 'knowledge'] as const;
 
 const descriptions: Record<GraphKind, readonly string[]> = {
-  harness: ['Run an agent', 'Check an execution gate', 'Perform git operations', 'Judge an outcome', 'Observe a result', 'Request human input', 'Run a child graph', 'Run an LLM prompt'],
+  harness: ['Run an agent', 'Check an execution gate', 'Perform git operations', 'Judge an outcome', 'Observe a result', 'Request human input', 'Run a child graph', 'Run an LLM prompt', 'Classify input'],
   workflow: ['Run an LLM prompt', 'Run a shell command', 'Invoke a skill', 'Invoke a CFT method', 'Request approval', 'Branch on a condition', 'Select a case', 'Iterate items', 'Classify input', 'Extract structured data', 'Assign variables', 'Filter items', 'Render a template', 'Make an HTTP request', 'Run a showroom', 'Create a task', 'Start on a schedule', 'Start on a webhook', 'Start on Discord', 'Start on Telegram', 'Start manually', 'Start on chat', 'Call another workflow', 'Search the vault for context'],
 };
 

package/src/graph-runner/runner.ts

@@ -1,7 +1,8 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { execFile, spawnSync } from 'node:child_process';
-import { existsSync, linkSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, linkSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve, sep } from 'node:path';
+import { tmpdir } from 'node:os';
 import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
 import { getElanousConfigDir, getElanousConfigDirOverride } from '../elanous-config-dir.js';
 import { debug } from '../debug/log.js';
@@ -23,8 +24,9 @@ export { UnitNotFoundError } from '../self-implement/graph-unit-resolver.js';
 import { createGraphVariant, type GraphVariantPlan } from '../self-implement/graph-variant.js';
 import { psProcessStartMs, START_TOLERANCE_MS } from '../harness/harness-stop.js';
 import { executeBashNode } from '../workflow-runtime/nodes/bash.js';
+import { executeClassifyNode } from '../workflow-runtime/nodes/classify.js';
 import { interpolate } from '../workflow-runtime/variables.js';
-import type { BashNode, NodeExecContext, WorkflowDeps } from '../workflow-runtime/types.js';
+import type { BashNode, ClassifyNode, NodeExecContext, NodeOutput, WorkflowDeps } from '../workflow-runtime/types.js';
 import { releaseResumeAcceptedRegressions, releaseResumeGateExecutor, releaseResumeGatePodPool, releaseResumeWaiver, type AcceptedRegression, type GateExecutorOverride, type GatePodPoolOverride } from '../../scripts/release-loop/resume.js';
 
 type BashRun = WorkflowDeps['runBash'];
@@ -83,6 +85,47 @@ function topLevelTerminalStatus(graphId: string, terminal: string): 'done' | 'fa
   return terminal === 'done' || terminal === 'failed' ? terminal : undefined;
 }
 
+/** HARNESS-FULL-GRAPH-LOOPS — the four goal loops are self-implement harness templates: their recipes are
+ *  catalog roles (no `recipes.yaml` sidecar) and some edges branch on `changed-files`. `graph run` can only
+ *  *plan* them: `--dry-run` walks the declared success route; a real run is refused (the harness owns effects). */
+const HARNESS_LOOP_GRAPH_IDS: ReadonlySet<string> = new Set(['default-loop', 'document-loop', 'operate-loop', 'research-loop']);
+
+type PlannedStep = { outcome?: string; to: string };
+
+/** Shortest declared route (map/to edges only — fallbacks are not a success branch) to a terminal that maps to `done`.
+ *  Ties keep the first declared outcome, so the plan follows the YAML's own order. A unit call only takes its first
+ *  declared exit (the same stand-in a plain dry run uses) — its `rework` exit is a shortcut, not the success path. */
+function planHarnessLoopRoute(graph: GraphTemplateSpec, unitSuccessExit: (nodeId: string) => string | undefined): Map<string, PlannedStep> {
+  const candidates = new Map<string, PlannedStep[]>();
+  for (const node of graph.nodes) {
+    const edge = graph.edges.find((e) => e.from === node.nodeId);
+    if (!edge) continue;
+    const exit = unitSuccessExit(node.nodeId);
+    candidates.set(node.nodeId, edge.to !== undefined ? [{ to: edge.to }]
+      : Object.entries(edge.map ?? {}).filter(([outcome]) => exit === undefined || outcome === exit).map(([outcome, to]) => ({ outcome, to })));
+  }
+  const distance = new Map<string, number>();
+  for (const terminal of graph.terminalNodes) if (topLevelTerminalStatus(graph.graphId, terminal) === 'done') distance.set(terminal, 0);
+  const route = new Map<string, PlannedStep>();
+  for (let changed = true; changed;) {
+    changed = false;
+    for (const [nodeId, steps] of candidates) {
+      if (graph.terminalNodes.includes(nodeId)) continue;
+      let best: { step: PlannedStep; d: number } | undefined;
+      for (const step of steps) {
+        const d = distance.get(step.to);
+        if (d !== undefined && (!best || d + 1 < best.d)) best = { step, d: d + 1 };
+      }
+      if (best && (distance.get(nodeId) ?? Infinity) > best.d) {
+        distance.set(nodeId, best.d);
+        route.set(nodeId, best.step);
+        changed = true;
+      }
+    }
+  }
+  return route;
+}
+
 export interface GraphRunState {
   graphId: string;
   runId: string;
@@ -125,6 +168,46 @@ export interface GraphRunState {
   statePath: string;
 }
 
+export interface GraphClassifyInput {
+  arguments: string;
+  classify: ClassifyNode['classify'];
+  /** Production consumer that asked for the verdict, so one ledger shape separates callers. */
+  caller?: string;
+}
+
+/** Run the workflow classifier as a persisted harness graph node. The workflow verdict is unchanged. */
+export async function runGraphClassifyNode(node: ClassifyNode, ctx: NodeExecContext, callLLM: WorkflowDeps['callLLM'],
+  meta: { caller?: string } = {}): Promise<NodeOutput> {
+  const dir = mkdtempSync(join(tmpdir(), 'elanous-graph-classify-'));
+  try {
+    const path = join(dir, 'graph.yaml');
+    writeFileSync(join(dir, 'recipes.yaml'), '{}\n');
+    writeFileSync(path, stringifyYaml({
+      graph_id: 'self-implement-classify', version: 1, entry_node: 'classify', terminal_nodes: ['done', 'failed'],
+      nodes: [
+        { node_id: 'classify', kind: 'classify', recipe: 'none', max_visits: 1 },
+        { node_id: 'done', kind: 'gate', recipe: 'none', max_visits: 1 },
+        { node_id: 'failed', kind: 'gate', recipe: 'none', max_visits: 1 },
+      ],
+      edges: [{ from: 'classify', on: 'outcome', map: { ok: 'done', fail: 'failed' } }],
+    }));
+    const run = await runGraph(path, { input: { arguments: ctx.arguments, classify: node.classify,
+      ...(meta.caller === undefined ? {} : { caller: meta.caller }) } satisfies GraphClassifyInput,
+      quiet: true,
+      deps: { callLLM: async (prompt) => callLLM({ prompt, ...(ctx.resolvedModel === undefined ? {} : { model: ctx.resolvedModel }),
+        ...(ctx.resolvedProvider === undefined ? {} : { provider: ctx.resolvedProvider }),
+        ...(ctx.signal === undefined ? {} : { signal: ctx.signal }) }) } });
+    const recorded = lastJsonObject(run.nodes[0]?.output);
+    if (!recorded || typeof recorded.durationMs !== 'number' || typeof recorded.ok !== 'boolean' || !('output' in recorded)) {
+      throw new Error(`classify graph did not record a result: ${run.statePath}`);
+    }
+    return { ok: recorded.ok, output: recorded.output, durationMs: recorded.durationMs,
+      ...(typeof recorded.error === 'string' ? { error: recorded.error } : {}) };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
 export interface GraphRunOptions {
   input?: unknown;
   /** Bytes already checked by the tick gate, used for a current-graph start or legacy resume. */
@@ -135,6 +218,8 @@ export interface GraphRunOptions {
   resumeRunId?: string;
   resumeGraphId?: string;
   fromNodeId?: string;
+  /** Embedded runs (a classify verdict inside self-implement) keep the per-node `[graph]` stderr lines off the caller's terminal; debug.log still records every node. */
+  quiet?: boolean;
   /** Release-only: accept the recorded failed node without executing it, and expose its regression to known-issues. */
   releaseWaiver?: { nodeId: string; reason: string; requestedRegressions: AcceptedRegression[]; acceptedRegressions: AcceptedRegression[]; unmeasured?: string };
   /** Release-only: add accepted issues independently of a waiver at a restart boundary. */
@@ -614,7 +699,15 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       throw new Error(`unsupported terminal node: ${terminal} (expected ${graph.unit ? graph.unit.exits.join(' or ') : 'done or failed'})`);
     }
   }
-  const recipeSource = readFileSync(graphMode === 'snapshot' ? join(snapshotDir!, 'recipes.yaml') : join(dirname(path), 'recipes.yaml'), 'utf8');
+  const recipePath = graphMode === 'snapshot' ? join(snapshotDir!, 'recipes.yaml') : join(dirname(path), 'recipes.yaml');
+  // A harness loop template without a command sidecar is planned, never executed, by this runner.
+  const harnessLoopTemplate = !graph.unit && HARNESS_LOOP_GRAPH_IDS.has(graph.graphId) && graphMode === 'current' && !existsSync(recipePath);
+  if (harnessLoopTemplate && (options.dryRun !== true || options.resumeRunId)) {
+    debug.log('graph.run', 'harness-loop-refused', { graphId: graph.graphId, path: resolve(path), why: 'real-run' });
+    throw new Error(`harness loop template ${graph.graphId} runs through the self-implement harness — graph run only plans it with --dry-run`);
+  }
+  const harnessLoopRoute = harnessLoopTemplate ? planHarnessLoopRoute(graph, (nodeId) => units.get(nodeId)?.template.unit?.exits[0]) : undefined;
+  const recipeSource = harnessLoopTemplate ? '{}\n' : readFileSync(recipePath, 'utf8');
   if (graphMode === 'snapshot' && saved?.graphSnapshot &&
     (createHash('sha256').update(source).digest('hex') !== saved.graphSnapshot.graphSha ||
       createHash('sha256').update(recipeSource).digest('hex') !== saved.graphSnapshot.recipesSha)) {
@@ -626,10 +719,20 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
   const approvalSourceHash = createHash('sha256').update(variantSource).update('\0').update(recipeSource).digest('hex');
   // Resolve all commands before executing any node; an unknown recipe must never produce a partial publication.
   for (const node of graph.nodes) {
+    if (node.kind === 'classify' && node.recipe !== 'none') throw new Error(`classify node cannot execute a recipe: ${node.nodeId}`);
     if (node.recipe === 'none') continue;
     const resolved = resolveNodeRecipe(node, recipes, catalogRoles);
+    // Harness loop recipes are labels the self-implement harness dispatches by node id (most are outside the
+    // node catalog — graph-catalog.test.ts); a planned loop never executes them, and a real run is refused above.
+    if (harnessLoopRoute) continue;
     if (!resolved.command && !resolved.prompt && !resolved.approval) throw new Error(`unknown command recipe for ${node.nodeId}: ${node.recipe}`);
   }
+  if (harnessLoopRoute) {
+    if (!harnessLoopRoute.has(graph.entryNode)) throw new Error(`harness loop ${graph.graphId} has no declared route from ${graph.entryNode} to a success terminal`);
+    const planned: string[] = [graph.entryNode];
+    for (let at = harnessLoopRoute.get(graph.entryNode); at; at = harnessLoopRoute.get(at.to)) planned.push(at.to);
+    debug.log('graph.run', 'harness-loop-plan', { graphId: graph.graphId, path: resolve(path), route: planned });
+  }
   const graphId = safeSegment(graph.graphId);
   const isReleaseLoop = graphId === 'release-loop';
   // A copied or saved release graph is still a release graph. Its path cannot grant or revoke
@@ -951,7 +1054,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     const startedAt = performance.now();
     const nodeStartedAt = new Date().toISOString();
     if (!resumingCompleted) state.currentNode = { nodeId: current, startedAt: nodeStartedAt };
-    console.error(`[graph] ${current} start (0.00s)`);
+    if (!options.quiet) console.error(`[graph] ${current} start (0.00s)`);
     debug.log('graph.run', 'node', { graphId, runId, nodeId: current, phase: 'start', dryRun: state.dryRun });
     publishInsideEvent({ kind: 'node', graphId, runId, nodeId: current, phase: 'start' });
     log('node-start', { graphId, runId, nodeId: current, visit: visits.get(current), dryRun: state.dryRun });
@@ -1030,7 +1133,12 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       state.executed++;
     }
     let unitExecuted = false;
-    if (units.has(current) && !waiving && state.dryRun && !resumingCompleted) {
+    const plannedStep: PlannedStep | undefined = harnessLoopRoute?.get(current);
+    if (harnessLoopRoute && !graph.terminalNodes.includes(current)) {
+      if (!plannedStep) throw new Error(`harness loop ${graphId} has no declared success route from ${current}`);
+      // The planned outcome stands in for the harness node (or unit) that a real loop run would execute.
+      output = JSON.stringify({ outcome: plannedStep.outcome ?? 'ok', dryRun: true, plannedNext: plannedStep.to });
+    } else if (units.has(current) && !waiving && state.dryRun && !resumingCompleted) {
       // Dry run plans the walk only: no child run, no unit event, no unitCalls entry; the first declared exit stands in.
       output = JSON.stringify({ outcome: units.get(current)!.template.unit!.exits[0], dryRun: true });
     } else if (units.has(current) && !waiving && !resumingCompleted) {
@@ -1132,6 +1240,39 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       }
       state.executed++;
     }
+    if (node.kind === 'classify' && !waiving && !state.dryRun && !resumingCompleted) {
+      const input = state.input as GraphClassifyInput | undefined;
+      const classify = input?.classify;
+      if (!input || typeof input.arguments !== 'string' || !classify || typeof classify.input !== 'string' ||
+          !Array.isArray(classify.classes) || !classify.classes.length || !classify.classes.every(c => typeof c === 'string' && c.length > 0) ||
+          (classify.retries !== undefined && (!Number.isSafeInteger(classify.retries) || classify.retries < 0)) ||
+          (classify.retryDelayMs !== undefined && (!Number.isSafeInteger(classify.retryDelayMs) || classify.retryDelayMs < 0))) {
+        throw new Error('classify node requires input.arguments and a valid input.classify');
+      }
+      try {
+        const result = await executeClassifyNode({ id: current, classify }, {
+          arguments: input.arguments, artifactsDir: dirname(statePath), outputs: {},
+          resolvedProvider: undefined, resolvedModel: undefined, toolPolicy: {},
+        }, { callLLM: async ({ prompt }) => {
+          if (!options.deps?.callLLM) throw new Error('classify node requires an injected LLM (deps.callLLM)');
+          return options.deps.callLLM(prompt);
+        }, runBash: async () => ({ stdout: '', stderr: '', exitCode: 0 }) });
+        output = JSON.stringify({ input: input.arguments, ok: result.ok, verdict: result.output, output: result.output,
+          durationMs: result.durationMs, ...(result.error ? { error: result.error } : {}) });
+        ok = result.ok;
+        error = result.error;
+      } catch (cause) {
+        ok = false;
+        error = cause instanceof Error ? cause.message : String(cause);
+        output = JSON.stringify({ input: input.arguments, ok, verdict: 'unknown', output: 'unknown', durationMs: 0, error });
+      }
+      const recorded = lastJsonObject(output);
+      debug.log('graph.classify', 'node-result', { graphId, runId, nodeId: current, caller: input.caller ?? null,
+        input: input.arguments, inputChars: input.arguments.length, classes: classify.classes,
+        verdict: recorded?.verdict ?? 'unknown', output: recorded?.output ?? 'unknown', ok,
+        ...(error ? { error } : {}) });
+      state.executed++;
+    }
     const seconds = Number(((performance.now() - startedAt) / 1000).toFixed(2));
     // A wall clock stepped back mid-node must not record an end before the start.
     const nodeEndedAt = new Date(Math.max(Date.now(), Date.parse(nodeStartedAt))).toISOString();
@@ -1152,7 +1293,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         output = JSON.stringify({ outcome: ok ? 'approved' : 'rejected', graphId, runId, nodeId: current,
           ...(state.pending?.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending?.decidedAt ?? null });
       }
-      state.nodes.push({ nodeId: current, ok, exit, executed: !waiving && ((!!command && (!state.dryRun || !!command.dry_run_command)) || (!!prompt && !state.dryRun) || unitExecuted), ...((waiving || units.has(current) || ((command || prompt || approval) && (!state.dryRun || !!command?.dry_run_command))) && output !== undefined ? { output } : {}), ...(error ? { error } : {}),
+      state.nodes.push({ nodeId: current, ok, exit, executed: !waiving && ((!!command && (!state.dryRun || !!command.dry_run_command)) || (!!prompt && !state.dryRun) || (node.kind === 'classify' && !state.dryRun) || unitExecuted), ...((waiving || harnessLoopRoute || units.has(current) || ((command || prompt || approval || node.kind === 'classify') && (!state.dryRun || !!command?.dry_run_command))) && output !== undefined ? { output } : {}), ...(error ? { error } : {}),
         ...(waiving ? { waiver: { reason: options.releaseWaiver!.reason, at: nodeEndedAt, ...(options.releaseWaiver!.unmeasured === undefined ? {} : { unmeasured: options.releaseWaiver!.unmeasured }), original: { exit: waivedRecord!.exit, ...(waivedRecord!.output === undefined ? {} : { output: waivedRecord!.output }), ...(waivedRecord!.error === undefined ? {} : { error: waivedRecord!.error }) } } } : {}),
         ...(approval && state.pending ? { ...(state.pending.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending.decidedAt } : {}),
         startedAt: nodeStartedAt, endedAt: nodeEndedAt, seconds });
@@ -1165,9 +1306,9 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       delete state.pending;
       delete state.approvalSourceHash;
     }
-    const reported = waiving || units.has(current) || (prompt && !state.dryRun) || (command && (!state.dryRun || command.dry_run_command)) ? lastJsonObject(resumingCompleted ? completed?.output : output)?.outcome : undefined;
-    const namedOutcome = typeof reported === 'string' ? reported : undefined;
-    console.error(`[graph] ${current} ${ok ? 'ok' : 'fail'} (${seconds.toFixed(2)}s)`);
+    const reported: unknown = waiving || harnessLoopRoute || units.has(current) || (prompt && !state.dryRun) || (command && (!state.dryRun || command.dry_run_command)) ? lastJsonObject(resumingCompleted ? completed?.output : output)?.outcome : undefined;
+    const namedOutcome: string | undefined = typeof reported === 'string' ? reported : undefined;
+    if (!options.quiet) console.error(`[graph] ${current} ${ok ? 'ok' : 'fail'} (${seconds.toFixed(2)}s)`);
     debug.log('graph.run', 'node', { graphId, runId, nodeId: current, phase: ok ? 'ok' : 'fail', seconds, exit });
     publishInsideEvent({ kind: 'node', graphId, runId, nodeId: current, phase: ok ? 'ok' : 'fail', seconds });
     publishInsideEvent({ kind: 'verdict', graphId, runId, nodeId: current, verdict: ok ? 'ok' : 'fail', ...(namedOutcome === undefined ? {} : { outcome: namedOutcome }) });
@@ -1225,7 +1366,9 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       }
       persist();
     }
-    current = nextNode(graph.edges, current, state.dryRun && !command?.dry_run_command ? 'ok' : ok ? 'ok' : 'fail', namedOutcome);
+    // A planned harness loop follows its route directly: `changed-files` edges have no runner condition.
+    current = plannedStep ? plannedStep.to
+      : nextNode(graph.edges, current, state.dryRun && !command?.dry_run_command ? 'ok' : ok ? 'ok' : 'fail', namedOutcome);
     resumedGrowth = false;
     if (current !== undefined) publishInsideEvent({ kind: 'edge', graphId, runId, from: fromNodeId, to: current });
     if (current === undefined) {

package/src/grok/credential.ts

@@ -87,6 +87,8 @@ export interface GrokCredential {
   baseUrl: string;
   /** Bearer 값. ⛔ 로그·관측에 실지 마라. */
   token: string;
+  /** Expiry for the selected subscription scope; absent for API-key credentials. */
+  expiresAt?: string | null;
   /** 이 자격에 «반드시» 붙어야 하는 헤더(Authorization 제외). */
   headers: Record<string, string>;
   /** 관측용 — 값이 아니라 «출처»만. */
@@ -120,8 +122,10 @@ function readSubscriptionToken(
   }
   if (!parsed || typeof parsed !== 'object') return null;
 
-  let best: { token: string; expiresAt: string | null; userId: string | null; ms: number } | null = null;
-  for (const scope of Object.values(parsed as Record<string, unknown>)) {
+  type SubscriptionToken = { token: string; expiresAt: string | null; userId: string | null; ms: number };
+  let best: SubscriptionToken | null = null;
+  let hqMirror: SubscriptionToken | null = null;
+  for (const [scopeName, scope] of Object.entries(parsed as Record<string, unknown>)) {
     if (!scope || typeof scope !== 'object') continue;
     const s = scope as GrokAuthScope;
     if (typeof s.key !== 'string' || s.key.length === 0) continue;
@@ -133,9 +137,11 @@ function readSubscriptionToken(
       userId: typeof s.user_id === 'string' ? s.user_id : null,
       ms: Number.isNaN(ms) ? Number.NEGATIVE_INFINITY : ms,
     };
+    if (scopeName === 'https://auth.x.ai::hq-mirror') hqMirror = cand;
     if (best === null || cand.ms > best.ms) best = cand;
   }
-  return best ? { token: best.token, expiresAt: best.expiresAt, userId: best.userId } : null;
+  const selected = hqMirror ?? best;
+  return selected ? { token: selected.token, expiresAt: selected.expiresAt, userId: selected.userId } : null;
 }
 
 /** 호스트 발급 문이 응답에 실을 access. user id 는 반환하지 않는다. */
@@ -302,6 +308,7 @@ function readGrokCredential(opts: {
         kind: 'subscription',
         baseUrl: GROK_SUBSCRIPTION_BASE_URL,
         token: sub.token,
+        expiresAt: sub.expiresAt,
         headers: grokSubscriptionHeaders({
           ...(opts.model ? { model: opts.model } : {}),
           userId: sub.userId,