elanous 0.2.29 → 0.2.31

package/src/dashboard/slash-runtime/help-from-registry.ts

@@ -16,7 +16,8 @@ const ESSENTIAL_KEYS = [
   ['Home / End', 'Move to start / end of line'],
   ['Ctrl+A / E', 'Move to start / end of line'],
   ['PgUp / PgDn', 'Scroll chat log'],
-  ['Ctrl+↑', 'Recall a queued line (Enter while answering queues it)'],
+  // 10-14 — 줄 수는 그대로(행 예산) · 큐는 다음 도구 경계에 들어가고, 빈 Enter 가 «지금 밀어 넣기»다.
+  ['Ctrl+↑', 'Recall all queued lines (Enter while answering queues · empty Enter pushes now)'],
 ] as const;
 
 function fitLine(text: string, width: number): string {

package/src/dashboard/slash-runtime/index.ts

@@ -13,3 +13,16 @@ export {
   type SkillToolSlashExecutor,
   type SkillToolSlashResult,
 } from './dashboard-handlers.js';
+// TUI-SLASH-SPLIT-MISSION(D4b) — 새 집 src/tui/slash/mission.ts 의 공개 심볼을 옛 입구에서도 낸다(re-export shim · RFC A5).
+export {
+  handleMissionSlash,
+  registerMissionSlash,
+  type MissionSlashContext,
+} from '../../tui/slash/mission.js';
+// TUI-SLASH-SPLIT-TERM(D4b) — 새 집 src/tui/slash/term.ts 의 공개 심볼을 옛 입구에서도 낸다(re-export shim · RFC A5).
+export {
+  handleTermSlash,
+  registerTermSlash,
+  type TermSlashContext,
+  type TermSlashHost,
+} from '../../tui/slash/term.js';

package/src/dashboard/turn-busy-teardown.ts

@@ -0,0 +1,50 @@
+// ── 턴 busy 표지 마감 (TUI-STALE-BUSY-MARKER · 0.2.31 · tui-op-issues #36·#37·#45·#54·#55·#58) ──
+//
+// S: 턴이 시작되면 `streamingInFlight = true` ⊕ `reportTuiTurn('busy')` 가 켜지고, 마감 closure 가
+//    끄기 전까지 외부 입력 대기열(`isTurnActive`)·`eln pty state` 는 «바쁨»으로 본다.
+// C: 마감 closure 안의 한 단계가 던지면(10-14 «✘ 실패 line.startsWith») 끄는 줄에 못 닿아 70분+ busy 가 남았다.
+//    #27721 이 settle 단계 하나를 try/finally 로 감쌌지만, 그 «앞» 단계(키 리스너 떼기 · ESC 게이트 정리)는
+//    여전히 맨몸이었다 — 거기서 던지면 키 층은 유휴(리스너 떨어짐)·턴 층은 busy 인 이원 판정이 그대로 재현된다.
+//    그리고 실패는 `dashboard.turn settle-failed` 한 곳에서만 보였다(#58 — 턴 본문 실패는 tui 범주 0).
+// A: 마감 단계마다 이 함수로 격리해 «다음 단계 ⊕ idle 전이»가 반드시 돌게 하고,
+//    던진 것은 한 범주 `tui.turn turn-threw {error, phase}` 로 남긴다.
+
+import { debug, redactSecretText } from '../debug/log.js';
+
+/** 4번째 인자로 `{ level: 'warn' }` 를 받는다 — 주입 기록기도 warn 수준을 그대로 넘겨야 한다(#58). */
+export type TurnThrewLog = (
+  category: string,
+  event: string,
+  payload: Record<string, unknown>,
+  opts?: { level?: 'warn' },
+) => void;
+
+const ERROR_HEAD_CHARS = 200;
+
+const warnLog: TurnThrewLog = (category, event, payload, opts) => debug.log(category, event, payload, opts);
+
+/** 턴 경로에서 던진 것을 한 범주로 남긴다(warn — #58 «warn/error 0» 의 몫). 관측 실패가 턴 마감을 막지 않는다. */
+export function logTurnThrew(phase: string, err: unknown, log: TurnThrewLog = warnLog): void {
+  try {
+    const message = err instanceof Error ? err.message : String(err);
+    const stackHead = err instanceof Error
+      ? err.stack?.split('\n').slice(1, 3).map((line) => line.trim()).join(' | ')
+      : undefined;
+    log('tui.turn', 'turn-threw', {
+      error: redactSecretText(message).slice(0, ERROR_HEAD_CHARS),
+      phase,
+      ...(stackHead ? { stackHead: redactSecretText(stackHead) } : {}),
+    }, { level: 'warn' });
+  } catch { /* fail-soft — 관측이 마감을 막지 않는다 */ }
+}
+
+/** 턴 마감의 한 단계 — 던져도 삼키고 `turn-threw` 로 남긴다. 다음 단계·idle 전이는 계속 돈다. */
+export function runTurnTeardownStep(phase: string, step: () => void, log?: TurnThrewLog): boolean {
+  try {
+    step();
+    return true;
+  } catch (err) {
+    logTurnThrew(phase, err, log);
+    return false;
+  }
+}

package/src/decisions/decision-ledger.ts

@@ -7,6 +7,7 @@ import { createVersionResolver, type VersionOptions, type Versions } from '../di
 import { getUserConfig } from '../user-config.js';
 import { registeredSeats, resolveSeat } from '../seat-address/seat-address.js';
 import { isSeatId } from '../seat-dispatch/seat-questions.js';
+import { openMsgStore } from '../msg/msg-store.js';
 
 export type DecisionCategory = 'secret' | 'publish' | 'money' | 'security' | 'scope' | 'irreversible' | 'other';
 /** Old track letters (S·T·F·O) stay readable; seat names (OP·MK·TC·UX) are the current identities. */
@@ -42,10 +43,22 @@ export interface SeatDecisionRecord {
 }
 export type SeatDecisionInput = Pick<SeatDecisionRecord, 'title' | 'decision' | 'seat' | 'delegation' | 'refs'> & { decidedAt?: string };
 type Event = { type: 'raised'; entry: DecisionEntry } | { type: 'seat-recorded'; entry: SeatDecisionRecord } | { type: 'options-added'; id: string; at: string; options: DecisionOption[]; by: string } | { type: 'decided'; id: string; at?: string; by: DecisionActor; choice?: string; version?: Versions; note?: string } | { type: 'withdrawn'; id: string; at: string; reason: string; version: Versions };
-export interface DecisionLedgerOptions extends VersionOptions { stateDir?: string; now?: () => Date; resolveVersion?: (at: string) => Versions; writeAnswer?: typeof writePendingQuestionAnswer }
+export interface DecisionLedgerOptions extends VersionOptions { stateDir?: string; now?: () => Date; resolveVersion?: (at: string) => Versions; writeAnswer?: typeof writePendingQuestionAnswer; postDecisionNotice?: (entry: DecisionEntry, stateDir: string, seat: string) => number }
 
 /** null = the decision resumes no run; otherwise whether the answer file was written (or already matched). */
 export type AnswerDelivery = null | { ok: true; questionId: string } | { ok: false; questionId: string; reason: string };
+export type DecisionNotice = { status: 'skipped' } | { status: 'sent'; seat: string; messageId: number } | { status: 'failed'; seat: string; reason: string };
+
+function postDecisionNotice(entry: DecisionEntry, stateDir: string, seat: string): number {
+  const selected = entry.options.find(option => option.key === entry.choice);
+  if (!selected || !entry.choice) throw new Error('recorded choice not found');
+  const recommendedWhy = 'option' in entry.recommendation && entry.recommendation.option === entry.choice ? entry.recommendation.why : undefined;
+  const rationale = (entry.note ?? recommendedWhy ?? entry.scqa.c).replace(/\s+/g, ' ').trim();
+  const body = `**[OP]** 결정 ${entry.id} · ${entry.title} · 선택 ${entry.choice}: ${selected.label} · 근거 ${rationale}`;
+  const store = openMsgStore(join(stateDir, 'msg', 'messages.db'));
+  try { return store.appendWithProvenance({ from: 'OP', to: seat, kind: 'info', body }, `decision:${entry.id}:${seat}`).id; }
+  finally { store.close(); }
+}
 
 /** The decision is durable even when delivery fails; retryAnswer(id) only retries delivery. */
 export class DecisionAnswerDeliveryError extends Error {
@@ -144,6 +157,7 @@ export class DecisionLedger {
   private readonly lockPath: string;
   private readonly now: () => Date;
   private readonly writeAnswer: typeof writePendingQuestionAnswer;
+  private readonly postDecisionNotice: NonNullable<DecisionLedgerOptions['postDecisionNotice']>;
   private readonly stateDir: string;
   private versionResolver?: (at: string) => Versions;
   private readonly versionOptions: DecisionLedgerOptions;
@@ -153,6 +167,7 @@ export class DecisionLedger {
     this.lockPath = `${this.path}.lock`;
     this.now = options.now ?? (() => new Date());
     this.writeAnswer = options.writeAnswer ?? writePendingQuestionAnswer;
+    this.postDecisionNotice = options.postDecisionNotice ?? postDecisionNotice;
     this.versionOptions = options;
     this.versionResolver = options.resolveVersion;
   }
@@ -300,13 +315,13 @@ export class DecisionLedger {
     return entry;
   }
   /** Record the decision and say whether its answer reached the waiting run (null = the decision resumes nothing). */
-  decideWithDelivery(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): { entry: DecisionEntry; delivery: AnswerDelivery } {
+  decideWithDelivery(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): { entry: DecisionEntry; delivery: AnswerDelivery; notice: DecisionNotice } {
     return this.decideLocked(id, choice, by, note, decidedAt);
   }
   decide(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): DecisionEntry {
     return this.decideLocked(id, choice, by, note, decidedAt).entry;
   }
-  private decideLocked(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): { entry: DecisionEntry; delivery: AnswerDelivery } {
+  private decideLocked(id: string, choice: string, by: DecisionActor, note?: string, decidedAt?: string): { entry: DecisionEntry; delivery: AnswerDelivery; notice: DecisionNotice } {
     if (!by || (by.kind !== 'human' && by.kind !== 'auto')) throw new Error('decidedBy is required');
     if (by.kind === 'auto') {
       single(by.delegation, 'delegation'); single(by.agent, 'agent');
@@ -322,9 +337,35 @@ export class DecisionLedger {
       this.append({ type: 'decided', id, at, by, choice, version: this.version(at), ...(note ? { note: safe(single(note, 'note')) } : {}) });
       debug.log('decisions', 'decided', { id, category: old.category, by: by.kind });
       const decided = this.show(id);
-      return { entry: decided, delivery: this.deliverAnswer(decided) };
+      return { entry: decided, delivery: this.deliverAnswer(decided), notice: this.notifyDecided(decided) };
+    });
+  }
+  /** Retry only the seat notice; the message provenance key prevents duplicate delivery. */
+  retryNotice(id: string): DecisionNotice {
+    return this.locked(() => {
+      const entry = this.show(id);
+      if (entry.status !== 'decided') throw new Error(`decision is not decided: ${id}`);
+      return this.notifyDecided(entry);
     });
   }
+  private notifyDecided(entry: DecisionEntry): DecisionNotice {
+    const track = entry.raisedBy.track;
+    if (!track) return { status: 'skipped' };
+    const seat = resolveSeat(track)?.id;
+    if (!seat) {
+      debug.log('decisions', 'decided-notify-unknown-seat', { id: entry.id, track });
+      return { status: 'failed', seat: track, reason: '올린 자리 미상' };
+    }
+    try {
+      const messageId = this.postDecisionNotice(entry, this.stateDir, seat);
+      debug.log('decisions', 'decided-notify-sent', { id: entry.id, seat, messageId });
+      return { status: 'sent', seat, messageId };
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      debug.log('decisions', 'decided-notify-failed', { id: entry.id, seat, reason });
+      return { status: 'failed', seat, reason };
+    }
+  }
   /** Retry delivery of the recorded choice without adding another decided event or changing its actor/note. */
   retryAnswer(id: string): DecisionEntry {
     return this.locked(() => {

package/src/discord-self-message.ts

@@ -66,7 +66,7 @@ import { localOcrText } from './telegram-card-followup.js';
 import type { runGraph } from './graph-runner/runner.js';
 import { readSlashContextNow, renderContextFirstNow, renderTelegramNow } from './context-bus/context-now-surfaces.js';
 import { contextNow, type ContextNowDeps } from './context-bus/context-now.js';
-import { createContextFirstGate, renderContextFirst } from './context-bus/context-first.js';
+import { createContextFirstGate, renderContextFirst, takeContextFirstOpening } from './context-bus/context-first.js';
 import { telegramLoopsStatus, type LoopsSources } from './telegram-loops-command.js';
 import { botUnavailableSlashReply, deriveTuiSlashAvailability, type TuiSlashAvailability } from './maturity/tui-slash-availability.js';
 
@@ -157,8 +157,8 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
   const log = deps.log ?? ((): void => {});
   const cfg = deps.userConfig;
   const contextFirstGate = createContextFirstGate({ now: deps.contextFirstNow ?? Date.now });
-  const maybeSendContextFirst = async (channelId: string): Promise<void> => {
-    if (!contextFirstGate.take(channelId) || cfg.discord?.contextFirst === false) return;
+  const maybeSendContextFirst = async (channelId: string, text?: string): Promise<void> => {
+    if (!takeContextFirstOpening({ gate: contextFirstGate, key: channelId, text, enabled: cfg.discord?.contextFirst !== false })) return;
     try {
       await deps.getBot()?.sendMessage(channelId, renderContextFirst(contextNow, deps.nowDeps, renderContextFirstNow));
     } catch (err) {
@@ -426,7 +426,7 @@ export function buildDiscordSelfOnMessage(deps: DiscordSelfMessageDeps): DcMessa
       if (unavailable) return unavailable;
     }
     const cmd = parseDiscordAcpCommand(ctx.text);
-    if (!cmd && !/^[!/]/.test(ctx.text.trim())) await maybeSendContextFirst(ctx.channelId);
+    if (!cmd && !/^[!/]/.test(ctx.text.trim())) await maybeSendContextFirst(ctx.channelId, ctx.text);
     log(`◀ ${ctx.userName ?? ctx.userId}: ${ctx.text.slice(0, 80)}${ctx.attachments.length ? ` (+첨부 ${ctx.attachments.length})` : ''}`);
     debug.log('discord.self.turn', 'inbound', { channelId: ctx.channelId, chars: ctx.text.length, attachments: ctx.attachments.length });
     // C2+ — 첨부 기억(사진만 먼저 올리는 패턴 지원). 명령 여부와 무관.

package/src/domains/release-tool.ts

@@ -122,7 +122,24 @@ 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 중 하나');
   if (args.topic !== undefined && args.action !== undefined) {

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/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' },

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 ?? '' };
 };