elanous 0.2.28 → 0.2.29

package/src/dashboard/turn-preamble.ts

@@ -18,6 +18,7 @@ import type { ModelFamily } from '../models/prompts.js';
 import { debug } from '../debug/log.js';
 import type { NativeToolCatalogEntry } from '../native-tool-catalog.js';
 import { buildUniversalPreamble } from '../prompt-library/universal-preamble.js';
+import { buildSeatBootSystemMessages, type SeatBootDeps } from './seat-boot-preamble.js';
 import { buildPlanModeSystemMessages } from '../plan-mode/system-prompt.js';
 import { buildImplDisciplineSystemMessages } from '../impl-discipline/index.js';
 import { buildConcisenessSystemMessages } from '../prompt-library/chat-conciseness.js';
@@ -29,7 +30,8 @@ import {
 import { buildExecutionAskSystemMessages } from '../ask-user-question/index.js';
 import { buildApprovalPolicySystemMessages } from '../code-edit/index.js';
 import { buildSandboxEscalationSystemMessages } from '../shell-primitive/index.js';
-import { elanousSelfAccessPrompt, elanousSelfAmbientParts } from '../agent/self-ambient.js';
+import { elanousSelfAccessPrompt, investigationRecallAmbient } from '../agent/self-ambient.js';
+import { sessionMemoryLayer, sessionSelfAmbientParts } from './turn-session-layers.js';
 import { localRefGroundingAmbient } from '../agent/ref-grounding.js';
 import {
   globalTaskNotificationQueue,
@@ -66,9 +68,14 @@ export interface DashboardTurnPreambleContext {
    *  one-liner directives (e.g. AskUserQuestion → use for tool-deny
    *  clarification). Pass `tools.map(t => t.name)` from the caller. */
   enabledTools?: readonly string[];
+  /** 🪪 L1 자리 부트 카드를 싣나(`seat-boot-preamble.ts`). 대화형 TUI 호출부만 켠다 — 기본 꺼짐이라
+   *  다른 호출부·시험은 셸의 `COORD_ID` 에 따라 출력이 갈리지 않는다. */
+  seatBoot?: boolean | SeatBootDeps;
   /** Explicit controller provenance for tests and embedded callers. When
    *  omitted, the controller environment is used. */
   controlEnv?: { controller?: string; channels?: string };
+  /** File-memory layer seam: a store root and env for scope resolution (tests), or false to omit it. */
+  memory?: { root?: string; env?: NodeJS.ProcessEnv } | false;
 }
 
 export function buildControllerSystemMessage(controller: string, channels?: string): LLMMessage {
@@ -91,10 +98,22 @@ export function buildDashboardTurnPreamble(
     ...(ctx.modelFamily !== undefined ? { modelFamily: ctx.modelFamily } : {}),
     ...(ctx.enabledTools !== undefined ? { enabledTools: ctx.enabledTools } : {}),
   });
+  // 🪪 L1 — 자리 부트 카드(세션마다 한 번 만든 스냅샷). 정체성(앵커) 바로 뒤. 자리가 아니면 [].
+  const seatBootSystemMsgs = ctx.seatBoot
+    ? buildSeatBootSystemMessages(
+      { cwd: ctx.cwd, ...(ctx.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}) },
+      ctx.seatBoot === true ? {} : ctx.seatBoot,
+    )
+    : [];
   const planModeSystemMsgs = buildPlanModeSystemMessages();
   const askSystemMsgs = buildExecutionAskSystemMessages() as LLMMessage[];
   const approvalSystemMsgs = buildApprovalPolicySystemMessages() as LLMMessage[];
   const sandboxSystemMsgs = buildSandboxEscalationSystemMessages() as LLMMessage[];
+  // Session-scoped (built once, rebuilt on change) — see turn-session-layers.ts.
+  const sessionKey = ctx.sessionId ?? 'tui';
+  const memorySystemMsgs = ctx.memory === false
+    ? []
+    : sessionMemoryLayer({ sessionKey, cwd: ctx.cwd, ...(ctx.memory ?? {}) });
   const gitSnapshotSystemMsgs = buildSessionRuntimeSystemMessages({
     cwd: ctx.cwd,
   });
@@ -137,7 +156,12 @@ export function buildDashboardTurnPreamble(
   //   성립한다. fail-soft: ambient 조회 실패가 턴을 막지 않는다.
   let selfOpsSystemMsgs: LLMMessage[] = [];
   try {
-    selfOpsSystemMsgs = [elanousSelfAccessPrompt(ctx.sessionId), ...elanousSelfAmbientParts(ctx.userText), localRefGroundingAmbient(ctx.userText)]
+    selfOpsSystemMsgs = [
+      elanousSelfAccessPrompt(ctx.sessionId),
+      ...sessionSelfAmbientParts(sessionKey),
+      investigationRecallAmbient(ctx.userText),
+      localRefGroundingAmbient(ctx.userText),
+    ]
       .filter(Boolean)
       .map((content): LLMMessage => ({ role: 'system', content }));
   } catch { /* fail-soft */ }
@@ -150,10 +174,12 @@ export function buildDashboardTurnPreamble(
     : [];
   const preamble = [
     ...universalPreamble,
+    ...seatBootSystemMsgs,
     ...planModeSystemMsgs,
     ...askSystemMsgs,
     ...approvalSystemMsgs,
     ...sandboxSystemMsgs,
+    ...memorySystemMsgs,
     ...gitSnapshotSystemMsgs,
     ...surfaceSystemMsgs,
     ...selfOpsSystemMsgs,
@@ -190,10 +216,12 @@ export function buildDashboardTurnPreamble(
       rich: ctx.rich === true,
       builderCounts: {
         universal: universalPreamble.length,
+        seatBoot: seatBootSystemMsgs.length,
         planMode: planModeSystemMsgs.length,
         ask: askSystemMsgs.length,
         approval: approvalSystemMsgs.length,
         sandbox: sandboxSystemMsgs.length,
+        memory: memorySystemMsgs.length,
         gitSnapshot: gitSnapshotSystemMsgs.length,
         surface: surfaceSystemMsgs.length,
         selfOps: selfOpsSystemMsgs.length,

package/src/dashboard/turn-session-layers.ts

@@ -0,0 +1,176 @@
+// TUI-SEAT-MEMORY-SCOPE (RFC-tui-self-awareness L2 ①③) — the TUI turn preamble's session layers.
+//
+// ① File memory: until now only chat.ts (telegram · discord · repl · a2a) injected buildMemoryInjection;
+//    the TUI preamble had no memory layer at all. Here it does, scoped to global ⊕ this seat/project:
+//    a context card tagged with another seat (or another project) is left out — index line included.
+// ③ Injection cadence: the preamble is rebuilt every turn, but these layers are not. They are built once
+//    per session and rebuilt only when their source changed (file signature for memory, a short TTL
+//    plus content hash for self ambient). Unchanged layers come back byte-identical, which keeps the
+//    provider's prompt-cache prefix and skips the per-turn store reads.
+//
+// Both layers are fail-soft: an error drops the layer (observed), it never blocks the turn.
+
+import { createHash } from 'node:crypto';
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import type { LLMMessage } from '../llm.js';
+import { debug } from '../debug/log.js';
+import { buildMemoryInjection, memoryRoot, type MemoryEntry } from '../memory.js';
+import { elanousSelfAmbientParts } from '../agent/self-ambient.js';
+
+/** Token budget for the TUI memory layer — the same default chat.ts gives buildMemoryInjection. */
+export const TUI_MEMORY_BUDGET_TOKENS = 1500;
+/** How long cached self ambient is trusted before the stores are read again. */
+export const SELF_AMBIENT_TTL_MS = 60_000;
+/** Sessions remembered per cache; the least recently used one is dropped beyond this. */
+export const SESSION_LAYER_CACHE_MAX = 32;
+
+export interface MemoryScope {
+  seat?: string;
+  project?: string;
+}
+
+/** This session's seat: `/seats/<seat>` in the cwd first, then COORD_ID. Project comes only from
+ *  ELANOUS_PROJECT — a path guess would silently drop cards whose project string does not match it. */
+export function resolveMemoryScope(cwd: string, env: NodeJS.ProcessEnv = process.env): MemoryScope {
+  const fromCwd = /(?:^|\/)seats\/([^/]+)/.exec(cwd)?.[1]?.trim();
+  const seat = fromCwd || env.COORD_ID?.trim() || undefined;
+  const project = env.ELANOUS_PROJECT?.trim() || undefined;
+  return { ...(seat ? { seat } : {}), ...(project ? { project } : {}) };
+}
+
+const same = (a: string, b: string): boolean => a.trim().toLowerCase() === b.trim().toLowerCase();
+
+/** Global memories (no context card, or a card with an empty seat) stay. A card tagged with a seat
+ *  stays only for that seat; a card tagged with a project is dropped only when the scope names another one. */
+export function memoryInScope(entry: MemoryEntry, scope: MemoryScope): boolean {
+  const card = entry.contextCard;
+  if (!card) return true;
+  if (card.seat.trim() && !(scope.seat && same(card.seat, scope.seat))) return false;
+  if (card.project.trim() && scope.project && !same(card.project, scope.project)) return false;
+  return true;
+}
+
+/** This seat's own cards are injected in full, like pinned memories. */
+export function isSeatCard(entry: MemoryEntry, scope: MemoryScope): boolean {
+  const seat = entry.contextCard?.seat.trim();
+  return Boolean(seat && scope.seat && same(seat, scope.seat));
+}
+
+/** Cheap change signal for the file store: names, sizes and mtimes of its markdown files. */
+export function memoryStoreSignature(root: string): string {
+  let names: string[];
+  try { names = readdirSync(root).filter(name => name.endsWith('.md')).sort(); }
+  catch { return 'missing'; }
+  const hash = createHash('sha256');
+  for (const name of names) {
+    try {
+      const st = statSync(join(root, name));
+      hash.update(`${name}\0${st.size}\0${st.mtimeMs}\n`);
+    } catch { hash.update(`${name}\0gone\n`); }
+  }
+  return hash.digest('hex').slice(0, 16);
+}
+
+const contentHash = (text: string): string => createHash('sha256').update(text).digest('hex').slice(0, 16);
+
+interface MemoryCacheEntry { key: string; messages: LLMMessage[]; hash: string }
+interface AmbientCacheEntry { parts: string[]; hash: string; at: number }
+
+const memoryCache = new Map<string, MemoryCacheEntry>();
+const ambientCache = new Map<string, AmbientCacheEntry>();
+
+/** Map insertion order doubles as recency: re-insert on use, drop the oldest beyond the cap. */
+function remember<V>(cache: Map<string, V>, key: string, value: V): void {
+  cache.delete(key);
+  cache.set(key, value);
+  while (cache.size > SESSION_LAYER_CACHE_MAX) cache.delete(cache.keys().next().value as string);
+}
+
+/** Test seam — forget every session's cached layers. */
+export function resetTurnSessionLayers(): void {
+  memoryCache.clear();
+  ambientCache.clear();
+}
+
+export interface SessionMemoryLayerOpts {
+  sessionKey: string;
+  cwd: string;
+  root?: string;
+  env?: NodeJS.ProcessEnv;
+  maxTokens?: number;
+}
+
+/** The file-memory system message for this session. Rebuilt only when the store or the scope changed. */
+export function sessionMemoryLayer(opts: SessionMemoryLayerOpts): LLMMessage[] {
+  try {
+    const root = opts.root ?? memoryRoot();
+    const scope = resolveMemoryScope(opts.cwd, opts.env);
+    const maxTokens = opts.maxTokens ?? TUI_MEMORY_BUDGET_TOKENS;
+    const key = JSON.stringify([root, scope.seat ?? '', scope.project ?? '', maxTokens, memoryStoreSignature(root)]);
+    const cached = memoryCache.get(opts.sessionKey);
+    if (cached && cached.key === key) {
+      remember(memoryCache, opts.sessionKey, cached);
+      debug.log('chat.memory-layer', 'reused', { session: opts.sessionKey, seat: scope.seat ?? null, hash: cached.hash });
+      return cached.messages;
+    }
+    // Empty user text on purpose: keyword hits would change with every prompt and break the cached prefix.
+    // Per-prompt recall is the memory_recall tool's job (it is on every TUI route).
+    const inj = buildMemoryInjection('', {
+      maxTokens,
+      filter: entry => memoryInScope(entry, scope),
+      alwaysInject: entry => isSeatCard(entry, scope),
+    }, root);
+    const messages: LLMMessage[] = inj.block ? [{ role: 'system', content: inj.block }] : [];
+    const hash = contentHash(inj.block);
+    debug.log('chat.memory-layer', cached ? 'changed' : 'built', {
+      session: opts.sessionKey, seat: scope.seat ?? null, project: scope.project ?? null,
+      injected: inj.injectedIds.length, tokens: inj.tokens, hash,
+      ...(cached ? { previousHash: cached.hash, sameContent: cached.hash === hash } : {}),
+    });
+    // Same content (e.g. an unrelated file touched) keeps the previous array — byte-identical prefix.
+    const kept = cached && cached.hash === hash ? cached.messages : messages;
+    remember(memoryCache, opts.sessionKey, { key, hash, messages: kept });
+    return kept;
+  } catch (error) {
+    // The layer is dropped for this turn and rebuilt on the next one.
+    memoryCache.delete(opts.sessionKey);
+    debug.log('chat.memory-layer', 'failed', { session: opts.sessionKey, error: String(error) });
+    return [];
+  }
+}
+
+export interface SessionSelfAmbientOpts {
+  now?: number;
+  ttlMs?: number;
+  build?: () => string[];
+}
+
+/** The task-independent self ambient (recent changes · autonomy · ops health · mission incident),
+ *  read at most once per TTL per session. The task-dependent investigation recall stays per turn. */
+export function sessionSelfAmbientParts(sessionKey: string, opts: SessionSelfAmbientOpts = {}): string[] {
+  const now = opts.now ?? Date.now();
+  const ttl = opts.ttlMs ?? SELF_AMBIENT_TTL_MS;
+  const cached = ambientCache.get(sessionKey);
+  if (cached && now - cached.at < ttl) {
+    remember(ambientCache, sessionKey, cached);
+    return cached.parts;
+  }
+  try {
+    const parts = (opts.build ?? (() => elanousSelfAmbientParts()))();
+    const hash = contentHash(parts.join('\0'));
+    if (cached && cached.hash === hash) {
+      remember(ambientCache, sessionKey, { ...cached, at: now });
+      debug.log('chat.self-ambient', 'unchanged', { session: sessionKey, hash });
+      return cached.parts;
+    }
+    remember(ambientCache, sessionKey, { parts, hash, at: now });
+    debug.log('chat.self-ambient', cached ? 'changed' : 'built', { session: sessionKey, parts: parts.length, hash });
+    return parts;
+  } catch (error) {
+    // Fail-soft means the layer is left out, not replayed stale; the next turn reads again.
+    ambientCache.delete(sessionKey);
+    debug.log('chat.self-ambient', 'failed', { session: sessionKey, error: String(error) });
+    return [];
+  }
+}

package/src/dashboard/turn-stream-formatter.ts

@@ -166,6 +166,12 @@ export interface TurnStreamFormatter {
 export function createTurnStreamFormatter(
   deps: TurnStreamFormatterDeps,
 ): TurnStreamFormatter {
+  const groupingKind = (name: string, args: Record<string, unknown>): string | undefined => {
+    const kind = toolOperationKind(name, args);
+    return deps.foldMode === 'kind-unit' || (deps.foldMode === 'task-unit' && kind === 'RunShell')
+      ? kind
+      : undefined;
+  };
   // Per-tool-round 누적기. cross-turn 에서 이전 round 의 텍스트를
   // 가져오지 않음. clear-and-commit (onText('', '')) 또는 tool call
   // 발생 시 reset.
@@ -278,8 +284,8 @@ export function createTurnStreamFormatter(
           callId: call.id,
           lines: rendered,
           args: call.args,
-          ...(deps.foldMode === 'kind-unit'
-            ? { operationKind: toolOperationKind(call.name, call.args) }
+          ...(groupingKind(call.name, call.args)
+            ? { operationKind: groupingKind(call.name, call.args) }
             : {}),
         });
         closeRound();
@@ -293,8 +299,8 @@ export function createTurnStreamFormatter(
         callId: call.id,
         lines: [deps.muted(`${deps.brainIcon} tool: ${call.name} — running`)],
         args: call.args,
-        ...(deps.foldMode === 'kind-unit'
-          ? { operationKind: toolOperationKind(call.name, call.args) }
+        ...(groupingKind(call.name, call.args)
+          ? { operationKind: groupingKind(call.name, call.args) }
           : {}),
       });
       debug.log('dashboard.chat.generic-tool', 'formatter.genericCall', { toolName: call.name });
@@ -331,8 +337,10 @@ export function createTurnStreamFormatter(
         callId: call.id,
         collapsedLines: variants.collapsed,
         expandedLines: variants.expanded,
-        ...(deps.foldMode === 'kind-unit'
-          ? { operationKind: ('operationKind' in variants ? variants.operationKind : undefined) ?? toolOperationKind(call.name, args) }
+        ...(groupingKind(call.name, args)
+          ? { operationKind: deps.foldMode === 'task-unit'
+            ? 'RunShell'
+            : ('operationKind' in variants ? variants.operationKind : undefined) ?? toolOperationKind(call.name, args) }
           : {}),
       });
       toolArgsByCallId.delete(call.id);

package/src/dashboard/turn-stream-presentation-applier.ts

@@ -99,6 +99,13 @@ export function createTurnStreamPresentationApplier(
       switch (event.type) {
         case 'assistant.replaceBlock': {
           const beforeLen = deps.chatLines.length;
+          if (assistantStart > deps.chatLines.length) {
+            debug.log('dashboard.chat.stream', 'presentation.assistant-start-clamped', {
+              assistantStart,
+              chatLinesLen: deps.chatLines.length,
+            });
+            assistantStart = deps.chatLines.length;
+          }
           deps.chatLines.length = assistantStart;
           deps.chatLines.push(...event.lines);
           logEvent('assistant.replaceBlock', {
@@ -158,6 +165,7 @@ export function createTurnStreamPresentationApplier(
             event.expandedLines,
             event.operationKind ? { operationKind: event.operationKind } : undefined,
           );
+          assistantStart = Math.min(assistantStart, deps.chatLines.length);
           deps.renderedToolRuntime.deleteArgs(event.callId);
           logEvent('tool.replaceBlock', {
             callId: event.callId,

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: {
@@ -125,10 +125,9 @@ function cellView(item: ChecklistItem) {
 export function dispatchReleaseStatus(args: Record<string, unknown>, deps: ReleaseToolDeps = {}): { text: string; structured: Record<string, unknown> } {
   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 +148,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 +224,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 +269,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/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/graph-runner/runner.ts

@@ -53,6 +53,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' },
 };