elanous 0.2.28 → 0.2.31

package/src/telegram.ts

@@ -84,7 +84,7 @@ import { recordBriefTelegramUpdate } from './cli/brief-cli.js';
 import { attachTelegramFabricPlan } from './telegram-fabric-plan.js';
 import { contextNow as readContextNow, type ContextNowDeps } from './context-bus/context-now.js';
 import { renderContextFirstOpening } from './context-bus/context-now-surfaces.js';
-import { createContextFirstFileStore, createContextFirstGate, isOperationalQuery, renderContextFirst, type ContextFirstStore } from './context-bus/context-first.js';
+import { createContextFirstFileStore, createContextFirstGate, renderContextFirst, takeContextFirstOpening, type ContextFirstStore } from './context-bus/context-first.js';
 
 export type TgAttachmentKind = 'photo' | 'voice' | 'audio' | 'document';
 
@@ -446,10 +446,8 @@ export class TelegramBot {
   /** 처음이거나 6시간 이상 쉰 대화의 첫 일반 답 앞에 context-now 요약 한 메시지를 보낸다. 실패해도 본 답은 막지 않는다. */
   private async maybeSendContextFirst(ctx: TgIncoming): Promise<void> {
     const key = `${ctx.chatId}:${ctx.threadId ?? ''}`;
-    if (!this.contextFirstGate.take(key)) return;
     const cfg = this.slashContext?.userConfig.telegram;
-    if (cfg?.contextFirst === false) return;
-    if (isOperationalQuery(ctx.text)) return;
+    if (!takeContextFirstOpening({ gate: this.contextFirstGate, key, text: ctx.text, enabled: cfg?.contextFirst !== false })) return;
     try {
       const opening = renderContextFirst(this.readContextNow, this.contextNowDeps, renderContextFirstOpening);
       if (!opening) return;

package/src/terminal/session-registry.ts

@@ -158,6 +158,12 @@ export class TerminalSessionRegistry {
         shellArgs: spec.shellArgs,
         env: spec.env,
         termName: spec.termName,
+        useRegistry: spec.useRegistry,
+        registryKind: spec.registryKind,
+        registryNickname: spec.registryNickname,
+        registryOrigin: spec.registryOrigin,
+        registryPurpose: spec.registryPurpose,
+        registrySeat: spec.registrySeat,
         bounds: spec.bounds,
         sizePreset: spec.sizePreset,
         onExit: (code) => {

package/src/thinking-line.ts

@@ -295,10 +295,19 @@ export function startPinnedThinking(opts: StartPinnedThinkingOpts): ThinkingHand
   const interval = opts.intervalMs ?? INTERVAL_MS;
   const timer = interval > 0 ? setInterval(tick, interval) : null;
 
+  // ⛔ stop() 뒤엔 칠하지 않는다 — 멈춘 손잡이에 늦게 온 update/updateMetrics(다음 반복이 같은 손잡이를
+  //   재사용하거나 턴 마감 뒤 도착한 이벤트)가 «✢ Thinking…» 프레임을 footer 에 다시 써서, 타이머 없는
+  //   멈춘 표시로 남았다(TUI 결함 #5 · 10-14 13:43 오류 뒤 «Thinking…» 정지).
+  const repaint = (): void => {
+    if (stopped) return;
+    paint();
+    opts.onFrame();
+  };
+
   return {
-    update: (m) => { message = m; messageFactory = null; paint(); opts.onFrame(); },
-    updateAnimated: (fn) => { messageFactory = fn; paint(); opts.onFrame(); },
-    updateMetrics: (m) => { metrics = { ...metrics, ...m }; paint(); opts.onFrame(); },
+    update: (m) => { message = m; messageFactory = null; repaint(); },
+    updateAnimated: (fn) => { messageFactory = fn; repaint(); },
+    updateMetrics: (m) => { metrics = { ...metrics, ...m }; repaint(); },
     reflow: () => { if (!stopped) paint(); opts.onFrame(); },
     stop: (stopOpts) => {
       if (stopped) return;

package/src/tool-runtime/index.ts

@@ -32,6 +32,7 @@ import { agentReplyRuntime } from './agent-reply-runtime.js';
 import { agentStopRuntime } from './agent-stop-runtime.js';
 import { ALL_TEAM_TOOL_RUNTIMES } from './team-tool-runtimes.js';
 import { ALL_OPS_FLEET_RUNTIMES } from './ops-fleet-runtimes.js';
+import { ALL_OPS_LEDGER_RUNTIMES } from './ops-ledger-runtimes.js';
 import { ALL_AUTO_RESEARCH_RUNTIMES } from './auto-research-runtimes.js';
 import { ALL_INTELLIGENCE_MAP_RUNTIMES } from './intelligence-map-runtimes.js';
 import { ALL_CFT_ANDON_RUNTIMES } from './cft-andon-runtimes.js';
@@ -115,6 +116,9 @@ export function registerAllDefaultToolRuntimes(): void {
   registerToolRuntime(agentStopRuntime);
   for (const rt of ALL_TEAM_TOOL_RUNTIMES) registerToolRuntime(rt);
   for (const rt of ALL_OPS_FLEET_RUNTIMES) registerToolRuntime(rt);
+  // Ops-ledger (우편 msg · 판 release checklist) — in-process ledger tools so
+  // TUI OP turns stop paying 1.3–2s of `eln` CLI startup per msg/checklist op.
+  for (const rt of ALL_OPS_LEDGER_RUNTIMES) registerToolRuntime(rt);
   for (const rt of ALL_AUTO_RESEARCH_RUNTIMES) registerToolRuntime(rt);
   for (const rt of ALL_INTELLIGENCE_MAP_RUNTIMES) registerToolRuntime(rt);
   for (const rt of ALL_CFT_ANDON_RUNTIMES) registerToolRuntime(rt);

package/src/tool-runtime/ops-ledger-runtimes.ts

@@ -0,0 +1,84 @@
+// ── Ops-ledger tool runtimes (우편 msg · 판 release checklist) ──
+//
+// Registers the eight in-process ledger tools with the tool-runtime
+// layer so every surface (skill-runner, TUI) can call them by name:
+// MsgList / MsgPost / MsgAck and ChecklistList / ChecklistAdd /
+// ChecklistSet / ChecklistEdit / ChecklistMove. Dispatchers live in
+// src/skills/tools/ops-ledger.ts; this file is a thin adapter — the
+// same pattern as team-tool-runtimes.ts. Every call goes through
+// `observeLedgerCall` — one `ops-ledger` `call` line with the tool, the
+// elapsed ms, ok, the seat actor and ids (never bodies or evidence).
+
+import {
+  buildMsgListTool, dispatchMsgList,
+  buildMsgPostTool, dispatchMsgPost,
+  buildMsgAckTool, dispatchMsgAck,
+  buildChecklistListTool, dispatchChecklistList,
+  buildChecklistAddTool, dispatchChecklistAdd,
+  buildChecklistSetTool, dispatchChecklistSet,
+  buildChecklistMoveTool, dispatchChecklistMove,
+  buildChecklistEditTool, dispatchChecklistEdit,
+  type ChecklistAddResult, type ChecklistEditResult, type ChecklistListResult, type ChecklistMoveResult,
+  type ChecklistSetResult, type MsgAckResult, type MsgListResult, type MsgPostResult,
+  observeLedgerCall,
+} from '../skills/tools/ops-ledger.js';
+import type { ToolRuntime } from './types.js';
+
+export const msgListRuntime: ToolRuntime<Record<string, unknown>, MsgListResult> = {
+  id: 'msg_list',
+  spec: buildMsgListTool(),
+  async run(req) { return observeLedgerCall('MsgList', req, () => dispatchMsgList(req), (a, r) => ({ to: a.to, ...(r ? { count: r.count, after: r.after } : {}) })); },
+};
+
+export const msgPostRuntime: ToolRuntime<Record<string, unknown>, MsgPostResult> = {
+  id: 'msg_post',
+  spec: buildMsgPostTool(),
+  async run(req) { return observeLedgerCall('MsgPost', req, () => dispatchMsgPost(req), (a, r) => ({ from: a.from, to: a.to, ...(r ? { id: r.message.id } : {}) })); },
+};
+
+export const msgAckRuntime: ToolRuntime<Record<string, unknown>, MsgAckResult> = {
+  id: 'msg_ack',
+  spec: buildMsgAckTool(),
+  async run(req) { return observeLedgerCall('MsgAck', req, () => dispatchMsgAck(req), (a, r) => ({ to: a.to, id: a.id, ...(r ? { cursor: r.cursor } : {}) })); },
+};
+
+export const checklistListRuntime: ToolRuntime<Record<string, unknown>, ChecklistListResult> = {
+  id: 'checklist_list',
+  spec: buildChecklistListTool(),
+  async run(req) { return observeLedgerCall('ChecklistList', req, () => dispatchChecklistList(req), (a, r) => ({ version: r?.version ?? a.version, ...(r ? { items: r.items.length, history: r.history.length } : {}) })); },
+};
+
+export const checklistAddRuntime: ToolRuntime<Record<string, unknown>, ChecklistAddResult> = {
+  id: 'checklist_add',
+  spec: buildChecklistAddTool(),
+  async run(req) { return observeLedgerCall('ChecklistAdd', req, () => dispatchChecklistAdd(req), (a, r) => ({ id: a.id, version: r?.version ?? a.version })); },
+};
+
+export const checklistSetRuntime: ToolRuntime<Record<string, unknown>, ChecklistSetResult> = {
+  id: 'checklist_set',
+  spec: buildChecklistSetTool(),
+  async run(req) { return observeLedgerCall('ChecklistSet', req, () => dispatchChecklistSet(req), (a, r) => ({ id: a.id, version: r?.version ?? a.version, ...(a.status === undefined ? {} : { status: a.status }) })); },
+};
+
+export const checklistEditRuntime: ToolRuntime<Record<string, unknown>, ChecklistEditResult> = {
+  id: 'checklist_edit',
+  spec: buildChecklistEditTool(),
+  async run(req) { return observeLedgerCall('ChecklistEdit', req, () => dispatchChecklistEdit(req), (a, r) => ({ id: a.id, version: r?.version ?? a.version, field: a.field })); },
+};
+
+export const checklistMoveRuntime: ToolRuntime<Record<string, unknown>, ChecklistMoveResult> = {
+  id: 'checklist_move',
+  spec: buildChecklistMoveTool(),
+  async run(req) { return observeLedgerCall('ChecklistMove', req, () => dispatchChecklistMove(req), (a) => ({ id: a.id, from: a.from, to: a.to })); },
+};
+
+export const ALL_OPS_LEDGER_RUNTIMES: ToolRuntime<any, any>[] = [
+  msgListRuntime,
+  msgPostRuntime,
+  msgAckRuntime,
+  checklistListRuntime,
+  checklistAddRuntime,
+  checklistSetRuntime,
+  checklistEditRuntime,
+  checklistMoveRuntime,
+];

package/src/tool-runtime/ref-consult-runtime.ts

@@ -23,7 +23,7 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import type { LLMToolSpec } from '../llm.js';
 import type { ToolRuntime, ToolRuntimeContext } from './types.js';
-import { DEFAULT_REFERENCE_ROOTS } from '../agent/ref-grounding.js';   // ★ F3 — 로컬 canonical ref 루트
+import { DEFAULT_REFERENCE_ROOTS, denyNonPublicReference } from '../agent/ref-grounding.js';   // ★ F3 — 로컬 canonical ref 루트
 import { debug } from '../debug/log.js';
 
 const CACHE_ROOT_DEFAULT = join(homedir(), '.cache', 'elanous-refs');
@@ -123,6 +123,17 @@ export function dispatchRefConsult(
 ): RefConsultResult {
   const host = args.host ?? 'github.com';
   const cacheRoot = args.cacheRoot ?? CACHE_ROOT_DEFAULT;
+  // 대표 2026-10-14 — 비공개 소스(Claude Code 사본)는 캐시·로컬 ref 어느 쪽이든 조회하지 않는다.
+  //   owner·repo 는 단일 경로 성분이어야 한다 — `<사본 이름>/.` 같은 값이 join() 정규화로 이름 판정을 우회하지 못하게.
+  for (const [field, value] of [['owner', args.owner], ['repo', args.repo]] as const) {
+    if (!/^[A-Za-z0-9._-]+$/.test(value) || value === '.' || value === '..') {
+      throw new Error(`RefConsult: ${field} must be a single path segment (got ${JSON.stringify(value)})`);
+    }
+  }
+  //   판정은 `repo` 칸만 — 공개 저장소 owner 이름이 우연히 같아도 막지 않는다(로컬 중첩 경로는 아래에서 따로 거른다).
+  if (denyNonPublicReference(args.repo)) {
+    throw new Error(`RefConsult: ${args.owner}/${args.repo} is a non-public source and is not consulted. Use public documentation instead.`);
+  }
   // ★ F3(2026-07-22) — repo 경로 해석을 fallback 체인으로: ①에이전트 scratch 캐시(SyncRepo 산출·있으면 우선)
   //   → ②로컬 canonical ref(~/source/ref/<repo>·flat bare-name·재클론 없이 90 repo 즉시 grep) → ③둘 다 없으면
   //   throw. 종전엔 캐시만 봐서 캐시 미존재 시 canonical ref 가 놀아도 "SyncRepo 먼저" 로 죽던 단절을 연결.
@@ -133,7 +144,11 @@ export function dispatchRefConsult(
   if (!existsSync(join(cachePath, '.git'))) {
     const roots = args.referenceRoots ?? DEFAULT_REFERENCE_ROOTS;
     const localHit = roots
-      .flatMap((root) => [join(root, args.repo), join(root, args.owner, args.repo)])
+      .flatMap((root) => [
+        join(root, args.repo),
+        // 로컬 ref 의 <owner>/<repo> 중첩은 owner 디렉터리가 비공개 사본이면 그 아래로 내려가지 않는다.
+        ...(denyNonPublicReference(args.owner) ? [] : [join(root, args.owner, args.repo)]),
+      ])
       .find((p) => existsSync(join(p, '.git')));
     if (localHit) { repoPath = localHit; source = 'local-ref'; }
     else {

package/src/tool-runtime/run-shell-runtime.ts

@@ -31,6 +31,9 @@ export const runShellRuntime: ToolRuntime<Record<string, unknown>, RunShellDispa
       ctx.surface === 'dashboard' && req.sandbox === undefined
         ? { ...req, sandbox: 'auto' }
         : req;
-    return dispatchRunShell(effectiveReq, { signal: ctx.signal });
+    return dispatchRunShell(effectiveReq, {
+      signal: ctx.signal,
+      availableToolNames: ctx.agentHostTools?.map(tool => tool.name),
+    });
   },
 };

package/src/tool-runtime/self-cognition-runtimes.ts

@@ -195,7 +195,11 @@ export const SELF_COGNITION_RUNTIMES: readonly ToolRuntime[] = SELF_COGNITION_TO
     return coreSpec(name);
   },
   run: async (args, ctx) => name === 'context_now'
-    ? (await import('../context-bus/context-now.js')).contextNow({ ...(typeof args.topic === 'string' ? { topic: args.topic } : {}) })
+    ? (() => {
+      const options = { ...(typeof args.topic === 'string' ? { topic: args.topic } : {}) };
+      return import('../context-bus/context-now.js').then(now => ctx.surface === 'tui'
+        ? now.contextNowInWorker(options) : now.contextNow(options));
+    })()
     : name === 'memory_recall' || name === 'self_recall'
       ? runRecall(name, args, ctx)
       : toToolRunResult(await coreTools().buildCoreTools().dispatch(name, args)),