elanous 0.2.17 → 0.2.19

package/src/domains/schedule-registry.ts

@@ -18,6 +18,9 @@ import { dirname, join } from 'node:path';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { prevScheduledFire } from './cron-match.js';
 import { debug } from '../debug/log.js';
+import { listSources } from '../intake-plane/intake-sources.js';
+import { getUserConfig } from '../user-config.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { deriveScheduleName, ensureScheduleRunsSchema, recordScheduleRun } from './schedule-runs.js';
 
 /** 스케줄 레지스트리 DB 정본 경로 — state-dir 존중(lazy · Phase B). prod(ELANOUS_STATE_DIR
@@ -490,6 +493,9 @@ export interface InventoryInternalOpts {
   discoveryIntervalMs?: number;
   /** 테스트 seam — workflow-runtime schedule 트리거 주입(미지정 시 discoverWorkflows). */
   workflowSchedules?: Array<{ workflowName: string; nodeId: string; cron?: string | null; intervalMs?: number | null }>;
+  /** Test seams for the installed instance; production reads the active config and instance root. */
+  watchRoot?: string;
+  watchEnabled?: boolean;
 }
 
 /** 데몬 내부 스케줄을 레지스트리에 upsert(멱등·고정 id). 등록 수 반환. */
@@ -513,6 +519,23 @@ export function inventoryInternalSchedules(db: Database, opts: InventoryInternal
   // 회고(retro loop = retro-aggregate/report/rebalance)와는 별개.
   const hour = opts.reflectionHour ?? (Number.isFinite(Number.parseInt(process.env.ELANOUS_REFLECTION_HOUR ?? '', 10)) ? Number.parseInt(process.env.ELANOUS_REFLECTION_HOUR!, 10) : 21);
   upsert('internal:daily-reflection', 'daily-reflection', 'daily-reflection', `0 ${hour} * * *`, null, 'daemon: elanous 활동 회고(노트/OCR/세션) 스냅샷 푸시', 'report', 'elanous');
+  // WATCH-DEFAULT — fail-soft: a broken sources file or config must not stop the other internal rows.
+  let watchSources: ReturnType<typeof listSources> = [];
+  try {
+    const watchEnabled = opts.watchEnabled ?? (getUserConfig().watch?.enabled !== false);
+    watchSources = watchEnabled ? listSources({ seat: 'user' }, opts.watchRoot ?? effectiveInstanceRoot()) : [];
+  } catch (error) {
+    debug.log('watch.default', 'failed', { stage: 'inventory', reason: error instanceof Error ? error.message : String(error) });
+  }
+  if (watchSources.length > 0) {
+    upsert('internal:watch-collect', 'watch-collect', 'watch-default', '0 7 * * *', null,
+      'intake source run-due --seat user', 'ingest', 'elanous');
+    upsert('internal:watch-brief', 'watch-brief', 'watch-default', '30 8 * * *', null,
+      'intake digest --seat user --telegram', 'digest', 'elanous');
+    debug.log('watch.default', 'scheduled', { topics: watchSources.length, items: 0, sent: false });
+  } else {
+    db.run("DELETE FROM schedule_registry WHERE id IN ('internal:watch-collect', 'internal:watch-brief') AND source = 'watch-default'");
+  }
   // discovery (env 설정 시에만 가동) — 코어 인프라 → elanous.
   const dm = opts.discoveryIntervalMs ?? Number.parseInt(process.env.ELANOUS_DISCOVERY_CRON_INTERVAL_MS ?? '', 10);
   if (Number.isFinite(dm) && dm > 0) {

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

@@ -75,3 +75,42 @@ export function kindRouteTarget(cfg: UserConfig, kind?: string): { botToken: str
   if (!ch || !Number.isFinite(ch.chatId)) return null;
   return { botToken: ch.botToken, chatId: ch.chatId };
 }
+
+export type ReportRouteReason =
+  | 'routed' | 'report-role-missing' | 'no-role-channel'
+  | 'no-report-channel' | 'report-bot-not-distinct' | 'report-chat-invalid' | 'no-main-home';
+
+/** Why a kind has (or lacks) a delivery target — no logging, no sending. Mirrors
+ *  `resolveReportTarget` so a skipped send can say *which* rule closed it instead of
+ *  «no report channel configured» (BRIEF-DELIVERY-1007: a channels table without a
+ *  `report` role closed the morning brief for four days while reportChannel was set). */
+export function explainReportRoute(cfg: UserConfig, kind?: string): { reason: ReportRouteReason; role: string; hint: string } {
+  const role = roleForKind(cfg, kind);
+  const trading = isTradingKind(kind);
+  if (cfg.telegram.channels?.length) {
+    if (kindRouteTarget(cfg, kind)) return { reason: 'routed', role, hint: '' };
+    const hasRole = resolveTelegramChannels(cfg.telegram).some(c => c.roles.includes(role));
+    if (trading && !hasRole && cfg.telegram.reportChannel) {
+      return {
+        reason: 'report-role-missing', role,
+        hint: `채널 표에 «${role}» 역할 칸이 없다 — telegram.reportChannel 은 채널 표가 있으면 쓰지 않는다. `
+          + `telegram.channels[].roles 에 "${role}" 를 더하거나 telegram.kindRoles.${kind ?? '<kind>'} 로 있는 역할을 고른다`,
+      };
+    }
+    return { reason: 'no-role-channel', role, hint: `채널 표에 «${role}» 역할을 가진 허용된 봇 칸이 없다 — telegram.channels 를 확인` };
+  }
+  if (!trading) {
+    return mainHomeTarget(cfg)
+      ? { reason: 'routed', role, hint: '' }
+      : { reason: 'no-main-home', role, hint: '운영 봇 또는 telegram.homeChannel·allowedUsers 가 없다' };
+  }
+  const rc = cfg.telegram.reportChannel;
+  if (!rc) return { reason: 'no-report-channel', role, hint: 'telegram.reportChannel 이 없다' };
+  const mainToken = resolveChannelBotToken('telegram', cfg).token;
+  if (!rc.botToken || rc.botToken === mainToken) {
+    return { reason: 'report-bot-not-distinct', role, hint: 'telegram.reportChannel 의 봇이 없거나 운영 봇과 같다 — 매매 보고는 별도 봇만 쓴다' };
+  }
+  return Number.isFinite(rc.chatId)
+    ? { reason: 'routed', role, hint: '' }
+    : { reason: 'report-chat-invalid', role, hint: 'telegram.reportChannel.chatId 가 숫자가 아니다' };
+}

package/src/domains/watch-default-scheduler.ts

@@ -0,0 +1,95 @@
+import { debug } from '../debug/log.js';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getUserConfig } from '../user-config.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { listSources, runDue } from '../intake-plane/intake-sources.js';
+import { runIntakeDigestCli } from '../cli/intake-cli.js';
+import { resolveTimeZone } from '../time/format.js';
+import { inventoryInternalSchedules, openSchedulesDb } from './schedule-registry.js';
+import type { Database } from 'bun:sqlite';
+
+export interface WatchDefaultSchedulerOpts {
+  root?: string;
+  enabled?: () => boolean;
+  now?: () => Date;
+  timeZone?: string;
+  collect?: () => Promise<unknown>;
+  brief?: () => Promise<unknown>;
+  setInterval?: (tick: () => void, ms: number) => ReturnType<typeof setInterval>;
+  openDb?: () => Database;
+}
+
+/** Daemon-owned watch jobs: the inventory rows describe these two actual timers. */
+export function startWatchDefaultScheduler(opts: WatchDefaultSchedulerOpts = {}): { stop(): void; tickNow(): Promise<void> } {
+  const root = opts.root ?? effectiveInstanceRoot();
+  const enabled = opts.enabled ?? (() => getUserConfig().watch?.enabled !== false);
+  const timeZone = opts.timeZone ?? resolveTimeZone().timeZone;
+  const now = opts.now ?? (() => new Date());
+  const collect = opts.collect ?? (() => runDue({ seat: 'user', deps: { stateDir: root } }));
+  // The CLI sets process.exitCode on an unsent report; inside the daemon that would leak into the daemon's own exit status.
+  const brief = opts.brief ?? (async () => {
+    const before = process.exitCode;
+    try { return await runIntakeDigestCli({ seat: 'user', telegram: true }, { root }); }
+    finally { process.exitCode = before; }
+  });
+  const lastRunFile = join(root, 'intake', 'watch-default-last-run.json');
+  const lastRun = new Map<string, string>();
+  let lastInventory: string | undefined;
+  let lastFailure: string | undefined;
+  try {
+    if (existsSync(lastRunFile)) {
+      const saved = JSON.parse(readFileSync(lastRunFile, 'utf8')) as Record<string, string>;
+      for (const [job, day] of Object.entries(saved)) if (typeof day === 'string') lastRun.set(job, day);
+    }
+  } catch (error) { debug.log('watch.default', 'failed', { reason: `last-run: ${String(error)}` }); }
+  let running = false;
+  let stopped = false;
+  const tickNow = async (): Promise<void> => {
+    if (stopped || running) return;
+    running = true;
+    try {
+      const active = enabled() && listSources({ seat: 'user' }, root).length > 0;
+      const registryDay = now().toISOString().slice(0, 10);
+      const inventoryKey = `${registryDay}:${active}`;
+      if (lastInventory !== inventoryKey) {
+        // The registry row is a view; a registry failure must not skip the real collect/brief of this minute.
+        try {
+          const db = (opts.openDb ?? openSchedulesDb)();
+          try { inventoryInternalSchedules(db, { watchRoot: root, watchEnabled: active }); lastInventory = inventoryKey; }
+          finally { if (!opts.openDb) db.close(); }
+        } catch (error) { debug.log('watch.default', 'failed', { stage: 'registry', reason: String(error) }); }
+      }
+      lastFailure = undefined;
+      if (!active) return;
+      const parts = new Intl.DateTimeFormat('en-CA', {
+        timeZone, year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', hourCycle: 'h23',
+      }).formatToParts(now());
+      const part = (type: string) => parts.find((entry) => entry.type === type)?.value ?? '';
+      const day = `${part('year')}-${part('month')}-${part('day')}`;
+      const clock = `${part('hour')}:${part('minute')}`;
+      for (const [job, at, fire] of [['watch-collect', '07:00', collect], ['watch-brief', '08:30', brief]] as const) {
+        if (clock !== at || lastRun.get(job) === day) continue;
+        try {
+          const outcome = await fire();
+          if (job === 'watch-brief' && (!outcome || (outcome as { sent?: boolean }).sent !== true)) continue;
+          if (job === 'watch-collect' && typeof outcome === 'object' && outcome && 'ran' in outcome
+            && (outcome as { ran: Array<{ error?: string }> }).ran.some((row) => row.error)) continue;
+          lastRun.set(job, day);
+          mkdirSync(join(root, 'intake'), { recursive: true });
+          const temp = `${lastRunFile}.${process.pid}.tmp`;
+          writeFileSync(temp, JSON.stringify(Object.fromEntries(lastRun)) + '\n');
+          renameSync(temp, lastRunFile);
+        } catch (error) { debug.log('watch.default', 'failed', { job, reason: String(error) }); }
+      }
+    } catch (error) {
+      const reason = String(error);
+      if (reason !== lastFailure) debug.log('watch.default', 'failed', { reason });
+      lastFailure = reason;
+    } finally { running = false; }
+  };
+  const timer = (opts.setInterval ?? setInterval)(() => { void tickNow(); }, 60_000);
+  if (typeof timer === 'object') timer.unref?.();
+  void tickNow();
+  return { stop() { stopped = true; clearInterval(timer); }, tickNow };
+}

package/src/esc-abort-gate.ts

@@ -34,6 +34,9 @@ import type { KeyEvent } from './display/types.js';
 import type { ThemeTokens } from './theme/tokens.js';
 import { debug } from './debug/log.js';
 import { abortTurnOnly } from './turn-abort-scope.js';
+import { SELF_IMPLEMENT_TOOL_NAMES } from './boot/daemon-tools/self-implement-names.js';
+
+export const DASHBOARD_CLARIFICATION_REQUEST = Symbol.for('elanous.dashboard.clarification-request');
 
 export interface EscAbortGateDeps {
   abortCtrl: AbortController;
@@ -87,8 +90,14 @@ export async function routeStreamingEscapeKey(
   gate: Pick<EscAbortGate, 'handleEscape' | 'handleKey' | 'isGateOpen'>,
   gateEvent: KeyEvent,
   consumeDragEscape: () => Promise<boolean>,
+  consumeTopModalEscape: () => boolean | 'passthrough' = () => false,
 ): Promise<boolean> {
   if (key.kind && key.kind !== 'press') return false;
+  if (key.name === 'escape') {
+    const modalResult = consumeTopModalEscape();
+    if (modalResult === true) return true;
+    if (modalResult === 'passthrough') return false;
+  }
   if (gate.isGateOpen()) {
     gate.handleKey(gateEvent);
     return true;
@@ -99,6 +108,41 @@ export async function routeStreamingEscapeKey(
   return true;
 }
 
+export function consumeStreamingTopModalEscape(input: {
+  modal: Pick<ModalSurface, 'id' | 'onKey'> | null;
+  abortGateModalId: string | null;
+  event: KeyEvent;
+  question?: { id: string; dispose(cancelled: boolean): void; isClarification: boolean };
+  onClarificationClosed(): void;
+  topModalId(): string | null;
+  redraw(): void;
+}): boolean | 'passthrough' {
+  const { modal, question } = input;
+  if (!modal || modal.id === input.abortGateModalId) return false;
+  if (modal.id === question?.id) {
+    question.dispose(true);
+    if (question.isClarification) input.onClarificationClosed();
+    input.redraw();
+    return true;
+  }
+  if (!modal.onKey) return 'passthrough';
+  modal.onKey(input.event);
+  input.redraw();
+  return input.topModalId() === modal.id ? 'passthrough' : true;
+}
+
+export function createHarnessEscHint(pushLine: (line: string) => void): (targets: readonly string[]) => boolean {
+  let shown = false;
+  return (targets) => {
+    if (!targets.some(name => (SELF_IMPLEMENT_TOOL_NAMES as readonly string[]).includes(name))) return false;
+    if (!shown) {
+      pushLine('하니스 런은 따로 계속 돈다 — 멈추려면 /harness stop <space-id> · 목록은 /harness runs');
+      shown = true;
+    }
+    return true;
+  };
+}
+
 export function createEscAbortGate(deps: EscAbortGateDeps): EscAbortGate {
   let current: ApprovalModalHandle | null = null;
   let currentDispose: (() => void) | null = null;

package/src/execution-loop/gates.ts

@@ -3,6 +3,7 @@ import { decideBudget, readBudgetInputsLive, type BudgetDecision, type BudgetInp
 import { resolveHarnessSubstrate, type ResolvedHarnessSubstrate } from '../harness/harness-substrate-default.js';
 import { podMemoryLimitFor } from '../task-orchestrator/surfaces/self-implement-pod.js';
 import { recallMemoryContext } from '../agent-substrate/execution/memory-context.js';
+import { CONTEXT_CARD_SCREEN_CHARS } from '../context-card/index.js';
 
 export interface GateResult<T> {
   decision: T;
@@ -169,6 +170,7 @@ export async function relationGate(
 export interface MemoryGateDeps {
   recall: (query: string) => Promise<string>;
   priorAbandonment: (goalId: string) => Promise<string | undefined> | string | undefined;
+  priorMustFix?: (goalId: string) => readonly string[];
 }
 
 export interface MemoryDecision {
@@ -183,15 +185,22 @@ export async function memoryGate(
   card: Pick<TaskCard, 'goalId' | 'title'>,
   deps: MemoryGateDeps = { recall: recallMemoryContext, priorAbandonment: () => undefined },
 ): Promise<GateResult<MemoryDecision>> {
-  const [context, priorAbandonment] = await Promise.all([
+  const [recall, priorAbandonment] = await Promise.all([
     deps.recall(card.title), deps.priorAbandonment(card.goalId),
   ]);
+  // must-fix 와 recall 은 서로 독립이다 — recall 이 비어도 앞선 must-fix 는 맥락에 남는다.
+  const mustFix = deps.priorMustFix?.(card.goalId) ?? [];
+  const mustFixBlock = mustFix.length ? `앞선 must-fix:\n${mustFix.map((item) => `- ${item}`).join('\n')}` : '';
+  const combined = [mustFixBlock, recall].filter(Boolean).join('\n');
+  const codePoints = [...combined];
+  const truncated = codePoints.length > CONTEXT_CARD_SCREEN_CHARS;
+  const context = truncated ? codePoints.slice(0, CONTEXT_CARD_SCREEN_CHARS).join('') : combined;
   const decision: MemoryDecision = {
     action: 'record', context, fragmentIds: [],
     ...(priorAbandonment === undefined ? {} : { priorAbandonment }),
   };
   return {
     decision,
-    explanation: `memory=${context ? 'recalled' : 'none or unavailable'}; prior abandonment=${priorAbandonment ?? 'unknown'}; fragment IDs unavailable from recall API`,
+    explanation: `memory=${recall ? 'recalled' : 'none or unavailable'}; prior abandonment=${priorAbandonment ?? 'unknown'}; fragment IDs unavailable from recall API${truncated ? `; truncated; chars=${[...context].length}/${CONTEXT_CARD_SCREEN_CHARS}` : ''}`,
   };
 }

package/src/flow-loop/split.ts

@@ -1,23 +1,27 @@
 import type { TaskCard } from '../task-cards/card-store.js';
 
-export interface SplitCell { id: string; title: string; seat?: string; host?: string }
+export interface SplitCell { id: string; title: string; kind?: string; seat?: string; host?: string }
 
 /** FLOW1: only explicitly assigned work may enter a seat's queue. The same proposal is used in shadow and live. */
 export function splitCard(card: TaskCard, _opts: { shadow?: boolean } = {}): SplitCell[] {
   const intake = [...card.sections].reverse().find(section => section.key.startsWith('intake:wish:'));
   let text = card.title;
+  let kind: string | undefined;
   if (intake) {
     let body: unknown;
     try { body = JSON.parse(intake.content); } catch { body = intake.content; }
     if (typeof body === 'string') text = body;
-    else if (body && typeof body === 'object' && typeof (body as { text?: unknown }).text === 'string') text = (body as { text: string }).text;
+    else if (body && typeof body === 'object') {
+      if (typeof (body as { text?: unknown }).text === 'string') text = (body as { text: string }).text;
+      if (typeof (body as { kind?: unknown }).kind === 'string') kind = (body as { kind: string }).kind;
+    }
   }
   const lines = text.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
   const cells: SplitCell[] = lines.map((line, index) => {
     const match = /^(?:[-*]|\d+[.)])?\s*\[(OP|MK|TC|UX)\]\s*(.+)$/u.exec(line);
-    if (match) return { id: `${card.id}-${index + 1}`, title: match[2]!.trim(), seat: match[1]! };
+    if (match) return { id: `${card.id}-${index + 1}`, title: match[2]!.trim(), seat: match[1]!, ...(kind !== undefined ? { kind } : {}) };
     // 담당 없는 행도 칸으로 남긴다 — seat 가 없으니 대기열엔 못 들어가고 tick 이 unplaced-no-owner 로 센다.
-    return { id: `${card.id}-${index + 1}`, title: line.replace(/^(?:[-*]|\d+[.)])\s*/u, '') };
+    return { id: `${card.id}-${index + 1}`, title: line.replace(/^(?:[-*]|\d+[.)])\s*/u, ''), ...(kind !== undefined ? { kind } : {}) };
   });
   // 의뢰 본문이 있으면 담당이 하나도 없어도 행마다 칸으로 남긴다. 본문 없이 제목뿐일 때만 카드 한 칸.
   return intake || cells.some(cell => cell.seat) ? cells : [{ id: card.id, title: card.title }];

package/src/git-fs/worktree.ts

@@ -20,6 +20,9 @@ import { debug } from '../debug/log.js';
 import { getUserConfig } from '../user-config.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;
 
 export interface WorktreeAddDeps {
@@ -439,14 +442,31 @@ export function syncBaseWithRemote(
   // 원격이 "그런 브랜치 없다" 고 답했다 ⇒ 축약 hex 여도 모호하지 않다.
   if (!hasRemote) return asSha(false) ?? { checkout: base, freshness: 'local-only' };
 
+  // ⭐ 얕은 저장소면 깊이를 묶는다 — 아니면 그 브랜치의 전 이력을 받느라 GIT_TIMEOUT_MS 를 넘긴다
+  //    (Pod 클론은 `--depth 50` · 비-main base 런이 전부 여기서 SIGTERM 으로 죽었다). 받은 tip 에서 갈리므로
+  //    이후 merge-base(HEAD ↔ 그 tip)는 tip 자체라 깊이 50 으로 족하다. 얕지 않으면 종전 인자 그대로다.
+  //    probe 를 못 읽으면 종전 경로로 간다(값은 'unknown' 으로 관측에 남긴다).
+  const shallowProbe = git('rev-parse', '--is-shallow-repository');
+  const shallowAnswer = shallowProbe.status === 0 ? (shallowProbe.stdout || '').trim() : '';
+  const shallow: boolean | 'unknown' = shallowAnswer === 'true' ? true : shallowAnswer === 'false' ? false : 'unknown';
+  const depth = shallow === true ? SHALLOW_BASE_FETCH_DEPTH : null;
+  const fetchArgs = depth === null ? ['fetch', 'origin', wanted] : ['fetch', `--depth=${depth}`, 'origin', wanted];
+  const fetchStartedAt = Date.now();
   // Only the no-runner fallback joins the shared retry seam; injected runners remain
   // an exact test/caller seam with their prior command count.
   const fetched = runner
-    ? git('fetch', 'origin', wanted)
-    : runGitCommand(repoRoot, ['fetch', 'origin', wanted], { encoding: 'utf8', timeout: GIT_TIMEOUT_MS });
+    ? git(...fetchArgs)
+    : runGitCommand(repoRoot, fetchArgs, { encoding: 'utf8', timeout: GIT_TIMEOUT_MS });
+  const fetchMs = Date.now() - fetchStartedAt;
+  debug.log('git-fs.worktree', 'base.fetch', { base, shallow, depth, ms: fetchMs, ok: fetched.status === 0, signal: fetched.signal ?? null }, fetched.status === 0 ? undefined : { level: 'warn' });
   if (fetched.status !== 0) {
     // origin 에 있는 것을 확인했는데 못 가져왔다 ⇒ 낡은 로컬로 진행하면 조용히 틀린다.
-    throw new Error(`git worktree base sync failed — origin/${remoteBranch} exists but fetch failed: status=${fetched.status}, signal=${fetched.signal ?? 'none'}, stdout=${JSON.stringify((fetched.stdout || '').trim().slice(0, 200))}, stderr=${JSON.stringify((fetched.stderr || '').trim().slice(0, 200))}`);
+    // spawnSync 의 timeout 은 SIGTERM 으로 끝난다 — 「실패」와 「시간 초과」를 문면에서 가른다.
+    const timedOut = fetched.status === null && fetched.signal === 'SIGTERM';
+    const what = timedOut
+      ? `fetch timed out after ${GIT_TIMEOUT_MS / 1000}s (shallow=${shallow}${depth === null ? '' : `, depth=${depth}`})`
+      : 'fetch failed';
+    throw new Error(`git worktree base sync failed — origin/${remoteBranch} exists but ${what}: status=${fetched.status}, signal=${fetched.signal ?? 'none'}, stdout=${JSON.stringify((fetched.stdout || '').trim().slice(0, 200))}, stderr=${JSON.stringify((fetched.stderr || '').trim().slice(0, 200))}`);
   }
   // ⭐ **가져온 것**에서 갈린다(리뷰 must-fix ②) — ls-remote 로 먼저 읽은 SHA 를 쓰면 그 사이 원격이
   //    전진했을 때 "원격 tip" 계약이 깨진다. FETCH_HEAD 가 방금 받은 tip 이다.

package/src/graph-runner/runner.ts

@@ -35,7 +35,11 @@ export interface GraphRunState {
   stoppedAt?: string;
   status: 'running' | 'done' | 'failed' | 'budget-exceeded' | 'awaiting-approval';
   path: string[];
-  nodes: Array<{ nodeId: string; ok: boolean; exit: number | null; executed: boolean; output?: unknown; error?: string; decidedBy?: string; decidedAt?: string }>;
+  /** startedAt/endedAt (ISO) and seconds are written when the node runs; ledgers before GRAPH-NODE-TIMES (0.2.19) have none. */
+  nodes: Array<{ nodeId: string; ok: boolean; exit: number | null; executed: boolean; output?: unknown; error?: string; decidedBy?: string; decidedAt?: string;
+    startedAt?: string; endedAt?: string; seconds?: number }>;
+  /** The node now running and when it started; cleared when its record is written. */
+  currentNode?: { nodeId: string; startedAt: string };
   input?: unknown;
   pending?: { nodeId: string; message: string; since: string; notifiedAt?: string; decision?: 'approved' | 'rejected'; decidedBy?: string; decidedAt?: string };
   approvalSourceHash?: string;
@@ -658,6 +662,8 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     }
     state.status = 'running';
     const startedAt = performance.now();
+    const nodeStartedAt = new Date().toISOString();
+    if (!resumingCompleted) state.currentNode = { nodeId: current, startedAt: nodeStartedAt };
     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' });
@@ -723,6 +729,10 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       error = result.error ? redactCredentials(result.error) : undefined;
       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();
+    delete state.currentNode;
     if (resumingCompleted && completed) {
       ok = completed.ok;
       exit = completed.exit;
@@ -734,7 +744,8 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         output = JSON.stringify({ outcome: ok ? 'approved' : 'rejected', ...(state.pending?.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending?.decidedAt ?? null });
       }
       state.nodes.push({ nodeId: current, ok, exit, executed: !!command && (!state.dryRun || !!command.dry_run_command), ...((command || approval) && (!state.dryRun || !!command?.dry_run_command) && output !== undefined ? { output } : {}), ...(error ? { error } : {}),
-        ...(approval && state.pending ? { ...(state.pending.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending.decidedAt } : {}) });
+        ...(approval && state.pending ? { ...(state.pending.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending.decidedAt } : {}),
+        startedAt: nodeStartedAt, endedAt: nodeEndedAt, seconds });
     }
     if (approval) {
       delete state.pending;
@@ -742,7 +753,6 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     }
     const reported = command && (!state.dryRun || command.dry_run_command) ? lastJsonObject(resumingCompleted ? completed?.output : output)?.outcome : undefined;
     const namedOutcome = typeof reported === 'string' ? reported : undefined;
-    const seconds = Number(((performance.now() - startedAt) / 1000).toFixed(2));
     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 });
@@ -892,11 +902,21 @@ export function manageGraphRun(graphId: string, runId: string, action: 'stop' |
         catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ESRCH') throw error; }
       }
     }
+    const current = state.currentNode;
+    const running = current && state.path.length === state.nodes.length + 1 && current.nodeId === state.path.at(-1) &&
+      Number.isFinite(Date.parse(current.startedAt)) ? current.startedAt : undefined;
+    // One stop instant for the node end, finishedAt and stoppedAt — never before the running node's start.
+    const stopMs = running === undefined ? Date.now() : Math.max(Date.now(), Date.parse(running));
     if (state.path.length === state.nodes.length + 1) {
-      state.nodes.push({ nodeId: state.path.at(-1)!, ok: false, exit: null, executed: false, error: 'stopped before node completed' });
+      state.nodes.push({ nodeId: state.path.at(-1)!, ok: false, exit: null, executed: false, error: 'stopped before node completed',
+        // The stop instant is always the node end; a start (and so seconds) exists only when the ledger named the running
+        // node — a run begun by a runner before GRAPH-NODE-TIMES did not, and a guessed start would be a false time.
+        endedAt: new Date(stopMs).toISOString(),
+        ...(running === undefined ? {} : { startedAt: running, seconds: Number(((stopMs - Date.parse(running)) / 1000).toFixed(2)) }) });
     }
+    delete state.currentNode;
     state.status = 'failed';
-    state.finishedAt = new Date().toISOString();
+    state.finishedAt = new Date(stopMs).toISOString();
     state.stoppedAt = state.finishedAt;
     delete state.activeNode;
     persistGraphRun(state);

package/src/harness/harness-cli-command.ts

@@ -23,6 +23,7 @@ import { queryRunningRuns } from '../self-implement/running-runs.js';
 import { DevPipelineError } from '../self-dev/dev-pipeline.js';
 import { runDraftSweep, sweepFailureReason, type DraftSweepAdapters, type DraftSweepResult, type SweepDraft, type SweepMergedPr, type SweepReviewGate } from '../self-dev/draft-sweep.js';
 import { debug } from '../debug/log.js';
+import { installHarnessSalvageCommand } from './harness-salvage-cli.js';
 import { decideNestedElanousLaunch, readNestedElanousDepth } from './nested-elanous-policy.js';
 import { dispatchTask, type DispatchTaskInput, type DispatchTaskDeps } from '../execution-loop/dispatch-task.js';
 import { launchRequestId, preLaunchGate, type PreLaunchGateDeps } from '../execution-loop/launch-gate.js';
@@ -33,7 +34,7 @@ import { installDeliverableVerifyCliCommand, type InstallDeliverableVerifyCliDep
 import { getUserConfig } from '../user-config.js';
 import { resolveRepositoryName } from './repository-name.js';
 import { installHarnessCliSinkHook } from './harness-cli-sink.js';
-import { addHarnessQueue, HarnessQueueDuplicateError, harnessQueueReceiptPath, listHarnessQueue, queueSeatForCwd, reconcileHarnessQueue, removeHarnessQueue, tickHarnessQueue, type HarnessQueueDeps, type QueueItem, type QueueSeat } from './harness-queue.js';
+import { addHarnessQueue, HarnessQueueDuplicateError, harnessQueueReceiptPath, listHarnessQueue, queueSeatForCwd, reconcileHarnessQueue, removeHarnessQueue, setHarnessQueuePriority, tickHarnessQueue, type HarnessQueueDeps, type QueueItem, type QueueSeat } from './harness-queue.js';
 import { writeHarnessQueueReceipt } from './harness-queue-child.js';
 import { parseDoorSince, queryLaunchDoors, renderLaunchDoors, type DoorTable } from './launch-stamp.js';
 import { resolveHarnessSubstrate, type ResolvedHarnessSubstrate } from './harness-substrate-default.js';
@@ -2511,6 +2512,7 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
   installDeliverableVerifyCliCommand(harnessCmd, deps.deliverableVerify);
   installHarnessProcessObservationCommand(harnessCmd, deps.processObservation);
   installHarnessBudgetCommand(harnessCmd);
+  installHarnessSalvageCommand(harnessCmd);
   installHarnessGoalCommand(harnessCmd, deps.goalLookup, deps.goalArchive);
   installHarnessDraftSweepCommand(harnessCmd, deps.draftSweep);
   const queue = harnessCmd.command('queue').description('자리별 영속 발사 대기열');
@@ -2548,12 +2550,20 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
       console.log(`${row.id} ${row.seat} ${row.kind} queued`);
     }));
   queue.command('list').description('대기·발사 원장 조회').action(() => queueAction(async () => {
-    for (const row of listHarnessQueue(queueDeps)) console.log(`${row.id} ${row.seat} ${row.status} ${row.kind} ${row.input}${row.waitingReason ? ` · ${row.waitingReason}` : ''}`);
+    for (const row of listHarnessQueue(queueDeps)) console.log(`${row.id} ${row.seat} ${row.status} ${row.kind} ${row.input}${row.priority === undefined ? '' : ` · prio ${row.priority}`}${row.waitingReason ? ` · ${row.waitingReason}` : ''}`);
   }));
   queue.command('remove <id>').description('대기 중 또는 종료 확인된 항목 제거').action((id: string) => queueAction(async () => {
     if (!await removeHarnessQueue(id, queueDeps)) throw new Error(`queue item active or not found: ${id}`);
     console.log(`${id} removed`);
   }));
+  queue.command('prio <id> <n>').description('대기 중 항목의 우선순위 재조정(클수록 먼저 · 다음 tick 부터)').action((id: string, n: string) => queueAction(async () => {
+    const value = Number(n);
+    if (!n.trim() || !Number.isFinite(value)) throw new Error(`harness queue prio: 수가 아니다 — ${n}`);
+    // A CLI call is the actor here; a seat or track that drives it names itself through the environment.
+    const by = process.env.ELANOUS_TRACK || process.env.ELANOUS_HARNESS_SEAT || 'cli';
+    const row = await setHarnessQueuePriority(id, value, by, queueDeps);
+    console.log(`${row.id} prio ${row.priority}`);
+  }));
   queue.command('reconcile <id>').description('불확정 발사를 확인하고 종료 또는 미발사 증거가 있으면 예약 해소').action((id: string) => queueAction(async () => {
     console.log(`${id} ${await reconcileHarnessQueue(id, queueDeps)}`);
   }));