elanous 0.2.34 → 0.2.36

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/domains/standalone-log-sink.ts

@@ -10,20 +10,33 @@
 /**
  * 독립 프로세스에서 logs.db 싱크를 등록한다. 반환된 off 는 process 'exit' 에 자동 배선된다.
  * @param surface  이 프로세스가 남기는 로그의 surface 라벨(예: 'scheduler'·'autopilot').
+ * @param opts.wrapSink  logs.db 싱크를 감싼다(예: TUI 는 pid·`--name`·세션을 data 에 찍는다 — debug/tui-log-tag.ts).
  */
-export async function registerStandaloneLogSink(surface: string): Promise<boolean> {
+export async function registerStandaloneLogSink(
+  surface: string,
+  opts: { wrapSink?: (sink: import('../mss/logging/sink.js').LogSink) => import('../mss/logging/sink.js').LogSink } = {},
+): Promise<boolean> {
   try {
     const [storeMod, dbgMod, cfgMod] = await Promise.all([
       import('../mss/logging/log-store.js'),
       import('../debug/log.js'),
       import('../user-config.js'),
     ]);
+    // TUI-LOG-SESSION-TAG — 한 logs.db 를 여러 TUI(클래식·next)가 쓴다: 행마다 pid·`--name`·소유 세션을 data 에 찍는다.
+    if (surface === 'tui' && !opts.wrapSink) {
+      const tagMod = await import('../debug/tui-log-tag.js');
+      const tag = tagMod.processTuiLogTag();
+      opts = { ...opts, wrapSink: (s) => tagMod.withTuiLogTag(s, tag) };
+    }
     const logsCfg = cfgMod.getUserConfig().logs;
     storeMod.setLogInstanceName(logsCfg.instanceName);
+    // TUI-TYPING-LAG — TUI 는 워커 로그 폭주를 덩어리로 나눠 넣는다(키가 drain 전체를 기다리지 않게).
+    const drainChunkSize = storeMod.logStoreDrainChunkForSurface(surface);
     const offStore = storeMod.registerLogStoreSink(
-      (s) => dbgMod.debug.registerSink(s),
+      (s) => dbgMod.debug.registerSink(opts.wrapSink ? opts.wrapSink(s) : s),
       surface,
       logsCfg.retention,
+      drainChunkSize !== undefined ? { drainChunkSize } : {},
     );
     if (!offStore) return false;
     process.on('exit', offStore);

package/src/esc-abort-gate.ts

@@ -145,6 +145,75 @@ export function createHarnessEscHint(pushLine: (line: string) => void): (targets
   };
 }
 
+export interface EscAbortPendingSoftStopRunnerDeps {
+  getActiveHarnessSpace: () => string | null;
+  pushChatLine: (line: string) => void;
+  showHarnessEscHint: (targets: readonly string[]) => boolean;
+}
+
+export interface EscAbortPendingSoftStopOutcomeLike {
+  outcome: 'stopped' | 'failed' | 'hint' | 'waiting';
+  stoppedHarnessSpace: string | null;
+}
+
+export interface EscAbortPendingGateDeps {
+  /**
+   * Production soft-stop runner (`runEscAbortPendingSoftStop` in
+   * src/dashboard/index.ts): enqueues the durable soft-stop marker,
+   * verifies it, and paints the stopped/failure line. Injected (not
+   * imported) to keep this module free of a dashboard import cycle.
+   */
+  runSoftStop: (targets: readonly string[], deps: EscAbortPendingSoftStopRunnerDeps) => EscAbortPendingSoftStopOutcomeLike;
+  formatWaitingTargets: (targets: readonly string[]) => string;
+  getActiveHarnessSpace: () => string | null;
+  pushChatLine: (line: string) => void;
+  showHarnessEscHint: (targets: readonly string[]) => boolean;
+  /** Dashboard paint hook (chatScrollOffset reset) after each callback. */
+  afterAbortEvent?: () => void;
+}
+
+export interface EscAbortPendingGate {
+  onAbortPending(event: { running: number; repeat: number; targets: readonly string[] }): void;
+  onAbortRepeat(event: { running: number; repeat: number; targets: readonly string[]; phase: 'confirming' | 'pending' }): void;
+  getStoppedHarnessSpace(): string | null;
+}
+
+/**
+ * ⭐ TUI-ESC-EXIT production seam — the onAbortPending/onAbortRepeat
+ * callback pair that `attachChatStreamingKeys` wires into
+ * `createEscAbortGate`. Extracted from the dashboard inline closure so the
+ * incident test exercises the same function the dashboard executes.
+ *
+ * ⛔ Preservation rule: `stoppedHarnessSpace` only advances on a successful
+ * soft stop (a real stopped space). Later waiting/hint/failed callbacks must
+ * NOT clear a previously successful space — `onAbortRepeat` and the
+ * teardown `settleEscAbortPendingLines` decision depend on the retained value.
+ */
+export function createEscAbortPendingGate(deps: EscAbortPendingGateDeps): EscAbortPendingGate {
+  let stoppedHarnessSpace: string | null = null;
+  return {
+    onAbortPending({ targets }) {
+      const softStop = deps.runSoftStop(targets, {
+        getActiveHarnessSpace: deps.getActiveHarnessSpace,
+        pushChatLine: deps.pushChatLine,
+        showHarnessEscHint: deps.showHarnessEscHint,
+      });
+      if (softStop.stoppedHarnessSpace) stoppedHarnessSpace = softStop.stoppedHarnessSpace;
+      if (softStop.outcome === 'waiting') {
+        deps.pushChatLine(`  ⏳ 중단 요청됨 — ${deps.formatWaitingTargets(targets)} 종료를 기다리는 중입니다.`);
+      }
+      deps.afterAbortEvent?.();
+    },
+    onAbortRepeat({ repeat, targets }) {
+      if (!stoppedHarnessSpace && !deps.showHarnessEscHint(targets)) {
+        deps.pushChatLine(`  ⏳ ESC 재시도 ${repeat}회 — ${deps.formatWaitingTargets(targets)} 종료를 기다리는 중입니다.`);
+      }
+      deps.afterAbortEvent?.();
+    },
+    getStoppedHarnessSpace: () => stoppedHarnessSpace,
+  };
+}
+
 export function createEscAbortGate(deps: EscAbortGateDeps): EscAbortGate {
   let current: ApprovalModalHandle | null = null;
   let currentDispose: (() => void) | null = null;

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

@@ -10,7 +10,7 @@
 // because elanous's primary surface runs native git.
 
 import { spawnSync, execFileSync, type SpawnSyncReturns } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, writeFileSync, rmSync, symlinkSync, lstatSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, writeFileSync, rmSync, symlinkSync, lstatSync, unlinkSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, dirname, join, resolve } from 'node:path';
 import { findGitDir } from './locate.js';
@@ -18,21 +18,59 @@ import { isTransientGitError } from './retry.js';
 import { runGitCommand } from './runner.js';
 import { debug } from '../debug/log.js';
 import { getUserConfig } from '../user-config.js';
+import { GATE_DEPS_DIR, GATE_DEPS_TREES, projectDepsManifest } from '../task-orchestrator/surfaces/pod-gate-deps.js';
 
 const GIT_TIMEOUT_MS = 30_000;
 /** 얕은 클론(Pod `git clone --depth 50` · docker/harness/job.yaml)에서 base 를 가져올 깊이 — 클론과 같은 값.
  *  ⛔ 깊이 없이 얕은 저장소로 다른 브랜치를 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>;
+  installDependencies?: (cwd: string, timeoutMs: number) => { status: number | null; stderr?: string | null; error?: Error };
+  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[] } {
@@ -288,6 +326,81 @@ export function linkWorktreeDependencies(
   return result;
 }
 
+const WORKTREE_DEPENDENCY_INSTALL_TIMEOUT_MS = 600_000;
+
+/** A lockfile-bearing child must have dependencies before its tests start. */
+export class WorktreeDependencyPreparationError extends Error {
+  readonly code = 'WORKTREE_DEPENDENCIES_UNAVAILABLE';
+  constructor(readonly worktreePath: string, readonly dependencyPath: string, readonly reason: string) {
+    super(`worktree dependencies unavailable (${dependencyPath}) at ${worktreePath}: ${reason}`);
+    this.name = 'WorktreeDependencyPreparationError';
+  }
+}
+
+function bakedDependenciesMatch(repoTree: string, bakedTree: string): boolean {
+  try {
+    if (!existsSync(join(bakedTree, 'node_modules'))) return false;
+    if (!readFileSync(join(repoTree, 'bun.lock')).equals(readFileSync(join(bakedTree, 'bun.lock')))) return false;
+    const source = projectDepsManifest(JSON.parse(readFileSync(join(repoTree, 'package.json'), 'utf8')) as Record<string, unknown>);
+    const baked = projectDepsManifest(JSON.parse(readFileSync(join(bakedTree, 'package.json'), 'utf8')) as Record<string, unknown>);
+    return JSON.stringify(source) === JSON.stringify(baked);
+  } catch { return false; }
+}
+
+function prepareWorktreeDependencies(repoRoot: string, worktreePath: string, opts: CreateWorktreeOpts, deps: WorktreeAddDeps): void {
+  const fallbackRoot = opts.dependencyFallbackRoot?.trim() || GATE_DEPS_DIR;
+  const timeoutMs = opts.dependencyInstallTimeoutMs ?? WORKTREE_DEPENDENCY_INSTALL_TIMEOUT_MS;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) throw new Error('dependencyInstallTimeoutMs must be a positive integer');
+  for (const tree of GATE_DEPS_TREES) {
+    const targetTree = join(worktreePath, tree);
+    const relativePath = tree === '.' ? 'node_modules' : 'apps/pwa/node_modules';
+    const target = join(worktreePath, relativePath);
+    const source = join(repoRoot, relativePath);
+    const fallbackTree = join(fallbackRoot, tree);
+    const fallback = join(fallbackTree, 'node_modules');
+    const report = (installed: boolean, ok: boolean, error: string | null, method: string): void => {
+      debug.log('git-fs.worktree', 'dependencies.prepared', {
+        worktreePath, path: relativePath, source, fallback, installed, ok, error, method,
+      }, ok ? undefined : { level: 'warn' });
+    };
+    if (existsSync(target)) { report(false, true, null, existsSync(source) ? 'source' : 'existing'); continue; }
+    try { if (lstatSync(target).isSymbolicLink()) unlinkSync(target); } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    }
+    // Plain git repositories without a Bun lockfile have no dependency contract.
+    if (!existsSync(join(targetTree, 'package.json')) || !existsSync(join(targetTree, 'bun.lock'))) {
+      report(false, true, null, 'not-required');
+      continue;
+    }
+    if (bakedDependenciesMatch(targetTree, fallbackTree)) {
+      try {
+        mkdirSync(dirname(target), { recursive: true });
+        symlinkSync(fallback, target, 'dir');
+        report(false, true, null, 'fallback');
+        continue;
+      } catch (error) {
+        debug.log('git-fs.worktree', 'dependencies.fallback-failed', { worktreePath, path: relativePath, error: String(error) }, { level: 'warn' });
+      }
+    }
+    let result: { status: number | null; stderr?: string | null; error?: Error };
+    try {
+      result = deps.installDependencies
+        ? deps.installDependencies(targetTree, timeoutMs)
+        : spawnSync('bun', ['install', '--frozen-lockfile'], { cwd: targetTree, encoding: 'utf8', timeout: timeoutMs, maxBuffer: 16 * 1024 * 1024 });
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      report(true, false, reason, 'install');
+      throw new WorktreeDependencyPreparationError(worktreePath, relativePath, reason);
+    }
+    if (result.status === 0 && existsSync(target)) { report(true, true, null, 'install'); continue; }
+    const reason = (result.error as NodeJS.ErrnoException | undefined)?.code === 'ETIMEDOUT'
+      ? `install timed out after ${timeoutMs}ms`
+      : (result.stderr ?? result.error?.message ?? `install exited ${result.status}`).trim().slice(-4096) || `install exited ${result.status}`;
+    report(true, false, reason, 'install');
+    throw new WorktreeDependencyPreparationError(worktreePath, relativePath, reason);
+  }
+}
+
 export interface CreateWorktreeOpts {
   /** Absolute repo root (main checkout). */
   repoRoot: string;
@@ -325,6 +438,12 @@ export interface CreateWorktreeOpts {
    *  기록된 owner 와 **정확히 같을 때**만 더티를 재사용 거부 사유로 쓰지 않는다(그 dirt 는 그 런 자신의 산출).
    *  ⛔ 생략·공백이면 종전 동작: 더티는 `worktree-dirty` 로 거부한다. */
   currentOwner?: string;
+  /** Baked dependency root; defaults to the harness image tree. */
+  dependencyFallbackRoot?: string;
+  /** Pod child only: require dependencies before its tests. Other callers remain fail-soft. */
+  requireDependencies?: boolean;
+  /** Maximum install time for each missing dependency tree; default 600 seconds. */
+  dependencyInstallTimeoutMs?: number;
 }
 
 /** base 를 무엇으로 확정했는지 — **모름과 부재를 값으로 가른다.**
@@ -679,6 +798,7 @@ export function createWorktree(opts: CreateWorktreeOpts, deps: WorktreeAddDeps =
       debug.log('git-fs.worktree', 'add.branch-held-reused', { branch, worktreePath: branchHolder, owner: gate.owner }, { level: 'warn' });
       const reusedLinks = linkWorktreeDependencies(repoRoot, branchHolder);
       debug.log('git-fs.worktree', 'dependencies.linked', { branch, worktreePath: branchHolder, dependencyLinks: reusedLinks });
+      if (opts.requireDependencies) prepareWorktreeDependencies(repoRoot, branchHolder, opts, deps);
       const head = spawnSync('git', ['rev-parse', 'HEAD'], { cwd: branchHolder, encoding: 'utf8', timeout: GIT_TIMEOUT_MS });
       const headSha = (head.stdout ?? '').trim();
       if (head.status !== 0 || headSha.length === 0) {
@@ -729,7 +849,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(
@@ -771,6 +893,16 @@ export function createWorktree(opts: CreateWorktreeOpts, deps: WorktreeAddDeps =
   //   idempotent). fail-soft — 링크 실패해도 worktree 자체는 유효(caller 가 필요시 install).
   const dependencyLinks = linkWorktreeDependencies(repoRoot, wtPath);
   debug.log('git-fs.worktree', 'dependencies.linked', { branch, worktreePath: wtPath, dependencyLinks });
+  if (opts.requireDependencies) {
+    try { prepareWorktreeDependencies(repoRoot, wtPath, opts, deps); }
+    catch (error) {
+      try { removeWorktree(repoRoot, wtPath, true); }
+      catch (cleanupError) {
+        debug.log('git-fs.worktree', 'dependencies.cleanup-failed', { worktreePath: wtPath, error: String(cleanupError) }, { level: 'warn' });
+      }
+      throw error;
+    }
+  }
   const resolvedBase = spawnSync('git', ['rev-parse', 'HEAD'], {
     cwd: wtPath,
     encoding: 'utf8',

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/graph-cli.ts

@@ -28,6 +28,24 @@ function findGraphFile(graphId: string): string | undefined {
 
 export function registerGraphCommands(program: Command, runsDeps: { root?: string; processStartMs?: (pid: number) => number | null } = {}): void {
   const graph = program.command('graph').description('Run a declared command graph or inspect its latest run');
+  graph.command('wizard-run <request>')
+    .description('Run one request through the smart wizard graph and stop at its approval gate')
+    .option('--json', 'Print run identity and transitions as JSON')
+    .action(async (request: string, opts: { json?: boolean }) => {
+      try {
+        await (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('graph');
+        const { runWizardRequest } = await import('../smart-wizard/run.js');
+        const result = await runWizardRequest(request);
+        const summary = { graphId: result.state.graphId, runId: result.runId, status: result.status,
+          path: result.path, transitions: result.transitions };
+        if (opts.json) await writeStdoutJson(JSON.stringify(summary) + '\n');
+        else console.log(`${summary.graphId} ${summary.runId}: ${summary.status} (${summary.path.join(' → ')})`);
+        if (result.status !== 'awaiting-approval' && result.status !== 'done') process.exitCode = 1;
+      } catch (error) {
+        console.error(`graph wizard-run: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+      }
+    });
   graph.command('run <file>')
     .option('--dry-run', 'Walk the success path without executing commands')
     .option('--json', 'Print run state as JSON')