ummaya 0.2.3 → 0.2.5

package/tui/src/ink/reconciler.ts

@@ -34,9 +34,8 @@ if (process.env.NODE_ENV === 'development') {
   try {
     // eslint-disable-next-line custom-rules/no-top-level-dynamic-import -- dev-only; NODE_ENV check is DCE'd in production
     void import('./devtools.js')
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  } catch (error: any) {
-    if (error.code === 'ERR_MODULE_NOT_FOUND') {
+  } catch (error: unknown) {
+    if (error instanceof Error && 'code' in error && error.code === 'ERR_MODULE_NOT_FOUND') {
       // biome-ignore lint/suspicious/noConsole: intentional warning
       console.warn(
         `

package/tui/src/ink/render-to-screen.ts

@@ -45,6 +45,31 @@ let output: Output | undefined
 const timing = { reconcile: 0, yoga: 0, paint: 0, scan: 0, calls: 0 }
 const LOG_EVERY = 20
 
+type SearchRendererContainer = ReturnType<typeof reconciler.createContainer>
+type SearchReconcilerRuntime = typeof reconciler & {
+  createContainer(
+    root: DOMElement,
+    tag: typeof LegacyRoot,
+    hydrationCallbacks: null,
+    isStrictMode: boolean,
+    concurrentUpdatesByDefaultOverride: null,
+    identifierPrefix: string,
+    onUncaughtError: () => void,
+    onCaughtError: () => void,
+    onRecoverableError: () => void,
+    onDefaultTransitionIndicator: () => void,
+  ): SearchRendererContainer
+  updateContainerSync(
+    element: ReactElement | null,
+    container: SearchRendererContainer,
+    parentComponent: null,
+    callback: () => void,
+  ): void
+  flushSyncWork(): void
+}
+
+const searchReconciler = reconciler as SearchReconcilerRuntime
+
 /** Render a React element (wrapped in all contexts the component needs —
  *  caller's job) to an isolated Screen buffer at the given width. Returns
  *  the Screen + natural height (from yoga). Used for search: render ONE
@@ -66,8 +91,7 @@ export function renderToScreen(
     stylePool = new StylePool()
     charPool = new CharPool()
     hyperlinkPool = new HyperlinkPool()
-    // @ts-expect-error react-reconciler 0.33 takes 10 args; @types says 11
-    container = reconciler.createContainer(
+    container = searchReconciler.createContainer(
       root,
       LegacyRoot,
       null,
@@ -82,10 +106,8 @@ export function renderToScreen(
   }
 
   const t0 = performance.now()
-  // @ts-expect-error updateContainerSync exists but not in @types
-  reconciler.updateContainerSync(el, container, null, noop)
-  // @ts-expect-error flushSyncWork exists but not in @types
-  reconciler.flushSyncWork()
+  searchReconciler.updateContainerSync(el, container, null, noop)
+  searchReconciler.flushSyncWork()
   const t1 = performance.now()
 
   // Yoga layout. Root might not have a yogaNode if the tree is empty.
@@ -117,10 +139,8 @@ export function renderToScreen(
   const t3 = performance.now()
 
   // Unmount so next call gets a fresh tree. Leaves root/container/pools.
-  // @ts-expect-error updateContainerSync exists but not in @types
-  reconciler.updateContainerSync(null, container, null, noop)
-  // @ts-expect-error flushSyncWork exists but not in @types
-  reconciler.flushSyncWork()
+  searchReconciler.updateContainerSync(null, container, null, noop)
+  searchReconciler.flushSyncWork()
 
   timing.reconcile += t1 - t0
   timing.yoga += t2 - t1

package/tui/src/ipc/bridge.ts

@@ -255,6 +255,14 @@ class AsyncQueue<T> {
           this._resolve = resolve
         })
       },
+      return: (): Promise<IteratorResult<T>> => {
+        if (this._resolve) {
+          const r = this._resolve
+          this._resolve = null
+          r({ value: undefined as unknown as T, done: true })
+        }
+        return Promise.resolve({ value: undefined as unknown as T, done: true })
+      },
     }
   }
 }
@@ -339,13 +347,19 @@ export function createBridge(opts: BridgeOptions = {}): IPCBridge {
   let _tuiSessionToken: string | null = opts.tuiSessionToken ?? null
   let _lastSeenCorrelationId: string | null = null
   let _lastSeenFrameSeq: number | null = null
-  // Bounded ring of applied (session_id, frame_seq) keys for replay-dedup.
-  // Cap mirrors the backend SessionRingBuffer size (Spec 032: 256 frames);
-  // oldest entries are evicted via FIFO replacement so the Set cannot grow
-  // unbounded across long sessions.
+  // Bounded rings for replay de-duplication.
+  //
+  // `applied_frame_seqs` remains the public debug surface expected by the
+  // resume tests. The actual skip decision uses a fuller frame identity below:
+  // some TUI-owned tool_call result paths are not ring-stamped by the backend
+  // yet and legally arrive with the default frame_seq=0. Dropping by
+  // session:frame_seq alone loses distinct tool_result frames in ordinary
+  // runtime, which is worse than replay duplication.
   const _APPLIED_FRAME_SEQS_CAP = 256
   const _appliedFrameSeqs = new Set<string>()
   const _appliedFrameSeqsOrder: string[] = []
+  const _appliedFrameIdentities = new Set<string>()
+  const _appliedFrameIdentitiesOrder: string[] = []
 
   // ------------------------------------------------------------------
   // Spawn first process
@@ -435,6 +449,40 @@ export function createBridge(opts: BridgeOptions = {}): IPCBridge {
     }
   }
 
+  function _frameReplayIdentity(frame: IPCFrame): string | null {
+    if (frame.frame_seq == null) return null
+    const sessionKey = frame.session_id ?? _sessionId
+    if (!sessionKey) return null
+    return [
+      sessionKey,
+      frame.frame_seq,
+      frame.kind,
+      frame.correlation_id ?? '',
+      frame.transaction_id ?? '',
+    ].join(':')
+  }
+
+  function _rememberAppliedFrameIdentity(identity: string): void {
+    _appliedFrameIdentities.add(identity)
+    _appliedFrameIdentitiesOrder.push(identity)
+    if (_appliedFrameIdentitiesOrder.length > _APPLIED_FRAME_SEQS_CAP) {
+      const evicted = _appliedFrameIdentitiesOrder.shift()
+      if (evicted !== undefined) _appliedFrameIdentities.delete(evicted)
+    }
+  }
+
+  function _rememberAppliedFrameSeq(frame: IPCFrame): void {
+    if (!_sessionId || frame.frame_seq == null) return
+    const key = `${frame.session_id ?? _sessionId}:${frame.frame_seq}`
+    if (_appliedFrameSeqs.has(key)) return
+    _appliedFrameSeqs.add(key)
+    _appliedFrameSeqsOrder.push(key)
+    if (_appliedFrameSeqsOrder.length > _APPLIED_FRAME_SEQS_CAP) {
+      const evicted = _appliedFrameSeqsOrder.shift()
+      if (evicted !== undefined) _appliedFrameSeqs.delete(evicted)
+    }
+  }
+
   async function _doReconnect(): Promise<void> {
     if (_closed || _reconnecting) return
     _reconnecting = true
@@ -536,22 +584,21 @@ export function createBridge(opts: BridgeOptions = {}): IPCBridge {
                 _lastSeenCorrelationId = frame.correlation_id
               }
 
-              // De-duplicate replayed frames (applied_frame_seqs set)
-              if (_sessionId && frame.frame_seq != null) {
-                const key = `${frame.session_id ?? _sessionId}:${frame.frame_seq}`
-                if (_appliedFrameSeqs.has(key)) {
+              // De-duplicate replayed frames by full frame identity. Do not
+              // use session:frame_seq as the skip key: TUI-owned tool_result
+              // frames can currently share the default frame_seq=0 while still
+              // being separate, valid results.
+              const replayIdentity = _frameReplayIdentity(frame)
+              if (replayIdentity !== null) {
+                if (_appliedFrameIdentities.has(replayIdentity)) {
                   _log(
                     'DEBUG',
-                    `Skipping duplicate replay frame session=${frame.session_id} frame_seq=${frame.frame_seq}`,
+                    `Skipping duplicate replay frame identity=${replayIdentity}`,
                   )
                   continue
                 }
-                _appliedFrameSeqs.add(key)
-                _appliedFrameSeqsOrder.push(key)
-                if (_appliedFrameSeqsOrder.length > _APPLIED_FRAME_SEQS_CAP) {
-                  const evicted = _appliedFrameSeqsOrder.shift()
-                  if (evicted !== undefined) _appliedFrameSeqs.delete(evicted)
-                }
+                _rememberAppliedFrameIdentity(replayIdentity)
+                _rememberAppliedFrameSeq(frame)
               }
 
               _log('DEBUG', `recv kind=${frame.kind} session=${frame.session_id}`)

package/tui/src/ipc/bridgeSingleton.ts

@@ -11,6 +11,7 @@
 // prompt is actually typed. Subsequent turns reuse the running child.
 
 import { createBridge, type IPCBridge } from './bridge.js'
+import { getSessionId } from '../bootstrap/state.js'
 import {
   ingestManifestFrame,
   waitForManifestSync,
@@ -36,7 +37,9 @@ let _pluginsModifiedThisSession = false
 
 export function getOrCreateUmmayaBridge(): IPCBridge {
   if (_bridge !== null) return _bridge
+  const sessionId = getUmmayaBridgeSessionId()
   _bridge = createBridge({
+    sessionId,
     // Epic ε #2296 T010 — route adapter_manifest_sync frames to the TS-side
     // manifest cache on receipt (before any LLM turn, at backend boot time).
     // FR-015: fires once per backend lifecycle; FR-016: replace-on-frame
@@ -69,7 +72,7 @@ export async function ensureUmmayaAdapterManifest(
 
 export function getUmmayaBridgeSessionId(): string {
   if (_sessionId === null) {
-    _sessionId = crypto.randomUUID()
+    _sessionId = getSessionId()
   }
   return _sessionId
 }
@@ -104,4 +107,5 @@ export async function closeUmmayaBridge(): Promise<void> {
     await b.close()
   }
   _pluginsModifiedThisSession = false
+  _sessionId = null
 }

package/tui/src/ipc/codec.ts

@@ -24,6 +24,7 @@ import type {
   IPCFrame,
   UserInputFrame,
   AssistantChunkFrame,
+  ProgressEventFrame,
   ToolCallFrame,
   ToolResultFrame,
   CoordinatorPhaseFrame,
@@ -50,6 +51,7 @@ import type {
 export type { AdapterManifestSyncFrame }
 // Re-export consent revoke types.
 export type { ConsentRevokeRequestFrame, ConsentRevokeResponseFrame }
+export type { ProgressEventFrame }
 
 // ---------------------------------------------------------------------------
 // Zod schemas (belt-and-braces atop generated TypeScript types)
@@ -113,6 +115,10 @@ const ChatRequestFrameSchema = BaseFrame.extend({
   max_tokens: z.number().int().min(1).max(32000).default(8192),
   temperature: z.number().min(0).max(2).default(1.0),
   top_p: z.number().min(0).max(1).default(0.95),
+  reasoning_mode: z
+    .enum(['fast', 'balanced', 'deep', 'diagnostic', 'auto'])
+    .nullable()
+    .optional(),
 })
 
 const AssistantChunkFrameSchema = BaseFrame.extend({
@@ -128,6 +134,22 @@ const AssistantChunkFrameSchema = BaseFrame.extend({
   done: z.boolean(),
 })
 
+const ProgressEventFrameSchema = BaseFrame.extend({
+  kind: z.literal('progress_event'),
+  phase: z.enum([
+    'analysis',
+    'tool_selection',
+    'tool_call',
+    'tool_result',
+    'answer_synthesis',
+  ]),
+  message_ko: z.string().min(1),
+  message_en: z.string().min(1),
+  safe_to_persist: z.boolean().default(true),
+  tool_id: z.string().nullable().optional(),
+  call_id: z.string().nullable().optional(),
+})
+
 const ToolCallFrameSchema = BaseFrame.extend({
   kind: z.literal('tool_call'),
   call_id: z.string(),
@@ -136,7 +158,7 @@ const ToolCallFrameSchema = BaseFrame.extend({
 })
 
 const ToolResultEnvelopeSchema = z.object({
-  kind: z.enum(['find', 'locate', 'send', 'check']),
+  kind: z.enum(['find', 'locate', 'send', 'check', 'document']),
 }).passthrough()
 
 const ToolResultFrameSchema = BaseFrame.extend({
@@ -154,7 +176,7 @@ const WorkerStatusFrameSchema = BaseFrame.extend({
   kind: z.literal('worker_status'),
   worker_id: z.string(),
   role_id: z.string(),
-  current_primitive: z.enum(['find', 'locate', 'send', 'check']),
+  current_primitive: z.enum(['find', 'locate', 'send', 'check', 'document']),
   status: z.enum(['idle', 'running', 'waiting_permission', 'error']),
 })
 
@@ -162,7 +184,7 @@ const PermissionRequestFrameSchema = BaseFrame.extend({
   kind: z.literal('permission_request'),
   request_id: z.string(),
   worker_id: z.string(),
-  primitive_kind: z.enum(['find', 'locate', 'send', 'check']),
+  primitive_kind: z.enum(['find', 'locate', 'send', 'check', 'document']),
   description_ko: z.string(),
   description_en: z.string(),
   risk_level: z.enum(['low', 'medium', 'high']),
@@ -337,6 +359,7 @@ export const IPCFrameSchema = z.discriminatedUnion('kind', [
   // Spec 287 baseline (10)
   UserInputFrameSchema,
   AssistantChunkFrameSchema,
+  ProgressEventFrameSchema,
   ToolCallFrameSchema,
   ToolResultFrameSchema,
   CoordinatorPhaseFrameSchema,
@@ -376,6 +399,9 @@ export function isUserInput(f: IPCFrame): f is UserInputFrame {
 export function isAssistantChunk(f: IPCFrame): f is AssistantChunkFrame {
   return f.kind === 'assistant_chunk'
 }
+export function isProgressEvent(f: IPCFrame): f is ProgressEventFrame {
+  return f.kind === 'progress_event'
+}
 export function isToolCall(f: IPCFrame): f is ToolCallFrame {
   return f.kind === 'tool_call'
 }