ummaya 0.2.3 → 0.2.5

package/tui/src/keybindings/defaultBindings.ts

@@ -338,3 +338,7 @@ export const DEFAULT_BINDINGS: KeybindingBlock[] = [
     },
   },
 ]
+
+// Backwards-compatible name used by older focused TUI tests and snapshot
+// harnesses. The active runtime import remains DEFAULT_BINDINGS.
+export const DEFAULT_BINDING_BLOCKS = DEFAULT_BINDINGS

package/tui/src/main.tsx

@@ -23,6 +23,7 @@ import { checkHasTrustDialogAccepted, getGlobalConfig, getRemoteControlAtStartup
 import { seedEarlyInput, stopCapturingEarlyInput } from './utils/earlyInput.js';
 import { getInitialEffortSetting, parseEffortValue } from './utils/effort.js';
 import { getInitialFastModeSetting, isFastModeEnabled, prefetchFastModeStatus, resolveFastModeStatusFromCache } from './utils/fastMode.js';
+import { getInitialReasoningModeSetting } from './utils/kExaoneReasoning.js';
 import { applyConfigEnvironmentVariables } from './utils/managedEnv.js';
 import { createSystemMessage } from './utils/systemMessageFactories.js';
 import { createUserMessage } from './utils/userMessageFactories.js';
@@ -91,8 +92,8 @@ import { validateUuid } from './utils/uuid.js';
 
 import { registerMcpAddCommand } from 'src/commands/mcp/addCommand.js';
 import { registerMcpXaaIdpCommand } from 'src/commands/mcp/xaaIdpCommand.js';
-// claude.ai MCP proxy removed in P1+P2 (Spec 1633); UMMAYA does not consume
-// Anthropic's enterprise MCP configs. The eligibility check is now a no-op.
+// Managed MCP proxy removed in P1+P2 (Spec 1633); UMMAYA does not consume
+// upstream enterprise MCP configs. The eligibility check is now a no-op.
 const fetchClaudeAIMcpConfigsIfEligible = async (): Promise<Record<string, never>> => ({});
 import { clearServerCache } from 'src/services/mcp/client.js';
 import { areMcpConfigsAllowedWithEnterpriseMcpConfig, dedupClaudeAiMcpServers, doesEnterpriseMcpConfigExist, filterMcpServersByPolicy, getClaudeCodeMcpConfigs, getMcpServerSignature, parseMcpConfig, parseMcpConfigFromFilePath } from 'src/services/mcp/config.js';
@@ -136,6 +137,27 @@ import { getTmuxInstallInstructions, isTmuxAvailable, parsePRReference } from '.
 
 
 
+type ModuleRequire = (specifier: string) => unknown
+type InspectorModule = {
+  url: () => string | undefined
+}
+
+function isModuleRequire(value: unknown): value is ModuleRequire {
+  return typeof value === 'function'
+}
+
+function isInspectorModule(value: unknown): value is InspectorModule {
+  return typeof value === 'object' && value !== null && 'url' in value && typeof value.url === 'function'
+}
+
+function getInspectorFromGlobal(): InspectorModule | undefined {
+  const globalRequire: unknown = Reflect.get(globalThis, 'require')
+  if (!isModuleRequire(globalRequire)) return undefined
+
+  const inspector = globalRequire('inspector')
+  return isInspectorModule(inspector) ? inspector : undefined
+}
+
 // Check if running in debug/inspection mode
 function isBeingDebugged() {
   const isBun = isRunningWithBun();
@@ -160,9 +182,8 @@ function isBeingDebugged() {
   // Check if inspector is available and active (indicates debugging)
   try {
     // Dynamic import would be better but is async - use global object instead
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const inspector = (global as any).require('inspector');
-    const hasInspectorUrl = !!inspector.url();
+    const inspector = getInspectorFromGlobal();
+    const hasInspectorUrl = !!inspector?.url();
     return hasInspectorUrl || hasInspectArg || hasInspectEnv;
   } catch {
     // Ignore error and fall back to argument detection
@@ -1094,12 +1115,12 @@ async function run(): Promise<CommanderCommand> {
     });
     void assertMinVersion();
 
-    // claude.ai config fetch: -p mode only (interactive uses useManageMCPConnections
+    // UMMAYA connector config fetch: -p mode only (interactive uses useManageMCPConnections
     // two-phase loading). Kicked off here to overlap with setup(); awaited
     // before runHeadless so single-turn -p sees connectors. Skipped under
     // enterprise/strict MCP to preserve policy boundaries.
     const claudeaiConfigPromise: Promise<Record<string, ScopedMcpServerConfig>> = isNonInteractiveSession && !strictMcpConfig && !doesEnterpriseMcpConfigExist() &&
-    // --bare / SIMPLE: skip claude.ai proxy servers (datadog, Gmail,
+    // --bare / SIMPLE: skip managed connector proxy servers (datadog, Gmail,
     // Slack, BigQuery, PubMed — 6-14s each to connect). Scripted calls
     // that need MCP pass --mcp-config explicitly.
     !isBareMode() ? fetchClaudeAIMcpConfigsIfEligible().then(configs => {
@@ -1108,7 +1129,7 @@ async function run(): Promise<CommanderCommand> {
         blocked
       } = filterMcpServersByPolicy(configs);
       if (blocked.length > 0) {
-        process.stderr.write(`Warning: claude.ai MCP ${plural(blocked.length, 'server')} blocked by enterprise policy: ${blocked.join(', ')}\n`);
+        process.stderr.write(`Warning: UMMAYA MCP ${plural(blocked.length, 'server')} blocked by enterprise policy: ${blocked.join(', ')}\n`);
       }
       return allowed;
     }) : Promise.resolve({});
@@ -1774,6 +1795,7 @@ async function run(): Promise<CommanderCommand> {
         },
         toolPermissionContext,
         effortValue: parseEffortValue(options.effort) ?? getInitialEffortSetting(),
+        reasoningMode: getInitialReasoningModeSetting(),
         ...(isFastModeEnabled() && {
           fastMode: getInitialFastModeSetting(effectiveModel ?? null)
         }),
@@ -2105,6 +2127,7 @@ async function run(): Promise<CommanderCommand> {
         })
       } : null,
       effortValue: parseEffortValue(options.effort) ?? getInitialEffortSetting(),
+      reasoningMode: getInitialReasoningModeSetting(),
       activeOverlays: new Set<string>(),
       fastMode: getInitialFastModeSetting(resolvedInitialModel),
       ...(isAdvisorEnabled() && advisorModel && {
@@ -2474,16 +2497,14 @@ async function run(): Promise<CommanderCommand> {
 
 
   const auth = program.command('auth').description('Show UMMAYA FriendliAI session-auth status').configureHelp(createSortedHelpConfig());
-  auth.command('login').description('Show how to log in with /login inside the TUI').option('--email <email>', 'Ignored in UMMAYA').option('--sso', 'Ignored in UMMAYA').option('--console', 'Ignored in UMMAYA').option('--claudeai', 'Ignored in UMMAYA').action(async ({
+  auth.command('login').description('Show how to log in with /login inside the TUI').option('--email <email>', 'Ignored in UMMAYA').option('--sso', 'Ignored in UMMAYA').option('--console', 'Ignored in UMMAYA').action(async ({
     email,
     sso,
     console: useConsole,
-    claudeai
   }: {
     email?: string;
     sso?: boolean;
     console?: boolean;
-    claudeai?: boolean;
   }) => {
     const {
       authLogin

package/tui/src/native-ts/file-index/index.ts

@@ -49,6 +49,7 @@ export class FileIndex {
   // During async build, tracks how many paths have bitmap/lowerPath filled.
   // search() uses this to search the ready prefix while build continues.
   private readyCount = 0
+  private buildGeneration = 0
 
   /**
    * Load paths from an array of strings.
@@ -56,6 +57,7 @@ export class FileIndex {
    * Automatically deduplicates paths.
    */
   loadFromFileList(fileList: string[]): void {
+    const generation = this.startBuild()
     // Deduplicate and filter empty strings (matches Rust HashSet behavior)
     const seen = new Set<string>()
     const paths: string[] = []
@@ -66,7 +68,7 @@ export class FileIndex {
       }
     }
 
-    this.buildIndex(paths)
+    this.buildIndex(paths, generation)
   }
 
   /**
@@ -88,18 +90,24 @@ export class FileIndex {
     const queryable = new Promise<void>(resolve => {
       markQueryable = resolve
     })
-    const done = this.buildAsync(fileList, markQueryable)
+    const generation = this.startBuild()
+    const done = this.buildAsync(fileList, markQueryable, generation)
     return { queryable, done }
   }
 
   private async buildAsync(
     fileList: string[],
     markQueryable: () => void,
+    generation: number,
   ): Promise<void> {
     const seen = new Set<string>()
     const paths: string[] = []
     let chunkStart = performance.now()
     for (let i = 0; i < fileList.length; i++) {
+      if (generation !== this.buildGeneration) {
+        markQueryable()
+        return
+      }
       const line = fileList[i]!
       if (line.length > 0 && !seen.has(line)) {
         seen.add(line)
@@ -112,11 +120,19 @@ export class FileIndex {
       }
     }
 
+    if (generation !== this.buildGeneration) {
+      markQueryable()
+      return
+    }
     this.resetArrays(paths)
 
     chunkStart = performance.now()
     let firstChunk = true
     for (let i = 0; i < paths.length; i++) {
+      if (generation !== this.buildGeneration) {
+        markQueryable()
+        return
+      }
       this.indexPath(i)
       if ((i & 0xff) === 0xff && performance.now() - chunkStart > CHUNK_MS) {
         this.readyCount = i + 1
@@ -125,21 +141,35 @@ export class FileIndex {
           firstChunk = false
         }
         await yieldToEventLoop()
+        if (generation !== this.buildGeneration) {
+          return
+        }
         chunkStart = performance.now()
       }
     }
+    if (generation !== this.buildGeneration) {
+      return
+    }
     this.readyCount = paths.length
     markQueryable()
   }
 
-  private buildIndex(paths: string[]): void {
+  private buildIndex(paths: string[], generation: number): void {
     this.resetArrays(paths)
     for (let i = 0; i < paths.length; i++) {
+      if (generation !== this.buildGeneration) {
+        return
+      }
       this.indexPath(i)
     }
     this.readyCount = paths.length
   }
 
+  private startBuild(): number {
+    this.buildGeneration += 1
+    return this.buildGeneration
+  }
+
   private resetArrays(paths: string[]): void {
     const n = paths.length
     this.paths = paths

package/tui/src/observability/surface.ts

@@ -32,11 +32,11 @@ const SURFACE_ATTRIBUTE_KEY = 'ummaya.ui.surface';
 const TRACER_NAME = 'ummaya/ui-l2';
 
 /**
- * Emit `ummaya.ui.surface=<surface>` on the active span if any. When no span
+ * Emit `ummaya.ui.surface=<surface>` on the active span when present. When no span
  * is active (e.g., outside a tracing context), open and immediately close a
  * one-shot span so the surface activation is recorded.
  *
- * The function is fail-soft: any OTEL provider failure becomes a console
+ * The function is fail-soft: OTEL provider failures become a console
  * warning rather than a crash so a logging fault never blocks the UI.
  */
 export function emitSurfaceActivation(surface: UiSurface, attrs?: Record<string, string | number | boolean>): void {

package/tui/src/probes/toolRegistryProbe.tsx

@@ -9,12 +9,13 @@
 //   bun run probe:tool-registry
 //
 // Expected success output:
-//   tool_registry: <N> entries verified (4 primitives) in <D>ms
+//   tool_registry: <N> entries verified (5 primitives) in <D>ms
 
 import { LookupPrimitive } from '../tools/LookupPrimitive/LookupPrimitive.js'
 import { ResolveLocationPrimitive } from '../tools/ResolveLocationPrimitive/ResolveLocationPrimitive.js'
 import { SubmitPrimitive } from '../tools/SubmitPrimitive/SubmitPrimitive.js'
 import { VerifyPrimitive } from '../tools/VerifyPrimitive/VerifyPrimitive.js'
+import { DocumentPrimitive } from '../tools/DocumentPrimitive/DocumentPrimitive.js'
 import { verifyBootRegistry } from '../services/toolRegistry/bootGuard.js'
 import type { Tool } from '../Tool.js'
 
@@ -23,6 +24,7 @@ const primitiveRegistry: readonly Tool[] = [
   ResolveLocationPrimitive as unknown as Tool,
   SubmitPrimitive as unknown as Tool,
   VerifyPrimitive as unknown as Tool,
+  DocumentPrimitive as unknown as Tool,
 ]
 
 const result = verifyBootRegistry(primitiveRegistry)

package/tui/src/projectOnboardingState.ts

@@ -47,17 +47,18 @@ export function isProjectOnboardingComplete(): boolean {
 }
 
 export function maybeMarkProjectOnboardingComplete(): void {
-  // Short-circuit on cached config — isProjectOnboardingComplete() hits
-  // the filesystem, and REPL.tsx calls this on every prompt submit.
   if (getCurrentProjectConfig().hasCompletedProjectOnboarding) {
     return
   }
-  if (isProjectOnboardingComplete()) {
-    saveCurrentProjectConfig(current => ({
+  saveCurrentProjectConfig(current => {
+    if (current.hasCompletedProjectOnboarding) {
+      return current
+    }
+    return {
       ...current,
       hasCompletedProjectOnboarding: true,
-    }))
-  }
+    }
+  })
 }
 
 export const shouldShowProjectOnboarding = memoize((): boolean => {

package/tui/src/query/chatMessageTypes.ts

@@ -0,0 +1,18 @@
+export type ChatMessageRole = 'system' | 'user' | 'assistant' | 'tool'
+
+export type ChatMessageToolCall = {
+  readonly id: string
+  readonly type: 'function'
+  readonly function: {
+    readonly name: string
+    readonly arguments: string
+  }
+}
+
+export type ChatMessage = {
+  readonly role: ChatMessageRole
+  readonly content: string
+  readonly name?: string | null
+  readonly tool_call_id?: string | null
+  readonly tool_calls?: readonly ChatMessageToolCall[] | null
+}

package/tui/src/query/chatMessagesBuilder.ts

@@ -44,7 +44,7 @@
 import type {
   ChatMessage,
   ChatMessageToolCall,
-} from '../ipc/frames.generated.js'
+} from './chatMessageTypes.js'
 
 // ---------------------------------------------------------------------------
 // Loose input types — mirror the CC ``Message`` shape WITHOUT importing

package/tui/src/query/deps.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from 'crypto'
-import { queryModelWithStreaming } from '../services/api/claude.js'
+import { queryModelWithStreaming } from '../services/api/ummaya.js'
 import { autoCompactIfNeeded } from '../services/compact/autoCompact.js'
 import { microcompactMessages } from '../services/compact/microCompact.js'
 

package/tui/src/query/messageGuards.ts

@@ -0,0 +1,106 @@
+import type {
+  AssistantMessage,
+  Message,
+  UserMessage,
+} from '../types/message.js'
+
+export type TextBlock = {
+  readonly type: 'text'
+  readonly text: string
+}
+
+export type ToolUseBlock = {
+  readonly type: 'tool_use'
+  readonly id: string
+  readonly name: string
+  readonly input: Record<string, unknown>
+}
+
+type ContentBlock = TextBlock | ToolUseBlock | Record<string, unknown>
+type MessageContentCarrier = {
+  readonly message?: {
+    readonly content?: unknown
+  }
+  readonly content?: unknown
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+export function contentBlocks(message: Message): readonly ContentBlock[] {
+  const content = messageContent(message)
+  return Array.isArray(content) ? content.filter(isRecord) : []
+}
+
+export function messageText(message: Message): string {
+  const content = messageContent(message)
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  return content
+    .filter(isRecord)
+    .filter((block): block is TextBlock => block.type === 'text')
+    .map(block => block.text)
+    .join('')
+}
+
+function messageContent(message: Message): unknown {
+  const candidate = message as MessageContentCarrier
+  return candidate.message?.content ?? candidate.content
+}
+
+export function toolUseBlocks(message: Message): readonly ToolUseBlock[] {
+  return contentBlocks(message).filter(
+    (block): block is ToolUseBlock =>
+      block.type === 'tool_use' &&
+      typeof block.id === 'string' &&
+      typeof block.name === 'string' &&
+      isRecord(block.input),
+  )
+}
+
+export function isAssistantMessage(message: Message): message is AssistantMessage {
+  return message.type === 'assistant'
+}
+
+export function isUserMessage(message: Message): message is UserMessage {
+  return message.type === 'user'
+}
+
+function hasVisibleUserText(message: Message): boolean {
+  return isUserMessage(message) && message.isMeta !== true &&
+    messageText(message).trim().length > 0
+}
+
+export function latestTextUserMessageIndex(messages: readonly Message[]): number {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index]
+    if (message && hasVisibleUserText(message)) return index
+  }
+  return -1
+}
+
+export function hasAssistantToolUseNamedAfterLatestTextUser(
+  messages: readonly Message[],
+  toolName: string,
+): boolean {
+  const latestUserIndex = latestTextUserMessageIndex(messages)
+  return messages.slice(latestUserIndex + 1).some(
+    message =>
+      isAssistantMessage(message) &&
+      toolUseBlocks(message).some(block => block.name === toolName),
+  )
+}
+
+export function cloneAssistantWithoutText(
+  message: AssistantMessage,
+): AssistantMessage {
+  const blocks = contentBlocks(message).filter(block => block.type !== 'text')
+  return {
+    ...message,
+    message: {
+      ...message.message,
+      content: blocks,
+    },
+  }
+}