elanous 0.2.32 → 0.2.35

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/retry.ts

@@ -4,6 +4,7 @@ const MAX_GIT_RETRY_ATTEMPTS = 6;
 export type GitRunResult = {
   status: number | null;
   signal?: NodeJS.Signals | null;
+  errorCode?: string;
   stdout: string;
   stderr: string;
 };
@@ -43,6 +44,9 @@ export function runGitWithRetry(
       if (attempt > 1) onRetrySuccess?.(attempt);
       return result;
     }
+    // A killed or timed-out process did not report a Git failure. Its partial
+    // output may mention a lock, but repeating the checkout hides its cause.
+    if (result.status === null) return result;
     const error = result.stderr || result.stdout || '';
     if (!isTransientGitError(error) || attempt === MAX_GIT_RETRY_ATTEMPTS) return result;
     sleepSyncMs(80 * attempt);

package/src/git-fs/runner.ts

@@ -27,9 +27,11 @@ export function runGitCommand(
   const run = runner ?? ((gitArgs: string[]): GitRunResult => {
     if (testRunner) return testRunner(cwd, gitArgs, options);
     const result = spawnSync('git', gitArgs, { ...options, cwd });
+    const errorCode = (result.error as NodeJS.ErrnoException | undefined)?.code;
     return {
       status: result.status,
       ...(result.signal ? { signal: result.signal } : {}),
+      ...(errorCode ? { errorCode } : {}),
       stdout: outputText(result.stdout),
       stderr: outputText(result.stderr),
     };

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'],
 };