ummaya 0.2.4 → 0.2.6

package/tui/src/main.tsx

@@ -92,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';
@@ -137,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();
@@ -161,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
@@ -539,7 +559,7 @@ async function run(): Promise<CommanderCommand> {
     // If not provided but flag is present, value will be true
     // The actual filtering is handled in debug.ts by parsing process.argv
     return true;
-  }).addOption(new Option('--debug-to-stderr', 'Enable debug mode (to stderr)').hideHelp()).option('--debug-file <path>', 'Write debug logs to a specific file path (implicitly enables debug mode)', () => true).option('--verbose', 'Override verbose mode setting from config', () => true).option('-p, --print', 'Print response and exit (useful for pipes). Note: The workspace trust dialog is skipped when UMMAYA is run with the -p mode. Only use this flag in directories you trust.', () => true).option('--bare', 'Minimal mode: skip hooks, LSP, plugin sync, attribution, auto-memory, background prefetches, keychain reads, and CLAUDE.md auto-discovery. Sets CLAUDE_CODE_SIMPLE=1. FriendliAI auth still requires an active /login session. Skills still resolve via /skill-name. Explicitly provide context via: --system-prompt[-file], --append-system-prompt[-file], --add-dir, --mcp-config, --settings, --agents, --plugin-dir.', () => true).addOption(new Option('--init', 'Run Setup hooks with init trigger, then continue').hideHelp()).addOption(new Option('--init-only', 'Run Setup and SessionStart:startup hooks, then exit').hideHelp()).addOption(new Option('--maintenance', 'Run Setup hooks with maintenance trigger, then continue').hideHelp()).addOption(new Option('--output-format <format>', 'Output format (only works with --print): "text" (default), "json" (single result), or "stream-json" (realtime streaming)').choices(['text', 'json', 'stream-json'])).addOption(new Option('--json-schema <schema>', 'JSON Schema for structured output validation. ' + 'Example: {"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}').argParser(String)).option('--include-hook-events', 'Include all hook lifecycle events in the output stream (only works with --output-format=stream-json)', () => true).option('--include-partial-messages', 'Include partial message chunks as they arrive (only works with --print and --output-format=stream-json)', () => true).addOption(new Option('--input-format <format>', 'Input format (only works with --print): "text" (default), or "stream-json" (realtime streaming input)').choices(['text', 'stream-json'])).option('--mcp-debug', '[DEPRECATED. Use --debug instead] Enable MCP debug mode (shows MCP server errors)', () => true).option('--dangerously-skip-permissions', 'Bypass all permission checks. Recommended only for sandboxes with no internet access.', () => true).option('--allow-dangerously-skip-permissions', 'Enable bypassing all permission checks as an option, without it being enabled by default. Recommended only for sandboxes with no internet access.', () => true).addOption(new Option('--thinking <mode>', 'Thinking mode: enabled (equivalent to adaptive), disabled').choices(['enabled', 'adaptive', 'disabled']).hideHelp()).addOption(new Option('--max-thinking-tokens <tokens>', '[DEPRECATED. Use --thinking instead for newer models] Maximum number of thinking tokens (only works with --print)').argParser(Number).hideHelp()).addOption(new Option('--max-turns <turns>', 'Maximum number of agentic turns in non-interactive mode. This will early exit the conversation after the specified number of turns. (only works with --print)').argParser(Number).hideHelp()).addOption(new Option('--max-budget-usd <amount>', 'Maximum dollar amount to spend on API calls (only works with --print)').argParser(value => {
+  }).addOption(new Option('--debug-to-stderr', 'Enable debug mode (to stderr)').hideHelp()).option('--debug-file <path>', 'Write debug logs to a specific file path (implicitly enables debug mode)', () => true).option('--verbose', 'Override verbose mode setting from config', () => true).option('-p, --print', 'Print response and exit (useful for pipes). Note: The workspace trust dialog is skipped when UMMAYA is run with the -p mode. Only use this flag in directories you trust.', () => true).option('--bare', 'Minimal mode: skip hooks, LSP, plugin sync, attribution, auto-memory, background prefetches, keychain reads, and project-memory auto-discovery. Enables minimal compatibility mode. FriendliAI auth still requires an active /login session. Skills still resolve via /skill-name. Explicitly provide context via: --system-prompt[-file], --append-system-prompt[-file], --add-dir, --mcp-config, --settings, --agents, --plugin-dir.', () => true).addOption(new Option('--init', 'Run Setup hooks with init trigger, then continue').hideHelp()).addOption(new Option('--init-only', 'Run Setup and SessionStart:startup hooks, then exit').hideHelp()).addOption(new Option('--maintenance', 'Run Setup hooks with maintenance trigger, then continue').hideHelp()).addOption(new Option('--output-format <format>', 'Output format (only works with --print): "text" (default), "json" (single result), or "stream-json" (realtime streaming)').choices(['text', 'json', 'stream-json'])).addOption(new Option('--json-schema <schema>', 'JSON Schema for structured output validation. ' + 'Example: {"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}').argParser(String)).option('--include-hook-events', 'Include all hook lifecycle events in the output stream (only works with --output-format=stream-json)', () => true).option('--include-partial-messages', 'Include partial message chunks as they arrive (only works with --print and --output-format=stream-json)', () => true).addOption(new Option('--input-format <format>', 'Input format (only works with --print): "text" (default), or "stream-json" (realtime streaming input)').choices(['text', 'stream-json'])).option('--mcp-debug', '[DEPRECATED. Use --debug instead] Enable MCP debug mode (shows MCP server errors)', () => true).option('--dangerously-skip-permissions', 'Bypass all permission checks. Recommended only for sandboxes with no internet access.', () => true).option('--allow-dangerously-skip-permissions', 'Enable bypassing all permission checks as an option, without it being enabled by default. Recommended only for sandboxes with no internet access.', () => true).addOption(new Option('--thinking <mode>', 'Thinking mode: enabled (equivalent to adaptive), disabled').choices(['enabled', 'adaptive', 'disabled']).hideHelp()).addOption(new Option('--max-thinking-tokens <tokens>', '[DEPRECATED. Use --thinking instead for newer models] Maximum number of thinking tokens (only works with --print)').argParser(Number).hideHelp()).addOption(new Option('--max-turns <turns>', 'Maximum number of agentic turns in non-interactive mode. This will early exit the conversation after the specified number of turns. (only works with --print)').argParser(Number).hideHelp()).addOption(new Option('--max-budget-usd <amount>', 'Maximum dollar amount to spend on API calls (only works with --print)').argParser(value => {
     const amount = Number(value);
     if (isNaN(amount) || amount <= 0) {
       throw new Error('--max-budget-usd must be a positive number greater than 0');
@@ -1095,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 => {
@@ -1109,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({});
@@ -2460,7 +2480,7 @@ async function run(): Promise<CommanderCommand> {
     } = await import('./cli/handlers/mcp.js');
     await mcpAddJsonHandler(name, json, options);
   });
-  mcp.command('add-from-claude-desktop').description('Import MCP servers from Claude Desktop (Mac and WSL only)').option('-s, --scope <scope>', 'Configuration scope (local, user, or project)', 'local').action(async (options: {
+  mcp.command('add-from-desktop').description('Import MCP servers from a desktop MCP config (Mac and WSL only)').option('-s, --scope <scope>', 'Configuration scope (local, user, or project)', 'local').action(async (options: {
     scope?: string;
   }) => {
     const {
@@ -2477,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
@@ -2494,8 +2512,7 @@ async function run(): Promise<CommanderCommand> {
     await authLogin({
       email,
       sso,
-      console: useConsole,
-      claudeai
+      console: useConsole
     });
   });
   auth.command('status').description('Show authentication status').option('--json', 'Output as JSON (default)').option('--text', 'Output as human-readable text').action(async (opts: {

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,
+    },
+  }
+}