elanous 0.2.36 → 0.2.38

package/src/session/index.ts

@@ -243,6 +243,8 @@ export interface SessionMeta {
    *  **no runtime effect today** — placeholder for schema stability so
    *  future coordinator does not require a migration pass. */
   retiredAt?: string | null;
+  /** Per-session Next TUI presentation preferences. */
+  uiState?: { sidetabOpen?: boolean };
 }
 
 /** Runtime channel attachments. Each key is optional; presence means
@@ -304,6 +306,8 @@ export interface SerializedMessage {
   toolArgs?: unknown;
   toolResult?: unknown;
   tokenEstimate?: number;
+  /** Goal-loop iteration reply, not the final assistant answer. */
+  goalInterim?: boolean;
   /** Per-turn stable identifier. Auto-populated by `appendMessage` when the
    *  caller omits it (SAM S0 seed · M1.2 narrow). The wire format stays a
    *  bare 26-char ULID; external inputs should pass through `asTurnUri()`
@@ -1513,6 +1517,8 @@ export function resolveSessionId(
   root: string = sessionRoot(),
 ): string | null {
   const idx = readIndex(root);
+  // A whole id wins even when it is also the start of a longer id — otherwise that session could never be named.
+  if (idx.some(m => m.id === prefix)) return prefix;
   const matches = idx.filter(m => m.id.startsWith(prefix));
   if (matches.length === 0) return null;
   if (matches.length > 1) {

package/src/session-runtime/index.ts

@@ -1,5 +1,6 @@
 import { buildGitSnapshot } from '../git-fs/index.js';
 import { debug } from '../debug/log.js';
+import { isResearchAgentIntent } from '../tool-hints/signals.js';
 import { resolve } from 'node:path';
 import type { ModelFamily } from '../models/prompts.js';
 import type { InputSourceKind, InputSourceRef } from '../input/input-source-kind.js';
@@ -127,6 +128,13 @@ export interface SessionTurnProfile {
   inputSourceKind: InputSourceKind | null;
 }
 
+/** A date anchor for research answers. Keep this local to the turn so a
+ *  long-lived session never presents yesterday as today's date. */
+export function buildResearchDateSystemMessage(now = new Date()): LLMMessage {
+  const localDate = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
+  return { role: 'system', content: `Current local date: ${localDate}. Verify dates in sources; do not infer freshness from an undated result.` };
+}
+
 export interface SessionModeSnapshot {
   rawMode: ChatModeState['mode'];
   activeIntent: string | null;
@@ -1702,12 +1710,20 @@ function buildEssentialSessionRuntimeToolSpecs(opts: {
         .map(tool => tool.spec)
       : [];
   });
+  // External MCP proxy runtimes are registered asynchronously by the TUI boot
+  // path and carry both `mcp` and `tui` surfaces. They are intentionally not
+  // part of the fixed built-in family allowlist above; include these explicit
+  // dynamic capabilities so ACP can advertise and dispatch their exact IDs.
+  const mcpProxySpecs = opts.runtimeTools
+    .filter(tool => tool.id.includes('.') && tool.surfaces?.includes('mcp') && tool.surfaces.includes('tui'))
+    .filter(tool => isToolAvailable(tool.spec.name, opts.toolAvailability))
+    .map(tool => tool.spec);
   const optionalByName = new Map(opts.optionalTools.map(tool => [tool.name, tool] as const));
   const optionalSpecs = ESSENTIAL_OPTIONAL_TOOL_NAMES
     .map(name => optionalByName.get(name))
     .filter((tool): tool is LLMToolSpec => !!tool)
     .filter(tool => isToolAvailable(tool.name, opts.toolAvailability));
-  return [...nativeSpecs, ...hostSpecs, ...runtimeSpecs, ...optionalSpecs];
+  return [...nativeSpecs, ...hostSpecs, ...runtimeSpecs, ...mcpProxySpecs, ...optionalSpecs];
 }
 
 export function buildSessionRuntimeToolSpecs(opts: {
@@ -2404,27 +2420,6 @@ const WEB_SEARCH_PROVIDER_TERMS = [
   'claude',
 ] as const;
 
-const DEEP_RESEARCH_INTENT_TERMS = [
-  'research',
-  'deep research',
-  'triangulate',
-  'compare sources',
-  'multiple sources',
-  'community reaction',
-  'reddit reaction',
-  'x reaction',
-  'trend',
-  'sentiment',
-  '여러 소스',
-  '깊게 조사',
-  '리서치',
-  '반응',
-  '트렌드',
-  '여론',
-  '비교 조사',
-  '교차검증',
-] as const;
-
 const WEB_FETCH_INTENT_TERMS = [
   'http://',
   'https://',
@@ -2639,7 +2634,7 @@ function hasWebSearchExposureIntent(text: string): boolean {
 }
 
 function hasResearchSearchIntent(text: string): boolean {
-  return matchesIntentLexicon(text, DEEP_RESEARCH_INTENT_TERMS);
+  return isResearchAgentIntent(text);
 }
 
 function hasWebFetchIntent(text: string): boolean {

package/src/skills/runner.ts

@@ -700,6 +700,9 @@ export interface ExecuteSkillOpts {
 export interface ExecuteSkillResult {
   provider: string;
   model: string;
+  /** Final assistant answer, without the rendered tool-call transcript. */
+  finalResponse: string;
+  /** Rendered skill transcript used by interactive surfaces. */
   fullResponse: string;
 }
 
@@ -1199,6 +1202,7 @@ async function executeSkillUnrecorded(
         return {
           provider: provider.name,
           model: modelHint || provider.defaultModel,
+          finalResponse: '',
           fullResponse: display,
         };
       }
@@ -2036,9 +2040,9 @@ async function executeSkillUnrecorded(
   return {
     provider: provider.name,
     model: modelHint || provider.defaultModel,
-    // streamLLMWithTools returns LLM text only; dashboard echo uses
-    // `display` (text + bash IO) — but callers of executeSkill rarely
-    // need the raw text so we keep the public contract stable.
+    // Keep both products: interactive surfaces need the rendered transcript,
+    // while programmatic callers (e.g. skill_exec) need only the final answer.
+    finalResponse: typeof fullResponse === 'string' ? fullResponse : '',
     fullResponse: display || fullResponse,
   };
 }

package/src/skills/tools/dev-harness.ts

@@ -383,7 +383,7 @@ export async function dispatchRunDevHarness(
   const { runStagedHarnessOnSurface } = await import('../../harness/harness-membrane.js');
   const { groundMissionInCodebase } = await import('../../autopilot/mission-codebase-gate.js'); // ★ 이식 §3.1 — 하니스 Planner grounding
   const { analyzeGoalAmbiguity } = await import('../../autopilot/mission-intake-clarify.js'); // ⓪ clarify(인터뷰·경량)
-  const { invokeResearch } = await import('../../research-bridge/invoke.js'); // ★ H3 외부 research(상황부·게이트)
+  const { runResearchQuestionLadder, researchTurnForGrounding } = await import('../../auto-research/research-turn.js'); // ★ Bloom 질문을 실제 조사 호출에 연결
   const { buildSkillHint } = await import('../../harness/skill-hint.js'); // ★ H3 skill 힌트(결정론·상황부)
   const { selectHarnessSkill } = await import('../../harness/skill-select.js'); // ★ S1 실행형(luna 주경로·substring fallback)
   const { buildAttractivenessSignal } = await import('../../harness/signal-gate.js'); // ★ R3 신호 게이트(판단층·부작용0)
@@ -532,7 +532,7 @@ export async function dispatchRunDevHarness(
     // ⓪ clarify(인터뷰·경량) — phase='scope'·heavy=false 로 과도한 조사 방지(대표 원칙: 명확하면 0질문·최상위 1개만).
     analyzeGoal: (obj) => analyzeGoalAmbiguity(obj, { phase: 'scope', heavy: false }),
     // ★ H3 외부 research(상황부) — objective 가 외부지식 요할 때만(intent-gate) web 조사 → grounding 에 얹음.
-    research: (topic) => invokeResearch(topic).then((r) => ({ ok: r.ok, output: r.output })),
+    research: (topic) => runResearchQuestionLadder(topic).then(researchTurnForGrounding),
     // ★ H3 skill 힌트(상황부) — objective 의 explicit 트리거가 특정 skill 을 강하게 가리키면 grounding 힌트
     //   (결정론·실행 안 함·luna 보완축). getSkillIndex 는 프로세스 캐시. fail-soft(index 로드 실패=null).
     skillHint: (objective) => { try { return buildSkillHint(objective, getSkillIndex()); } catch { return null; } },

package/src/skills/tools/pty.ts

@@ -149,6 +149,11 @@ export async function dispatchPtyShellStart(
   opts: PtyDispatchOpts = {},
 ): Promise<{ output: string }> {
   const args = validateStart(rawArgs);
+  // Keep the self-nest guard at the shared production boundary: the daemon
+  // tool surface and the skills runner both reach this dispatcher.
+  const { decideTuiSelfNest } = await import('../../agent/terminal-surface.js');
+  const selfNest = decideTuiSelfNest([args.cmd, ...(args.args ?? [])]);
+  if (selfNest.reject) return { output: selfNest.output ?? '' };
   const boundaryReject = harnessCommandWriteReject([args.cmd, ...(args.args ?? [])], args.workdir ?? process.cwd(), 'pty-start');
   if (boundaryReject) return { output: boundaryReject };
   if (!ptyAvailable()) {

package/src/skills/tools/schedule-wakeup.ts

@@ -402,7 +402,7 @@ export function buildScheduleWakeupHostTool(scheduler: WakeupScheduler): LLMTool
     name: SCHEDULE_WAKEUP_TOOL_NAME,
     description:
       'Wake THIS TUI later with an internal turn: when you would write «다음 점검 HH:MM» and end the turn, call this instead so the check actually happens. '
-      + 'action=schedule (default) needs reason plus one of at ("HH:MM" local, past → tomorrow) / delaySeconds (≥60) / repeatMinutes (≥1; repeats expire after 7 days). Never provide both at and delaySeconds; the schema requires one timing variant. '
+      + 'action=schedule (default) needs reason plus one of at ("HH:MM" local, past → tomorrow) / delaySeconds (≥60) / repeatMinutes (≥1; repeats expire after 7 days). Never provide both at and delaySeconds; the scheduler validates the timing choice. '
       + 'ONE-SHOT (wake once): give only delaySeconds or at and OMIT repeatMinutes (0 also means one-shot). Set repeatMinutes only when you really want it to repeat. '
       + `action=list shows pending wakeups; action=cancel needs id. Limits: ≥60s ahead, ≤7 days, at most 5 pending, at most ${WAKEUP_MAX_CALLS_PER_TURN} schedule/cancel calls per turn. `
       + 'If the TUI is busy or the human is typing at that time it retries once a minute later, then gives up (repeats move to the next tick). '
@@ -418,11 +418,6 @@ export function buildScheduleWakeupHostTool(scheduler: WakeupScheduler): LLMTool
         id: { type: 'string', description: 'Wakeup id for action=cancel (from schedule/list).' },
       },
       required: [],
-      oneOf: [
-        { not: { anyOf: [{ required: ['at'] }, { required: ['delaySeconds'] }] } },
-        { required: ['at'], not: { required: ['delaySeconds'] } },
-        { required: ['delaySeconds'], not: { required: ['at'] } },
-      ],
     },
     handler: async (args) => {
       const action = typeof args.action === 'string' ? args.action : 'schedule';

package/src/status/bar.ts

@@ -322,7 +322,7 @@ function truncateAtParamSize(model: string): string {
 /** Current active LLM model pill. Pink matches Claude Code's palette.
  *
  *  2026-05-05 — provider name omitted (cloud) / `<node>:<model>` for
- *  local. Node name (e.g. `local`, `node-b`) doubles as the local-LLM
+ *  local. Node name (e.g. `local`, `node-a`) doubles as the local-LLM
  *  indicator (cloud entries have no `<node>:` prefix). When
  *  `opts.compact` is true (caller decides via terminal width), the
  *  model id portion truncates at the first parameter-size marker.
@@ -330,13 +330,13 @@ function truncateAtParamSize(model: string): string {
  *  Render shape examples:
  *   - Cloud:                       `claude-opus-4-6`, `grok-4.3`
  *   - Local (multi-node spec):     `local:qwen3.6-35b-a3b-ud-mlx`
- *                                  `node-b:qwen2.5-72b-instruct`
+ *                                  `node-a:qwen2.5-72b-instruct`
  *   - Local (legacy `local:<m>`):  `local:llama-3-8b` (unchanged)
  *   - Local (bare model):          `local:tinyllama-1b`
  *   - No model:                    bare provider name fallback.
  *  With `compact: true`:
  *   - `local:qwen3.6-35b-a3b-ud-mlx` → `local:qwen3.6-35b`
- *   - `node-b:qwen2.5-72b-instruct`    → `node-b:qwen2.5-72b`
+ *   - `node-a:qwen2.5-72b-instruct`  → `node-a:qwen2.5-72b`
  *   - `claude-opus-4-6`              → unchanged (no `\d+b` marker) */
 export function modelSegment(info: StatusModelInfo, opts: StatusBarRenderOptions = {}): string {
   // 이번 턴 실제 실행이 있으면 그 값이 «지금» 이다 — 설정/런타임 값은 실행 전 기본값일 뿐.

package/src/status/metrics.ts

@@ -16,7 +16,7 @@
 
 import { costForUsageDetailed, type TokenUsage } from '../models/costs.js';
 import { resolveModelContextWindow } from '../models/context-window.js';
-import { DEFAULT_TOKEN_BUDGET, estimateTokens } from '../tokens.js';
+import { DEFAULT_TOKEN_BUDGET, estimateMessagesTokens, estimateTokens } from '../tokens.js';
 
 export interface SessionMetrics {
   /** Cumulative input tokens sent this session. */
@@ -119,6 +119,17 @@ export function recordTurn(input: RecordTurnInput): SessionMetrics {
   return singleton;
 }
 
+/**
+ * A conversation was just restored (`/session load` · `--resume`): the next turn will send all of it,
+ * so the ctx readout shows that size now instead of 0 until the first turn reports real usage
+ * (TUI-RESUME-PICKER ④). The first `recordTurn` replaces it with the provider's number.
+ */
+export function noteRestoredContext(history: readonly { role: string; content: unknown }[]): number {
+  const used = estimateMessagesTokens(history.map((m) => ({ role: m.role, content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content ?? '') })));
+  singleton.lastContextUsed = used;
+  return used;
+}
+
 /** Elapsed time since session start, in seconds. Updated on every
  *  call (doesn't depend on recordTurn firing). */
 export function sessionElapsedSec(): number {

package/src/steward/rejudge-tick.ts

@@ -19,7 +19,7 @@ import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { spawnElanous } from '../instance/spawn-elanous.js';
 import { getUserConfig } from '../user-config.js';
-import { resyncPendingPath } from './resync-tick.js';
+import { resyncPendingPath, resyncPendingRecoveryPath } from './resync-tick.js';
 
 export const REJUDGE_TICK_EVENT = 'rejudge-tick';
 export const REJUDGE_DEFAULT_MAX_LOAD = 60;
@@ -145,11 +145,18 @@ export async function rejudgeTick(deps: RejudgeTickDeps = {}): Promise<RejudgeTi
   }
 }
 
+/**
+ * The resync marker, or its recovery sibling when the primary record could not be written after a push. Both carry
+ * `{ savedAt }`, so a same-tick rejudge still sees the new head instead of falling back to the cadence alone.
+ */
 function readPending(path: string): string | null {
-  try {
-    const value = (JSON.parse(readFileSync(path, 'utf8')) as { savedAt?: unknown }).savedAt;
-    return typeof value === 'string' && Number.isFinite(Date.parse(value)) ? value : null;
-  } catch { return null; }
+  for (const candidate of [path, resyncPendingRecoveryPath(path)]) {
+    try {
+      const value = (JSON.parse(readFileSync(candidate, 'utf8')) as { savedAt?: unknown }).savedAt;
+      if (typeof value === 'string' && Number.isFinite(Date.parse(value))) return value;
+    } catch { /* missing or unreadable: fall through to the recovery marker */ }
+  }
+  return null;
 }
 
 if (import.meta.main) {

package/src/steward/resync-tick.ts

@@ -16,6 +16,36 @@ type ResyncTickResult = { decision: 'ran' | 'failed' | 'skipped-release' | 'skip
 
 export function resyncPendingPath(): string { return join(effectiveInstanceRoot(), 'steward', 'resync-pending.json'); }
 
+/**
+ * Fallback marker for the same-tick rejudge node when the primary marker cannot be written after a successful
+ * remote push. It lives next to the primary marker and carries the same `{ savedAt }` shape, so the consumer
+ * contract does not change — only the location the marker is read from.
+ */
+export function resyncPendingRecoveryPath(pendingPath: string = resyncPendingPath()): string {
+  return join(dirname(pendingPath), 'resync-pending-recovery.json');
+}
+
+/** Best-effort marker write: a record failure must not undo the completed push or hide its new head. */
+function recordResyncPending(pendingPath: string): void {
+  const savedAt = new Date().toISOString();
+  try {
+    mkdirSync(dirname(pendingPath), { recursive: true });
+    writeFileSync(pendingPath, JSON.stringify({ savedAt }));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`steward resync: pending record write failed — ${message}`);
+    try {
+      const recoveryPath = resyncPendingRecoveryPath(pendingPath);
+      mkdirSync(dirname(recoveryPath), { recursive: true });
+      writeFileSync(recoveryPath, JSON.stringify({ savedAt }));
+      console.error(`steward resync: pending record recovered at ${recoveryPath}`);
+    } catch (fallbackError) {
+      // Nothing left to write: the tick still reports `ran` with the pushed summary, and the failure stays observable.
+      console.error(`steward resync: pending record recovery failed — ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`);
+    }
+  }
+}
+
 /** The same registered, detached OP checkout used by steward launch; the installed package is not a git repository. */
 export function stewardResyncRepoRoot(
   resolveSeat: typeof resolveHqLaunchSeat = resolveHqLaunchSeat,
@@ -185,10 +215,7 @@ export async function resyncTickWithReleaseProbe(
           result = { decision: 'skipped-release-window', reason: window === 'inside' ? 'scheduled release window' : 'release schedule unavailable' };
         } else {
           const summary = await run();
-          if (summary.saved > 0) {
-            mkdirSync(dirname(pendingPath), { recursive: true });
-            writeFileSync(pendingPath, JSON.stringify({ savedAt: new Date().toISOString() }));
-          }
+          if (summary.saved > 0) recordResyncPending(pendingPath);
           result = { decision: 'ran', summary };
         }
       }

package/src/storage/file-lock.ts

@@ -70,13 +70,26 @@ export function acquireLockSync(lockPath: string, opts: LockOpts = {}): ReleaseL
   for (let attempt = 0; attempt < maxTries; attempt += 1) {
     try {
       const fd = openSync(lockPath, 'wx');
-      try { writeSync(fd, `${process.pid}\n`); }
-      catch { /* metadata only · not fatal */ }
-      const acquired = fstatSync(fd);
+      try {
+        writeSync(fd, `${process.pid}\n`);
+      } catch (writeErr) {
+        // 보유자 PID 를 못 쓰면 holderIsDead·onWait 독자 계약이 깨진다 — 방금 'wx' 로 만든 파일을 정리하고 올린다.
+        try { closeSync(fd); } catch { /* ignore */ }
+        try { unlinkSync(lockPath); } catch { /* ignore */ }
+        throw writeErr;
+      }
+      // ⭐ 소유 증명은 파일 «내용»이 아니라 «정체»다 — 내용은 보유자 PID 한 줄 계약(test/storage-file-lock ·
+      //   goal-author supersession 잠금)이라 구분 토큰을 심을 수 없고, rm+즉시 재생성은 inode 번호를
+      //   재사용하므로 inode 만으로는 교체를 못 가린다(실측). dev·ino·mtimeNs 셋이 같을 때만 우리가 만든
+      //   그 파일로 본다 — 재사용된 inode 도 새 mtime 을 가지므로 교체 자물쇠는 mtimeNs 에서 갈린다.
+      const acquired = fstatSync(fd, { bigint: true });
       closeSync(fd);
       return () => {
         try {
-          if (statSync(lockPath).ino === acquired.ino) unlinkSync(lockPath);
+          const current = statSync(lockPath, { bigint: true });
+          if (current.dev === acquired.dev && current.ino === acquired.ino && current.mtimeNs === acquired.mtimeNs) {
+            unlinkSync(lockPath);
+          }
         } catch { /* stale recovery or replacement won the path */ }
       };
     } catch (err) {