elanous 0.2.28 → 0.2.31

package/src/domains/release-tool.ts

@@ -21,7 +21,7 @@ export const RELEASE_STATUS_SPEC: LLMToolSpec = {
     + 'topic=cell: id 칸 하나의 상태·근거와 살핀 판.\n'
     + 'topic=schedule: 발행 이후 판의 컷·착지·발행·동결 일정.\n'
     + 'topic=ops: 도는 런·발행·늦은 스케줄·자리·열린 결정의 출처 있는 개관.\n'
-    + 'topic 과 action 을 동시에 쓰면 topic 을 우선하고 action 은 무시한다. topic 은 읽을 대상, action 은 단독 조회의 짧은 요약.\n'
+    + 'topic 과 action 을 동시에 쓰면 오류를 돌려받는다 — 둘 중 하나만 보낸다. topic 은 읽을 대상, action 은 단독 조회의 짧은 요약.\n'
     + 'topic=features 에서는 owner·status 로 칸을 필터링할 수 있다.\n'
     + '발행·버전·피처·체크리스트·칸·컷·일정·운영 상태 질문은 Grep·ListDir·파일 검색보다 이 도구를 먼저 부른다 — 그 답은 파일이 아니라 원장에 있다.',
   parameters: { type: 'object', properties: {
@@ -122,13 +122,29 @@ function cellView(item: ChecklistItem) {
     owner: item.owner ?? null, priority: item.priority ?? null, evidence: item.evidence ? firstLine(item.evidence) : null };
 }
 
-export function dispatchReleaseStatus(args: Record<string, unknown>, deps: ReleaseToolDeps = {}): { text: string; structured: Record<string, unknown> } {
+export function dispatchReleaseStatus(rawArgs: Record<string, unknown>, deps: ReleaseToolDeps = {}): { text: string; structured: Record<string, unknown> } {
+  // A blank topic/action ("" · spaces) means «not sent» — models fill unused enum slots with "" and then hit the
+  // simultaneous-topic-and-action rejection over and over (TUI defect #70 · 10-15: 10+ identical retries, then gave up).
+  const args = { ...rawArgs };
+  for (const key of Object.keys(args)) if (typeof args[key] === 'string' && !(args[key] as string).trim()) delete args[key];
+  // topic=status is the default read — beside an action it adds nothing, so the action wins (#70 · 10-15 실측:
+  // models send {topic:"status", action:"landed"} and looped on the simultaneous-topic-and-action rejection).
+  if (args.topic === 'status' && args.action !== undefined) delete args.topic;
+  // Any other non-features topic beside an action: the action wins too, with one warning line in front (#70b · 10-15
+  // 실측: {topic:"ops", action:"schedule"} rejected over and over). topic=features ⊕ action stays rejected below —
+  // a feature list and a short summary are different answers.
+  if (args.action !== undefined && typeof args.topic === 'string'
+    && ['cell', 'schedule', 'ops'].includes(args.topic)) {
+    const { topic: ignoredTopic, ...rest } = args;
+    debug.log('release.tool', 'topic-ignored-for-action', { topic: ignoredTopic, action: args.action });
+    const result = dispatchReleaseStatus(rest, deps);
+    return { text: `topic(${ignoredTopic}) 은 무시하고 action 으로 답함\n${result.text}`, structured: { ...result.structured, ignoredTopic } };
+  }
   const topic = args.topic === undefined ? 'status' : args.topic;
   if (typeof topic !== 'string' || !['status', 'features', 'cell', 'schedule', 'ops'].includes(topic)) throw new Error('topic 은 status, features, cell, schedule, ops 중 하나');
-  const ignoredAction = args.topic !== undefined && args.action !== undefined ? args.action : undefined;
-  const withIgnoredAction = (result: { text: string; structured: Record<string, unknown> }) => ignoredAction === undefined
-    ? result
-    : { ...result, text: `action=${String(ignoredAction)} 은 무시됨 — topic 과 같이 못 쓴다\n${result.text}` };
+  if (args.topic !== undefined && args.action !== undefined) {
+    throw new Error('topic 과 action 을 동시에 쓸 수 없습니다 — 둘 중 하나만: topic=features 는 피처 목록 · action 은 짧은 요약');
+  }
   const requested = args.version;
   if (topic === 'features') {
     for (const key of ['owner', 'status'] as const) {
@@ -149,10 +165,10 @@ export function dispatchReleaseStatus(args: Record<string, unknown>, deps: Relea
     const kinds: ContextFact['kind'][] = ['run', 'release', 'schedule-late', 'seat', 'decision'];
     const facts = answer.facts.filter(fact => kinds.includes(fact.kind));
     debug.log('release.tool', 'status', { action: 'status', topic, version: requested ?? null });
-    return withIgnoredAction({ text: facts.length ? facts.map(fact => JSON.stringify(fact)).join('\n') : '운영 개관: 관측된 사실 없음', structured: { facts } });
+    return { text: facts.length ? facts.map(fact => JSON.stringify(fact)).join('\n') : '운영 개관: 관측된 사실 없음', structured: { facts } };
   }
   const dev = checklistDevVersion(deps.devVersion?.() ?? devVersion());
-  if (ignoredAction === undefined && args.action !== undefined) {
+  if (args.action !== undefined) {
     const action = args.action;
     if (typeof action !== 'string' || !['schedule', 'blocked', 'landed'].includes(action)) {
       throw new Error('action 은 schedule, blocked, landed 중 하나여야 합니다');
@@ -225,7 +241,7 @@ export function dispatchReleaseStatus(args: Record<string, unknown>, deps: Relea
           publishAt: row.publishAt ?? null, freezeFrom: row.freezeFrom ?? null, freezeUntil: row.freezeUntil ?? null })) } };
     }
     debug.log('release.tool', 'status', { action: 'status', topic, version: requested ?? dev });
-    return withIgnoredAction(result);
+    return result;
   }
   const version = requested ? null : dev;
   const versions = requested ? [requested as string] : [version!, nextVersion(version!)];
@@ -270,7 +286,7 @@ export function dispatchReleaseStatus(args: Record<string, unknown>, deps: Relea
     : published.state === 'unreadable' ? `발행 판 ${published.version} · 발행 기록 못 읽음` : '발행 판 모름';
   const structured = { releases: entries, latestRun: latest, published };
   debug.log('release.tool', 'status', { action: 'status', topic, version: versions.join(',') });
-  return withIgnoredAction({ text: `${lines.join('\n\n')}\n${cards.map(formatElanousCard).join('\n')}\n${publishedLine}`, structured });
+  return { text: `${lines.join('\n\n')}\n${cards.map(formatElanousCard).join('\n')}\n${publishedLine}`, structured };
 }
 
 function requiredString(args: Record<string, unknown>, key: string): string {

package/src/domains/surface-events.ts

@@ -146,7 +146,10 @@ export function recordInboundTurn(
 ): string | null {
   const q = (opts.userText ?? '').trim();
   if (!q) return null;
-  const db = opts.db ?? openSurfaceEventsDb();
+  // Test runners must never fall through to the user's production memory DB.
+  const testRunner = process.env.NODE_ENV === 'test' || process.env.BUN_TEST !== undefined;
+  const isolatedTestPath = process.env.ELANOUS_STATE_DIR?.trim() ? surfaceEventsDbPath() : ':memory:';
+  const db = opts.db ?? openSurfaceEventsDb(testRunner ? isolatedTestPath : surfaceEventsDbPath());
   const ownDb = !opts.db;
   try {
     const a = (opts.responseText ?? '').trim();

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

@@ -50,8 +50,13 @@ export function startWatchDefaultScheduler(opts: WatchDefaultSchedulerOpts = {})
     running = true;
     try {
       const active = enabled() && listSources({ seat: 'user' }, root).length > 0;
-      const registryDay = now().toISOString().slice(0, 10);
-      const inventoryKey = `${registryDay}:${active}`;
+      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')}`;
+      const inventoryKey = `${day}:${active}`;
       if (lastInventory !== inventoryKey) {
         // The registry row is a view; a registry failure must not skip the real collect/brief of this minute.
         try {
@@ -62,14 +67,8 @@ export function startWatchDefaultScheduler(opts: WatchDefaultSchedulerOpts = {})
       }
       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;
+        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;

package/src/field-note/transcribe.ts

@@ -1,4 +1,5 @@
 import type { TranscriptEntry } from './index';
+import type { STTProvider } from '../voice/stt-provider.js';
 
 /** Mono, normalized PCM. The capture instant is required for NOTE1's absolute photo alignment. */
 export interface FieldAudio {
@@ -70,6 +71,22 @@ export function createCloudSttEngine(client: CloudSttClient): TranscriptionEngin
   };
 }
 
+export function createBatchSttEngine(provider: STTProvider): TranscriptionEngine {
+  return {
+    async transcribe(chunk, request) {
+      if (chunk.sampleRate !== 16000) throw new RangeError('Batch STT requires 16 kHz mono PCM');
+      const pcm = Buffer.alloc(chunk.samples.length * 2);
+      for (let i = 0; i < chunk.samples.length; i++) {
+        const sample = chunk.samples[i]!;
+        if (!Number.isFinite(sample)) throw new RangeError('Audio samples must be finite');
+        pcm.writeInt16LE(Math.round(Math.max(-1, Math.min(1, sample)) * (sample < 0 ? 32768 : 32767)), i * 2);
+      }
+      const { text } = await provider.transcribeBatch(pcm, { language: request.language });
+      return text.trim() ? [{ startSeconds: 0, endSeconds: chunk.samples.length / chunk.sampleRate, text }] : [];
+    },
+  };
+}
+
 export interface TranscriptionOptions {
   /** Default: ko. */
   language?: string;

package/src/fold-stack.ts

@@ -70,6 +70,9 @@ export interface StaticFoldTarget {
   groupKey?: string;
   /** Fold mode shared with fold-applied. FoldStack does not invent this. */
   mode?: string;
+  /** Offset (from lineStart) of the click that expanded this target —
+   *  clicking the same row again collapses it (#16 two-way click). */
+  expandedAtOffset?: number;
 }
 
 export type FoldTarget = LiveFoldTarget | StaticFoldTarget;
@@ -178,6 +181,7 @@ export class FoldStack {
 
     this.opts.chatLines.splice(t.lineStart, oldLen, ...newLines);
     t.expanded = nextExpanded;
+    t.expandedAtOffset = undefined;
     t.lineEnd  = t.lineStart + newLines.length;
 
     // Any OTHER static target whose lineStart is ≥ the toggled
@@ -224,6 +228,7 @@ export class FoldStack {
     const lineStart = t.lineStart;
     const lineEnd = t.lineEnd;
     const toggled = this.toggleTarget(t);
+    if (toggled) t.expandedAtOffset = t.expanded ? lineIndex - lineStart : undefined;
     if (toggled) {
       debug.log('log.fold', t.expanded ? 'fold-expanded' : 'fold-recollapsed', {
         mode: t.mode ?? null,
@@ -259,6 +264,16 @@ export class FoldStack {
     return t != null && t.expanded && t.lineStart === lineIndex;
   }
 
+  /** Fact for callers: may a click on `lineIndex` collapse its expanded
+   *  target? True on the first line, the last line, and the row whose
+   *  click expanded it — the rest of the body stays a reading area. */
+  isExpandedCollapseLine(lineIndex: number): boolean {
+    const t = this.findLatestStaticContaining(lineIndex);
+    if (t == null || !t.expanded) return false;
+    const offset = lineIndex - t.lineStart;
+    return offset === 0 || lineIndex === t.lineEnd - 1 || offset === t.expandedAtOffset;
+  }
+
   /** Toggle every static target on the stack in the same direction.
    *  If ≥ half are already expanded we collapse all; otherwise we
    *  expand all. Returns the number of targets that actually changed
@@ -273,7 +288,14 @@ export class FoldStack {
     const statics = this.targets.filter((t): t is StaticFoldTarget => t.kind === 'static');
     if (statics.length === 0) return 0;
     const expandedCount = statics.filter(t => t.expanded).length;
-    const targetExpanded = expandedCount * 2 < statics.length; // <50% → expand all
+    return this.setAll(expandedCount * 2 < statics.length); // <50% → expand all
+  }
+
+  /** Put every static target in one explicit state (`/log unfold all` ·
+   *  `/log fold all`). Returns how many targets changed; live targets are
+   *  skipped exactly as in toggleAll. */
+  setAll(targetExpanded: boolean): number {
+    const statics = this.targets.filter((t): t is StaticFoldTarget => t.kind === 'static');
     // Sort by lineStart ascending; toggling from the top of chatLines
     // down means later targets shift consistently as we go. Skip
     // targets already in the desired state.
@@ -287,6 +309,7 @@ export class FoldStack {
       const delta = newLines.length - oldLen;
       this.opts.chatLines.splice(t.lineStart, oldLen, ...newLines);
       t.expanded = targetExpanded;
+      t.expandedAtOffset = undefined;
       t.lineEnd = t.lineStart + newLines.length;
       if (delta !== 0) {
         for (const other of this.targets) {

package/src/git-fs/dirty.ts

@@ -5,10 +5,11 @@
 // kernel has to stat every tracked file vs its index entry.
 //
 // Throttle is enforced by the caller (the index.ts cache). This
-// module just does one probe, synchronously (spawnSync), and is
-// intentionally side-effect free.
+// module just does one probe and is intentionally side-effect free.
+// The sync probes serve one-shot callers; the TUI's periodic refresh
+// uses the async twins so `git status` never blocks its event loop.
 
-import { spawnSync } from 'node:child_process';
+import { execFile, spawnSync } from 'node:child_process';
 import type { DirtyCount, AheadBehind } from './types.js';
 import { CLEAN_DIRTY } from './types.js';
 
@@ -26,6 +27,23 @@ export function probeDirty(cwd: string, timeoutMs = 5_000): DirtyCount {
   return parsePorcelain(res.stdout);
 }
 
+/** Run git without blocking the caller's event loop; null on failure. */
+function execGit(cwd: string, args: string[], timeoutMs: number, maxBuffer: number): Promise<string | null> {
+  return new Promise((resolveOut) => {
+    try {
+      execFile('git', args, { cwd, encoding: 'utf8', timeout: timeoutMs, maxBuffer }, (error, stdout) => {
+        resolveOut(error ? null : String(stdout ?? ''));
+      });
+    } catch { resolveOut(null); }
+  });
+}
+
+/** Async twin of `probeDirty`. */
+export async function probeDirtyAsync(cwd: string, timeoutMs = 5_000): Promise<DirtyCount> {
+  const out = await execGit(cwd, ['status', '--porcelain'], timeoutMs, 2 * 1024 * 1024);
+  return out === null ? CLEAN_DIRTY : parsePorcelain(out);
+}
+
 /** Parse porcelain v1 output. Format per line:
  *
  *     XY <path>               — regular change
@@ -66,7 +84,17 @@ export function probeAheadBehind(cwd: string, timeoutMs = 5_000): AheadBehind |
     { cwd, encoding: 'utf8', timeout: timeoutMs, maxBuffer: 64 * 1024 },
   );
   if (res.status !== 0 || res.error) return null;
-  const parts = res.stdout.trim().split(/\s+/);
+  return parseAheadBehind(res.stdout);
+}
+
+/** Async twin of `probeAheadBehind`. */
+export async function probeAheadBehindAsync(cwd: string, timeoutMs = 5_000): Promise<AheadBehind | null> {
+  const out = await execGit(cwd, ['rev-list', '--left-right', '--count', '@{u}...HEAD'], timeoutMs, 64 * 1024);
+  return out === null ? null : parseAheadBehind(out);
+}
+
+function parseAheadBehind(out: string): AheadBehind | null {
+  const parts = out.trim().split(/\s+/);
   if (parts.length < 2) return null;
   const behind = Number.parseInt(parts[0]!, 10);
   const ahead = Number.parseInt(parts[1]!, 10);

package/src/git-fs/index.ts

@@ -13,7 +13,7 @@ import { spawnSync } from 'node:child_process';
 import { findGitDir, type LocatedGit } from './locate.js';
 import { readGitHead } from './read-head.js';
 import { GitFileWatcher } from './watcher.js';
-import { probeDirty, probeAheadBehind } from './dirty.js';
+import { probeDirty, probeAheadBehind, probeDirtyAsync, probeAheadBehindAsync } from './dirty.js';
 import { debug } from '../debug/log.js';
 import type {
   GitHeadInfo,
@@ -170,6 +170,47 @@ export function refreshDirty(
   };
 }
 
+const dirtyInFlight = new Map<CacheEntry, Promise<GitStatusView>>();
+
+function viewOf(entry: CacheEntry): GitStatusView {
+  return { head: entry.head, dirty: entry.dirty, aheadBehind: entry.aheadBehind, lastDirtyProbeAt: entry.lastDirtyProbeAt };
+}
+
+/** Non-blocking twin of `refreshDirty` for the TUI: the probes run as
+ *  async subprocesses so a slow `git status` (large worktree, loaded
+ *  host) never stalls key input. Same throttle; concurrent calls share
+ *  one probe, except that `force` (a known write just happened) never
+ *  reuses a probe that started before it. */
+export function refreshDirtyAsync(
+  cwd: string,
+  opts: { minIntervalMs?: number; force?: boolean } = {},
+): Promise<GitStatusView> {
+  let entry: CacheEntry | null;
+  try { entry = ensureEntry(cwd); } catch (error) { return Promise.reject(error); }
+  if (!entry) return Promise.resolve({ head: null, dirty: null, aheadBehind: null, lastDirtyProbeAt: 0 });
+  // An in-flight probe (possibly a forced, post-write one) is newer than the last stored view.
+  const running = dirtyInFlight.get(entry);
+  if (running && !opts.force) return running;
+  const min = opts.minIntervalMs ?? 2_000;
+  if (!opts.force && entry.lastDirtyProbeAt > 0 && Date.now() - entry.lastDirtyProbeAt < min) {
+    return Promise.resolve(viewOf(entry));
+  }
+  const target = entry;
+  const root = target.located.root;
+  const start = (): Promise<GitStatusView> => Promise.all([probeDirtyAsync(root), probeAheadBehindAsync(root)])
+    .then(([dirty, aheadBehind]) => {
+      target.dirty = dirty;
+      target.aheadBehind = aheadBehind;
+      target.lastDirtyProbeAt = Date.now();
+      return viewOf(target);
+    });
+  // A forced probe queues behind the running one so it reads the post-write tree.
+  const probe = (running ? running.then(start, start) : start())
+    .finally(() => { if (dirtyInFlight.get(target) === probe) dirtyInFlight.delete(target); });
+  dirtyInFlight.set(target, probe);
+  return probe;
+}
+
 /** Claude Code-style git snapshot for LLM system context.
  *  This is intentionally a point-in-time summary: good enough for
  *  baseline repo awareness, but callers should still use tools for
@@ -256,4 +297,5 @@ export function __resetGitFsCache(): void {
   for (const [, entry] of cache) entry.watcher.dispose();
   cache.clear();
   clearGitSnapshotCache();
+  dirtyInFlight.clear();
 }

package/src/github/remote-call.ts

@@ -0,0 +1,81 @@
+import { debug } from '../debug/log.js';
+
+/** One measured execution at a GitHub boundary. Never put an URL, arguments, token, or body here. */
+export interface GithubRemoteCall {
+  kind: 'rest' | 'graphql' | 'gh-command' | 'git-clone' | 'git-fetch' | 'git-push';
+  caller: string;
+  route: string;
+  method?: string;
+  host: string;
+  scopeId?: string;
+  runId?: string;
+  retry?: number;
+}
+
+export interface GithubRemoteOutcome<T> {
+  failed: boolean;
+  result?: T;
+  error?: unknown;
+}
+
+export interface GithubRemoteCallOptions<T> {
+  /** Return an observed HTTP status only; CLI success alone is not HTTP 200. */
+  status?: (outcome: GithubRemoteOutcome<T>) => number | undefined;
+  now?: () => number;
+  emit?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+/** Execute the real call and record exactly one completion, including failures. Observation cannot change the result. */
+export async function runGithubRemoteCall<T>(
+  call: GithubRemoteCall,
+  execute: () => Promise<T>,
+  options: GithubRemoteCallOptions<T> = {},
+): Promise<T> {
+  const now = options.now ?? Date.now;
+  const safeNow = (): number | undefined => {
+    try { const value = now(); return Number.isFinite(value) ? value : undefined; } catch { return undefined; }
+  };
+  const started = safeNow();
+  let outcome: GithubRemoteOutcome<T> = { failed: false };
+  try {
+    const result = await execute();
+    outcome = { failed: false, result };
+    return result;
+  } catch (error) {
+    outcome = { failed: true, error };
+    throw error;
+  } finally {
+    let status: number | undefined;
+    try { status = options.status?.(outcome); } catch { /* telemetry must not alter the call */ }
+    const ended = safeNow();
+    const data: Record<string, unknown> = {
+      kind: call.kind,
+      caller: call.caller,
+      route: call.route,
+      method: call.method ?? 'unmeasured',
+      host: call.host,
+      scopeId: call.scopeId ?? 'unmeasured',
+      runId: call.runId ?? '',
+      retry: call.retry ?? 'unmeasured',
+      status: status ?? 'unmeasured',
+      ok: !outcome.failed,
+      durationMs: started === undefined || ended === undefined ? 'unmeasured' : Math.max(0, ended - started),
+    };
+    try { (options.emit ?? debug.log.bind(debug))('github.transport', 'complete', data); } catch { /* same rule */ }
+  }
+}
+
+/** Only a real GitHub remote belongs in the Git transport denominator. */
+export function isGithubGitRemote(remote: string): boolean {
+  let host: string | undefined;
+  if (remote.includes('://')) {
+    try {
+      const url = new URL(remote);
+      if (!['http:', 'https:', 'ssh:', 'git:'].includes(url.protocol)) return false;
+      host = url.hostname;
+    } catch { return false; }
+  } else {
+    host = /^(?:[^@\s]+@)?([^:/\s]+):[^\s]+$/.exec(remote)?.[1];
+  }
+  return host === 'github.com' || host === 'ssh.github.com';
+}

package/src/goals/registry.ts

@@ -75,8 +75,18 @@ export function hydrateGoalFromSnapshot(): Goal | null {
       persistSnapshot(null);
       return null;
     }
-    current = parsed;
-    debug.log('goal', 'snapshot.hydrated', { id: current.id, status: current.status });
+    // TUI-GOAL-LOOP-FRICTION(#35) — 프로세스가 죽어 있던 시간은 이 목표가 «돈» 시간이 아니다.
+    //   active 로 되살아나면 벽시계 기준을 지금으로 다시 잡는다(낡은 createdAt 기준 4.9억 ms 소진 오판 방지).
+    const now = Date.now();
+    const staleStart = goalWallClockStart(parsed);
+    current = parsed.status === 'active'
+      ? { ...parsed, activeSince: now, usage: { ...parsed.usage, elapsedMs: 0 } }
+      : parsed;
+    debug.log('goal', 'snapshot.hydrated', {
+      id: current.id, status: current.status,
+      wallClockRestarted: parsed.status === 'active',
+      staleElapsedMs: Math.max(0, now - staleStart),
+    });
     notify(current, null);
     return getCurrentGoal();
   } catch (error) {
@@ -100,12 +110,25 @@ export function generateGoalId(): string {
   return `g-${ts}-${rand}`;
 }
 
+/** TUI-GOAL-LOOP-FRICTION(#35) — 벽시계 예산의 기준 시각 = 이번에 active 로 들어선 때.
+ *  옛 스냅숏(activeSince 없음)만 createdAt 으로 떨어진다. */
+export function goalWallClockStart(goal: Goal): number {
+  return typeof goal.activeSince === 'number' && Number.isFinite(goal.activeSince)
+    ? goal.activeSince
+    : goal.createdAt;
+}
+
+/** 이번 활성화 기준 벽시계 경과(ms). 시계가 거꾸로 가도 음수는 내지 않는다. */
+export function goalWallClockElapsedMs(goal: Goal, now: number): number {
+  return Math.max(0, now - goalWallClockStart(goal));
+}
+
 export function getCurrentGoal(): Goal | null {
   if (!current) return null;
   // Refresh elapsed ms on read so callers don't see stale values.
   return {
     ...current,
-    usage: { ...current.usage, elapsedMs: Date.now() - current.createdAt },
+    usage: { ...current.usage, elapsedMs: goalWallClockElapsedMs(current, Date.now()) },
   };
 }
 
@@ -155,6 +178,7 @@ export function startGoal(input: GoalCreateInput): { ok: true; goal: Goal } | {
     status: 'active',
     createdAt: now,
     updatedAt: now,
+    activeSince: now,
     budget,
     usage: { turnsUsed: 0, tokensUsed: 0, tokensMeasured: true, elapsedMs: 0 },
     linkedTaskId: input.linkedTaskId,
@@ -173,8 +197,22 @@ export function setStatus(next: GoalStatus, reason?: string): { ok: true; goal:
     return { ok: false, error: { code: 'GoalNotFound', message: 'No active goal.' } };
   }
   const prev = { ...current };
-  current = { ...current, status: next, updatedAt: Date.now() };
+  const now = Date.now();
+  // TUI-GOAL-LOOP-FRICTION(#35) — paused·budget-limited·resume_required → active 는 «새 활성화»다.
+  //   벽시계는 여기서 다시 잰다 — 멈춰 있던 시간(며칠)을 이번 실행 예산에 싣지 않는다.
+  const reactivated = next === 'active' && prev.status !== 'active';
+  current = {
+    ...current,
+    status: next,
+    updatedAt: now,
+    ...(reactivated ? { activeSince: now, usage: { ...current.usage, elapsedMs: 0 } } : {}),
+  };
   debug.log('goal', 'status', { id: current.id, from: prev.status, to: next, reason: reason ?? '' });
+  if (reactivated) {
+    debug.log('goal', 'wall-clock-restart', {
+      id: current.id, from: prev.status, priorElapsedMs: goalWallClockElapsedMs(prev, now),
+    });
+  }
   try {
     writeGoalTransitionLedger({
       timestamp: new Date().toISOString(),
@@ -210,7 +248,7 @@ export function recordTurn(opts: { tokens?: number; verdict?: Goal['lastVerdict'
       turnsUsed: current.usage.turnsUsed + 1,
       tokensUsed: current.usage.tokensUsed + (opts.tokens ?? 0),
       tokensMeasured: current.usage.tokensMeasured && opts.tokens !== undefined,
-      elapsedMs: Date.now() - current.createdAt,
+      elapsedMs: goalWallClockElapsedMs(current, Date.now()),
     },
     lastVerdict: opts.verdict ?? current.lastVerdict,
     lastSummary: opts.summary ?? current.lastSummary,
@@ -251,7 +289,9 @@ const NO_GOAL_BUDGET_DIAGNOSTICS: GoalBudgetDiagnostics = {
 export function evaluateGoalBudget(goal: Goal, now: number): GoalBudgetDiagnostics {
   const { turnsUsed, tokensUsed, elapsedMs, tokensMeasured } = goal.usage;
   const { maxTurns, tokenBudget, wallClockMaxMs } = goal.budget;
-  const elapsedWallClockMs = Math.max(elapsedMs, now - goal.createdAt);
+  // TUI-GOAL-LOOP-FRICTION(#35) — 기준 = 이번 활성화 시작(activeSince · 옛 스냅숏만 createdAt).
+  //   usage.elapsedMs 도 같은 기준으로만 쓰인다(재활성화·hydrate 때 0 으로 되돌린다).
+  const elapsedWallClockMs = Math.max(elapsedMs, goalWallClockElapsedMs(goal, now));
   const exceededAxes = [
     ...(turnsUsed >= maxTurns ? [{ axis: 'maxTurns' as const, used: turnsUsed, limit: maxTurns }] : []),
     ...(tokenBudget > 0 && tokensUsed >= tokenBudget

package/src/goals/types.ts

@@ -69,7 +69,8 @@ export interface GoalUsage {
   tokensUsed: number;
   /** Whether every recorded auto-turn supplied a token measurement. */
   tokensMeasured: boolean;
-  /** Wall-clock since createdAt, refreshed on read. */
+  /** Wall-clock since this activation began (`activeSince`, falling back to
+   *  `createdAt` for old snapshots), refreshed on read. */
   elapsedMs: number;
 }
 
@@ -97,6 +98,11 @@ export interface Goal {
   status: GoalStatus;
   /** Epoch ms. */
   createdAt: number;
+  /** TUI-GOAL-LOOP-FRICTION(#35) — epoch ms when the goal last entered `active`
+   *  (start · resume · process restart hydrate). The wall-clock budget is measured
+   *  from here, not from `createdAt`: a goal created days ago and resumed now must
+   *  not report 4.9e8 ms elapsed. Optional so older snapshots still parse. */
+  activeSince?: number;
   /** Last time status transitioned. */
   updatedAt: number;
   budget: GoalBudget;

package/src/graph-runner/runner.ts

@@ -34,6 +34,7 @@ const RELEASE_NODE_COMMANDS: Readonly<Record<string, { recipe: string; command?:
   'checklist-gate': { recipe: 'cmd:checklist-gate', command: 'bun scripts/release-loop/checklist-gate-node.ts' },
   prefetch: { recipe: 'cmd:docs', command: 'bun scripts/release-loop/docs-node.ts --json' },
   gate: { recipe: 'cmd:gate', command: 'bun scripts/release-loop/gate-node.ts --json' },
+  'gate-triage': { recipe: 'cmd:gate-triage', command: 'bun scripts/release-loop/gate-triage-node.ts' },
   'mac-smoke': { recipe: 'cmd:mac-smoke', command: 'bun scripts/release-loop/mac-smoke-node.ts' },
   'export-check': { recipe: 'cmd:export-check', command: 'bun scripts/release-loop/export-check-node.ts' },
   pwa: { recipe: 'cmd:pwa', command: 'bun scripts/release-loop/node-verdict.ts pwa' },
@@ -53,6 +54,7 @@ const RELEASE_NODE_COMMANDS: Readonly<Record<string, { recipe: string; command?:
   'release-story': { recipe: 'cmd:release-story', command: 'bun scripts/release-story/draft.ts --graph' },
   'ops-upgrade': { recipe: 'cmd:ops-upgrade', command: 'bun scripts/release-loop/ops-upgrade-node.ts' },
   'version-dev-bump': { recipe: 'cmd:version-dev-bump', command: 'bun scripts/release-loop/version-node.ts dev-bump --json' },
+  'version-dev-bump-after-failure': { recipe: 'cmd:version-dev-bump', command: 'bun scripts/release-loop/version-node.ts dev-bump --json' },
   done: { recipe: 'none' },
   failed: { recipe: 'none' },
 };

package/src/grok/credential.ts

@@ -478,6 +478,32 @@ export function isGrokSubscriptionExpiring(
   return (opts.now ?? Date.now)() + (opts.bufferMs ?? GROK_REFRESH_BUFFER_MS) >= ms;
 }
 
+/** 구독 만료 상태 — 칸 CRED-EXPIRY-REFRESH 기준 창. 이 안에 만료가 오면 갱신 후보다. */
+export const GROK_EXPIRY_SOON_WINDOW_MS = 2 * 60 * 60 * 1000;
+
+/** 만료 상태 셋 — ⛔ boolean 으로 접으면 「모름」과 «여유»가 «같은 값»이 된다. */
+export type GrokSubscriptionExpiryState = 'healthy' | 'expiring' | 'unknown';
+
+/** 실제로 쓸 구독(key 를 가진 scope 중 가장 늦게 만료되는 것)의 expires_at 만으로 상태를 가른다.
+ *
+ * ⭐ 칸 CRED-EXPIRY-REFRESH 첫 조각 — «토큰 없이» 읽는다:
+ *   · 선택 규칙은 `readSubscriptionToken` 과 «같다»(key 없는 항목의 만료에 속지 않는다).
+ *   · 반환은 상태 «하나»뿐 — 토큰 값은 어떤 형태로도 나가지 않는다.
+ *   · 기존 `isGrokSubscriptionExpiring`(boolean)은 모름을 false 로 접는다 — 이 함수는
+ *     모름을 'unknown' 으로 «별도의 값»으로 낸다. 갱신 유도·호스트 발사는 후속 조각.
+ * · 순수 판정 — 부수효과가 없고, 파일이 못 읽히면 죽이지 않고 'unknown' 을 낸다. */
+export function grokSubscriptionExpiryState(
+  opts: { home?: string; bufferMs?: number; now?: () => number } = {},
+): GrokSubscriptionExpiryState {
+  const raw = readSubscriptionToken(grokAuthFilePath(opts.home))?.expiresAt ?? null;
+  if (raw === null) return 'unknown';
+  const ms = Date.parse(raw);
+  if (!Number.isFinite(ms)) return 'unknown';
+  return (opts.now ?? Date.now)() + (opts.bufferMs ?? GROK_EXPIRY_SOON_WINDOW_MS) >= ms
+    ? 'expiring'
+    : 'healthy';
+}
+
 /** 갱신 경로의 관측 — ⛔ 토큰은 «절대» 싣지 않는다(판정·결과·출처만). */
 function observeGrokAuth(event: string, data: Record<string, unknown>): void {
   try {

package/src/harness/harness-clean.ts

@@ -5,6 +5,7 @@
 // planHarnessClean = 순수 분류(테스트). execHarnessClean = git/gh IO + 실제 제거.
 
 import { spawnSync } from 'node:child_process';
+import { SPAWN_SYNC_MAX_BUFFER } from '../util/spawn-sync-output.js';
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { listPtyManifest, type PtyManifestRow } from '../pty-shell/pty-manifest.js';
@@ -466,7 +467,7 @@ export type { GitRunner, GitRunResult } from '../git-fs/retry.js';
 
 const defaultGitRunner: GitRunner = (args) => {
   // git-spawn-allow: This is the injected low-level runner consumed by direct runGitWithRetry callers; routing it through runGitCommand would recurse through the retry seam.
-  const r = spawnSync('git', args, { encoding: 'utf8', timeout: 20_000 });
+  const r = spawnSync('git', args, { encoding: 'utf8', timeout: 20_000, maxBuffer: SPAWN_SYNC_MAX_BUFFER });
   return { status: r.status, stdout: r.stdout ?? '', stderr: r.stderr ?? '' };
 };