V48 Gate 3 (implementation-only): grok-build-0.1 default, one DIV pass, empty-obf skip

Default xAI model to grok-build-0.1; set SynthesizeAssetPacks maxIterations to
1; raise LLM call timeout default to 180s and stall UI to match; skip Setup
input-comprehension LLM when Obfuscations are empty (no monorepo thrash).

Author: geraldarthurdavis

packages/agent-generics/src/execution/AgentLLMsRegistry.ts

@@ -20,12 +20,13 @@ import { Execution } from '@bitcode/execution-generics/Execution';
  * synthesis indefinitely (QA: a deposit run stuck for minutes on one
  * structured-output call). On timeout the call rejects and the failsafe/PTRR
  * retry handles it (a clean failure, never an indefinite hang). Tunable via
- * BITCODE_LLM_CALL_TIMEOUT_MS (default 90000); set 0 to disable the bound.
+ * BITCODE_LLM_CALL_TIMEOUT_MS (default 180000 for monorepo deposit chunks);
+ * set 0 to disable the bound.
  */
 function resolveLlmCallTimeoutMs(): number {
   const raw = Number(process?.env?.BITCODE_LLM_CALL_TIMEOUT_MS);
   if (Number.isFinite(raw)) return raw > 0 ? raw : 0;
-  return 90_000;
+  return 180_000;
 }
 
 async function callLlmWithTimeout(call: Promise<LLMOutput>, model: string): Promise<LLMOutput> {
@@ -177,8 +178,17 @@ export class AgentLLMsRegistry extends RegistryImpl<LLMConfig> {
    */
   private wrapWithExecutionTracking(llm: LLM, configKey: string): LLM {
     return async (input: LLMInput): Promise<LLMOutput> => {
-      // Create child execution for this LLM call
-      const model = input.config?.model || 'unknown';
+      // Prefer call-site model, then registered hierarchy config (avoids "unknown"
+      // timeout banners when the provider config is only on the registry path).
+      const registered = this.findConfigInHierarchy(configKey) || this.findConfigInHierarchy('default');
+      const model =
+        (typeof input.config?.model === 'string' && input.config.model.trim()
+          ? input.config.model.trim()
+          : null) ||
+        (typeof registered?.model === 'string' && registered.model.trim()
+          ? registered.model.trim()
+          : null) ||
+        'unknown';
       const llmExec = this.execution.child(`llm:${configKey}:${model}`);
 
       // Track execution

packages/generic-llms/src/defaults.ts

@@ -31,7 +31,8 @@ export function resolveDefaultLLMModel(
   switch (provider.toLowerCase()) {
     case 'xai':
     case 'grok':
-      return 'grok-4.5';
+      // Product default: grok-build-0.1 (overridable via BITCODE_LLM_MODEL).
+      return 'grok-build-0.1';
     case 'google':
       return 'gemini-2.5-flash';
     case 'anthropic':

packages/generic-llms/src/providers/xai.ts

@@ -4,15 +4,15 @@ import { LLMProvider, LLMConfig, LLMInput, LLMOutput } from '@bitcode/llm-generi
  * xAI / Grok provider — OpenAI-compatible client against https://api.x.ai/v1.
  *
  * Auth: XAI_API_KEY (preferred) or GROK_API_KEY.
- * Default model: grok-4.5 (overridable via BITCODE_LLM_MODEL).
+ * Default model: grok-build-0.1 (overridable via BITCODE_LLM_MODEL).
  *
  * Uses chat.completions (OpenAI-compatible surface on xAI). The Responses API
  * is also available on the same base URL; chat is sufficient for Bitcode's
  * message-shaped LLMInput.
  */
 
 const XAI_BASE_URL = 'https://api.x.ai/v1';
-const DEFAULT_XAI_MODEL = 'grok-4.5';
+const DEFAULT_XAI_MODEL = 'grok-build-0.1';
 
 function resolveXaiApiKey(env: NodeJS.ProcessEnv = process.env): string | undefined {
   const key = env.XAI_API_KEY || env.GROK_API_KEY;

packages/generic-llms/tests/unit/registry.test.ts

@@ -47,7 +47,7 @@ describe('factoryLLMRegistryWithProviders', () => {
 
     expect(defaults).toEqual({
       provider: 'xai',
-      model: 'grok-4.5',
+      model: 'grok-build-0.1',
     });
   });
 

packages/pipelines-generics/src/execution/PipelineLLMRegistry.ts

@@ -18,12 +18,13 @@ import { Execution } from '@bitcode/execution-generics/Execution';
  * Pipeline LLM calls must be time-bounded — the provider SDK sets no short
  * timeout, so a hung/very-slow generation stalls the entire inline synthesis.
  * On timeout the call rejects and the failsafe/PTRR retry handles it. Tunable
- * via BITCODE_LLM_CALL_TIMEOUT_MS (default 90000); set 0 to disable.
+ * via BITCODE_LLM_CALL_TIMEOUT_MS (default 180000 for monorepo deposit chunks);
+ * set 0 to disable.
  */
 function resolveLlmCallTimeoutMs(): number {
   const raw = Number(process?.env?.BITCODE_LLM_CALL_TIMEOUT_MS);
   if (Number.isFinite(raw)) return raw > 0 ? raw : 0;
-  return 90_000;
+  return 180_000;
 }
 
 async function callLlmWithTimeout(call: Promise<LLMOutput>, model: string): Promise<LLMOutput> {

packages/pipelines/asset-pack/src/__tests__/deposit-setup-discovery-agents.test.ts

@@ -127,6 +127,31 @@ describe('deposit Setup input-comprehension agent (boundary-mocked PTRR)', () =>
     expect(exec.get('setup', 'obfuscationComprehension')).toEqual(MOCK_OBFUSCATION_COMPREHENSION);
     expect(getBoundaryLLMCalls().length).toBeGreaterThan(0);
   }, 30000);
+
+  it('skips LLM when Obfuscations are empty (no monorepo inventory thrash / timeout)', async () => {
+    resetBoundaryLLMCalls();
+    const exec = new Execution('setup-node-empty-obfuscations');
+    const out = await runDepositInputComprehensionAgent(
+      {
+        ...DEPOSIT_INPUT,
+        obfuscations: '',
+      },
+      exec,
+    );
+
+    expect(out.success).toBe(true);
+    expect(out.comprehensionMode).toBe('empty-obfuscations-skip-llm');
+    expect(out.comprehension).toMatchObject({
+      obfuscatedPaths: [],
+      obfuscatedConcepts: [],
+      honorNotes: [],
+    });
+    expect(out.comprehension.summary).toMatch(/No explicit obfuscations/i);
+    expect(exec.get('setup', 'inputComprehension')).toEqual(out.comprehension);
+    expect(exec.get('setup', 'obfuscationComprehension')).toEqual(out.comprehension);
+    // Zero provider calls — this is the fix for empty-obfuscation deposit timeouts.
+    expect(getBoundaryLLMCalls().length).toBe(0);
+  });
 });
 
 describe('deposit Discovery lens agents (boundary-mocked PTRR)', () => {

packages/pipelines/asset-pack/src/agents/setup/deposit-input-comprehension-agent.ts

@@ -103,11 +103,42 @@ function findValue(execution: any, namespace: string, key: string): any {
   return execution?.findUp?.(namespace, key);
 }
 
+const EMPTY_OBFUSCATION_COMPREHENSION: DepositObfuscationComprehension = {
+  summary:
+    'No explicit obfuscations declared; synthesis honors the protected-IP exclusions as authoritative.',
+  obfuscatedPaths: [],
+  obfuscatedConcepts: [],
+  honorNotes: [],
+};
+
+function hasDeclaredObfuscations(value: unknown): boolean {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
 export default async function runDepositInputComprehensionAgent(input: any, execution: any) {
   const obfuscations = input?.obfuscations ?? findValue(execution, 'deposit', 'obfuscations') ?? null;
   const repository = input?.repository ?? findValue(execution, 'deposit', 'repository') ?? {};
   const inventory = input?.inventory ?? findValue(execution, 'deposit', 'inventory');
 
+  // Empty Obfuscations: no LLM work. Full monorepo inventory + PTRR plan/try
+  // against blank text was burning minutes and timing out (90s per call) with
+  // nothing to map. Protected-IP exclusions remain authoritative downstream.
+  if (!hasDeclaredObfuscations(obfuscations)) {
+    storeCrossPhaseArtifact(execution, 'setup', 'inputComprehension', EMPTY_OBFUSCATION_COMPREHENSION);
+    storeCrossPhaseArtifact(
+      execution,
+      'setup',
+      'obfuscationComprehension',
+      EMPTY_OBFUSCATION_COMPREHENSION,
+    );
+    return {
+      ...(input || {}),
+      success: true,
+      comprehension: EMPTY_OBFUSCATION_COMPREHENSION,
+      comprehensionMode: 'empty-obfuscations-skip-llm',
+    };
+  }
+
   // Prompt path: paths + samples only. Full inventory.sources stays on the
   // shared execution store for measurement; never enter PTRR user prompts
   // (JSON.stringify of monorepo sources → Invalid string length).
@@ -126,13 +157,8 @@ export default async function runDepositInputComprehensionAgent(input: any, exec
   // unwrap it to the agent's typed structured output (F27).
   const result = (raw as any)?.finalOutput ?? (raw as any)?.output ?? raw;
 
-  const comprehension: DepositObfuscationComprehension = (result as any)?.comprehension ?? {
-    summary:
-      'No explicit obfuscations declared; synthesis honors the protected-IP exclusions as authoritative.',
-    obfuscatedPaths: [],
-    obfuscatedConcepts: [],
-    honorNotes: [],
-  };
+  const comprehension: DepositObfuscationComprehension =
+    (result as any)?.comprehension ?? EMPTY_OBFUSCATION_COMPREHENSION;
 
   // Cross-phase artifacts: the Implementation synthesis agent and the deposit
   // Validation agent read this obfuscation guidance from OTHER phase siblings,

uapi/components/base/bitcode/execution/pipeline-execution-log.tsx

@@ -537,10 +537,10 @@ export function buildTerseLogCopyText(args: {
 }
 
 // Matches the default BITCODE_LLM_CALL_TIMEOUT_MS (AgentLLMsRegistry /
-// PipelineLLMRegistry) — past this many seconds with no new row, an in-flight
-// LLM call should already have timed out server-side, so continued silence is
-// a genuine-hang signal rather than a merely slow generation.
-const LIKELY_STALL_SECONDS = 90;
+// PipelineLLMRegistry, 180s) — past this many seconds with no new row, an
+// in-flight LLM call should already have timed out server-side, so continued
+// silence is a genuine-hang signal rather than a merely slow generation.
+const LIKELY_STALL_SECONDS = 180;
 
 /**
  * Build the live "While {Depositing|Reading}, during {Phase}, {Agent} Agent is