truecourse 0.5.4 → 0.5.5

package/server.mjs

@@ -23239,6 +23239,14 @@ var init_env = __esm({
 });
 
 // apps/server/src/config/index.ts
+function parsePositiveInt(envVar, raw, defaultValue) {
+  if (raw === void 0 || raw === "") return defaultValue;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new Error(`${envVar} must be a positive integer, got "${raw}"`);
+  }
+  return parsed;
+}
 var config;
 var init_config = __esm({
   "apps/server/src/config/index.ts"() {
@@ -23251,7 +23259,12 @@ var init_config = __esm({
       claudeCodeBinary: process.env.CLAUDE_CODE_BINARY || "claude",
       claudeCodeModel: process.env.CLAUDE_CODE_MODEL || "",
       claudeCodeTimeoutMs: parseInt(process.env.CLAUDE_CODE_TIMEOUT_MS || "120000", 10),
-      claudeCodeMaxRetries: parseInt(process.env.CLAUDE_CODE_MAX_RETRIES || "2", 10)
+      claudeCodeMaxRetries: parseInt(process.env.CLAUDE_CODE_MAX_RETRIES || "2", 10),
+      claudeCodeMaxConcurrency: parsePositiveInt(
+        "CLAUDE_CODE_MAX_CONCURRENCY",
+        process.env.CLAUDE_CODE_MAX_CONCURRENCY,
+        10
+      )
     };
   }
 });
@@ -124048,6 +124061,172 @@ var init_dist2 = __esm({
   }
 });
 
+// node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
+var Node, Queue;
+var init_yocto_queue = __esm({
+  "node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js"() {
+    Node = class {
+      value;
+      next;
+      constructor(value) {
+        this.value = value;
+      }
+    };
+    Queue = class {
+      #head;
+      #tail;
+      #size;
+      constructor() {
+        this.clear();
+      }
+      enqueue(value) {
+        const node2 = new Node(value);
+        if (this.#head) {
+          this.#tail.next = node2;
+          this.#tail = node2;
+        } else {
+          this.#head = node2;
+          this.#tail = node2;
+        }
+        this.#size++;
+      }
+      dequeue() {
+        const current = this.#head;
+        if (!current) {
+          return;
+        }
+        this.#head = this.#head.next;
+        this.#size--;
+        if (!this.#head) {
+          this.#tail = void 0;
+        }
+        return current.value;
+      }
+      peek() {
+        if (!this.#head) {
+          return;
+        }
+        return this.#head.value;
+      }
+      clear() {
+        this.#head = void 0;
+        this.#tail = void 0;
+        this.#size = 0;
+      }
+      get size() {
+        return this.#size;
+      }
+      *[Symbol.iterator]() {
+        let current = this.#head;
+        while (current) {
+          yield current.value;
+          current = current.next;
+        }
+      }
+      *drain() {
+        while (this.#head) {
+          yield this.dequeue();
+        }
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/p-limit@7.3.0/node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  let rejectOnClear = false;
+  if (typeof concurrency === "object") {
+    ({ concurrency, rejectOnClear = false } = concurrency);
+  }
+  validateConcurrency(concurrency);
+  if (typeof rejectOnClear !== "boolean") {
+    throw new TypeError("Expected `rejectOnClear` to be a boolean");
+  }
+  const queue = new Queue();
+  let activeCount = 0;
+  const resumeNext = () => {
+    if (activeCount < concurrency && queue.size > 0) {
+      activeCount++;
+      queue.dequeue().run();
+    }
+  };
+  const next = () => {
+    activeCount--;
+    resumeNext();
+  };
+  const run = async (function_, resolve7, arguments_) => {
+    const result = (async () => function_(...arguments_))();
+    resolve7(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (function_, resolve7, reject, arguments_) => {
+    const queueItem = { reject };
+    new Promise((internalResolve) => {
+      queueItem.run = internalResolve;
+      queue.enqueue(queueItem);
+    }).then(run.bind(void 0, function_, resolve7, arguments_));
+    if (activeCount < concurrency) {
+      resumeNext();
+    }
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve7, reject) => {
+    enqueue(function_, resolve7, reject, arguments_);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        if (!rejectOnClear) {
+          queue.clear();
+          return;
+        }
+        const abortError = AbortSignal.abort().reason;
+        while (queue.size > 0) {
+          queue.dequeue().reject(abortError);
+        }
+      }
+    },
+    concurrency: {
+      get: () => concurrency,
+      set(newConcurrency) {
+        validateConcurrency(newConcurrency);
+        concurrency = newConcurrency;
+        queueMicrotask(() => {
+          while (activeCount < concurrency && queue.size > 0) {
+            resumeNext();
+          }
+        });
+      }
+    },
+    map: {
+      async value(iterable, function_) {
+        const promises = Array.from(iterable, (value, index) => this(function_, value, index));
+        return Promise.all(promises);
+      }
+    }
+  });
+  return generator;
+}
+function validateConcurrency(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+}
+var init_p_limit = __esm({
+  "node_modules/.pnpm/p-limit@7.3.0/node_modules/p-limit/index.js"() {
+    init_yocto_queue();
+  }
+});
+
 // apps/server/src/services/analysis-registry.ts
 function registerAnalysis(repoId, analysisId) {
   const existing = activeAnalyses2.get(repoId);
@@ -126381,6 +126560,7 @@ var init_cli_provider = __esm({
   "apps/server/src/services/llm/cli-provider.ts"() {
     "use strict";
     init_logger();
+    init_p_limit();
     init_analysis_registry();
     init_esm4();
     init_config();
@@ -126388,6 +126568,7 @@ var init_cli_provider = __esm({
     init_schemas();
     BaseCLIProvider = class {
       maxRetries = config.claudeCodeMaxRetries ?? 2;
+      limit = pLimit(config.claudeCodeMaxConcurrency);
       debugDir = null;
       callCounter = 0;
       _analysisId = null;
@@ -126572,35 +126753,42 @@ var init_cli_provider = __esm({
       }
       /** Spawn CLI with retry on parse/validation failure. */
       async spawnAndParse(prompt, schema, opts) {
-        const jsonSchemaStr = this.toJsonSchema(schema);
-        const label = opts?.label ?? "call";
-        let lastError = null;
-        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
-          try {
-            const raw = await this.spawnCLI(prompt, jsonSchemaStr, opts);
-            this.dumpDebug(label, prompt, raw, jsonSchemaStr);
-            return this.parseAndValidate(raw, schema);
-          } catch (err) {
-            lastError = err;
-            if (this._abortSignal?.aborted) throw lastError;
-            if (attempt < this.maxRetries) {
-              log.warn(`[CLI] Attempt ${attempt + 1} failed, retrying... (${lastError.message})`);
+        return this.limit(async () => {
+          if (this._abortSignal?.aborted) {
+            throw this._abortSignal.reason ?? new DOMException("Analysis cancelled", "AbortError");
+          }
+          opts?.onStart?.();
+          const jsonSchemaStr = this.toJsonSchema(schema);
+          const label = opts?.label ?? "call";
+          let lastError = null;
+          for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            try {
+              const raw = await this.spawnCLI(prompt, jsonSchemaStr, opts);
+              this.dumpDebug(label, prompt, raw, jsonSchemaStr);
+              return this.parseAndValidate(raw, schema);
+            } catch (err) {
+              lastError = err;
+              if (this._abortSignal?.aborted) throw lastError;
+              if (attempt < this.maxRetries) {
+                log.warn(`[CLI] Attempt ${attempt + 1} failed, retrying... (${lastError.message})`);
+              }
             }
           }
-        }
-        throw lastError;
+          throw lastError;
+        });
       }
       // ---------------------------------------------------------------------------
       // LLMProvider implementation
       // ---------------------------------------------------------------------------
-      async generateServiceViolations(context) {
+      async generateServiceViolations(context, opts) {
         const { vars, idMap } = buildServiceTemplateVars(context);
         const prompt = getPrompt("violations-service", vars);
         log.info("[CLI] Service violations call starting...");
         const t0 = Date.now();
         const { data: object, usage: cliUsage } = await this.spawnAndParse(prompt, ServiceViolationOutputSchema, {
           extraArgs: ["--tools", ""],
-          label: "service"
+          label: "service",
+          onStart: opts?.onStart
         });
         const dur = Date.now() - t0;
         log.info(`[CLI] Service violations call done in ${dur}ms \u2014 ${object.violations.length} violations`);
@@ -126623,14 +126811,15 @@ var init_cli_provider = __esm({
           }))
         };
       }
-      async generateDatabaseViolations(context) {
+      async generateDatabaseViolations(context, opts) {
         const { vars, idMap } = buildDatabaseTemplateVars(context);
         const prompt = getPrompt("violations-database", vars);
         log.info("[CLI] Database violations call starting...");
         const t0 = Date.now();
         const { data: object, usage: cliUsage } = await this.spawnAndParse(prompt, DatabaseViolationOutputSchema, {
           extraArgs: ["--tools", ""],
-          label: "database"
+          label: "database",
+          onStart: opts?.onStart
         });
         const dur = Date.now() - t0;
         log.info(`[CLI] Database violations call done in ${dur}ms \u2014 ${object.violations.length} violations`);
@@ -126650,7 +126839,7 @@ var init_cli_provider = __esm({
           }))
         };
       }
-      async generateModuleViolations(context) {
+      async generateModuleViolations(context, opts) {
         const { vars, idMap } = buildModuleTemplateVars(context);
         const prompt = getPrompt("violations-module", vars);
         const moduleIdToServiceId = new Map(
@@ -126662,7 +126851,8 @@ var init_cli_provider = __esm({
         const { data: object, usage: cliUsage } = await this.spawnAndParse(prompt, ModuleViolationOutputSchema, {
           extraArgs: ["--tools", ""],
           label: "module",
-          timeoutMs: moduleTimeoutMs
+          timeoutMs: moduleTimeoutMs,
+          onStart: opts?.onStart
         });
         const dur = Date.now() - t0;
         log.info(`[CLI] Module violations call done in ${dur}ms \u2014 ${object.violations.length} violations`);
@@ -126689,15 +126879,23 @@ var init_cli_provider = __esm({
       }
       async generateAllViolations(contexts) {
         const onStepComplete = contexts.onStepComplete;
+        const onCallStart = contexts.onCallStart;
+        const onCallDone = contexts.onCallDone;
         const promises = [];
         if (contexts.service) {
-          promises.push(["service", this.generateServiceViolations(contexts.service)]);
+          promises.push(["service", this.generateServiceViolations(contexts.service, {
+            onStart: () => onCallStart?.("service")
+          })]);
         }
         if (contexts.database) {
-          promises.push(["database", this.generateDatabaseViolations(contexts.database)]);
+          promises.push(["database", this.generateDatabaseViolations(contexts.database, {
+            onStart: () => onCallStart?.("database")
+          })]);
         }
         if (contexts.module) {
-          promises.push(["module", this.generateModuleViolations(contexts.module)]);
+          promises.push(["module", this.generateModuleViolations(contexts.module, {
+            onStart: () => onCallStart?.("module")
+          })]);
         }
         const stepLabels = {
           service: "Service architecture checks done",
@@ -126705,10 +126903,17 @@ var init_cli_provider = __esm({
           module: "Module & function checks done"
         };
         const settled = await Promise.allSettled(promises.map(
-          ([key, p]) => p.then((v) => {
-            onStepComplete?.(stepLabels[key] || `${key} done`);
-            return v;
-          })
+          ([key, p]) => p.then(
+            (v) => {
+              onStepComplete?.(stepLabels[key] || `${key} done`);
+              onCallDone?.(key, true);
+              return v;
+            },
+            (err) => {
+              onCallDone?.(key, false);
+              throw err;
+            }
+          )
         ));
         const result = {};
         for (let i = 0; i < promises.length; i++) {
@@ -126723,6 +126928,7 @@ var init_cli_provider = __esm({
         return result;
       }
       async generateAllViolationsWithLifecycle(contexts, onStepComplete) {
+        const onCallStart = contexts.onCallStart;
         const allResolved = [];
         const allNew = [];
         let serviceDescriptions = [];
@@ -126739,7 +126945,8 @@ var init_cli_provider = __esm({
               const t0 = Date.now();
               const { data: object, usage: cliUsage } = await this.spawnAndParse(prompt, LifecycleServiceOutputSchema, {
                 extraArgs: ["--tools", ""],
-                label: "service-lifecycle"
+                label: "service-lifecycle",
+                onStart: () => onCallStart?.("service")
               });
               const dur = Date.now() - t0;
               log.info(`[CLI] Lifecycle service call done in ${dur}ms \u2014 resolved: ${object.resolvedViolationIds.length}, new: ${object.newViolations.length}`);
@@ -126747,7 +126954,9 @@ var init_cli_provider = __esm({
               return object;
             })()]);
           } else {
-            promises.push(["service-normal", this.generateServiceViolations(ctx)]);
+            promises.push(["service-normal", this.generateServiceViolations(ctx, {
+              onStart: () => onCallStart?.("service")
+            })]);
           }
         }
         if (contexts.database) {
@@ -126761,7 +126970,8 @@ var init_cli_provider = __esm({
               const t0 = Date.now();
               const { data: object, usage: cliUsage } = await this.spawnAndParse(prompt, DiffViolationOutputSchema, {
                 extraArgs: ["--tools", ""],
-                label: "database-lifecycle"
+                label: "database-lifecycle",
+                onStart: () => onCallStart?.("database")
               });
               const dur = Date.now() - t0;
               log.info(`[CLI] Lifecycle database call done in ${dur}ms \u2014 resolved: ${object.resolvedViolationIds.length}, new: ${object.newViolations.length}`);
@@ -126769,7 +126979,9 @@ var init_cli_provider = __esm({
               return object;
             })()]);
           } else {
-            promises.push(["database-normal", this.generateDatabaseViolations(ctx)]);
+            promises.push(["database-normal", this.generateDatabaseViolations(ctx, {
+              onStart: () => onCallStart?.("database")
+            })]);
           }
         }
         if (contexts.module) {
@@ -126786,7 +126998,8 @@ var init_cli_provider = __esm({
               const t0 = Date.now();
               const { data: object, usage: cliUsage } = await this.spawnAndParse(prompt, DiffViolationOutputSchema, {
                 extraArgs: ["--tools", ""],
-                label: "module-lifecycle"
+                label: "module-lifecycle",
+                onStart: () => onCallStart?.("module")
               });
               const dur = Date.now() - t0;
               log.info(`[CLI] Lifecycle module call done in ${dur}ms \u2014 resolved: ${object.resolvedViolationIds.length}, new: ${object.newViolations.length}`);
@@ -126807,7 +127020,9 @@ var init_cli_provider = __esm({
               };
             })()]);
           } else {
-            promises.push(["module-normal", this.generateModuleViolations(ctx)]);
+            promises.push(["module-normal", this.generateModuleViolations(ctx, {
+              onStart: () => onCallStart?.("module")
+            })]);
           }
         }
         const stepLabels = {
@@ -126818,11 +127033,20 @@ var init_cli_provider = __esm({
           module: "Module checks done",
           "module-normal": "Module checks done"
         };
+        const baseKey = (key) => key.replace("-normal", "");
+        const onCallDone = contexts.onCallDone;
         const settled = await Promise.allSettled(promises.map(
-          ([key, p]) => p.then((v) => {
-            onStepComplete?.(stepLabels[key] || `${key} done`);
-            return v;
-          })
+          ([key, p]) => p.then(
+            (v) => {
+              onStepComplete?.(stepLabels[key] || `${key} done`);
+              onCallDone?.(baseKey(key), true);
+              return v;
+            },
+            (err) => {
+              onCallDone?.(baseKey(key), false);
+              throw err;
+            }
+          )
         ));
         for (let i = 0; i < promises.length; i++) {
           const [key] = promises[i];
@@ -126914,7 +127138,7 @@ var init_cli_provider = __esm({
         }
         return { resolvedViolationIds: allResolved, newViolations: allNew, serviceDescriptions };
       }
-      async generateCodeViolations(context) {
+      async generateCodeViolations(context, opts) {
         const hasExisting = context.existingViolations && context.existingViolations.length > 0;
         let promptName;
         if (context.tier === "metadata") {
@@ -126935,7 +127159,8 @@ var init_cli_provider = __esm({
           const { data: object2, usage: cliUsage2 } = await this.spawnAndParse(prompt, CodeViolationLifecycleOutputSchema, {
             extraArgs: codeExtraArgs,
             label: "code-lifecycle",
-            timeoutMs: codeTimeoutMs
+            timeoutMs: codeTimeoutMs,
+            onStart: opts?.onStart
           });
           const dur2 = Date.now() - t0;
           log.info(`[CLI] Code violations call done in ${dur2}ms \u2014 new: ${object2.newViolations.length}, resolved: ${object2.resolvedViolationIds.length}, unchanged: ${object2.unchangedViolationIds.length}`);
@@ -126958,7 +127183,8 @@ var init_cli_provider = __esm({
         const { data: object, usage: cliUsage } = await this.spawnAndParse(prompt, CodeViolationOutputSchema, {
           extraArgs: codeExtraArgs,
           label: "code",
-          timeoutMs: codeTimeoutMs
+          timeoutMs: codeTimeoutMs,
+          onStart: opts?.onStart
         });
         const dur = Date.now() - t0;
         log.info(`[CLI] Code violations call done in ${dur}ms \u2014 ${object.violations.length} violations`);
@@ -146488,7 +146714,7 @@ function routeContext(rules, fileAnalyses, fileContents) {
 
 // apps/server/src/services/violation.service.ts
 init_provider();
-async function generateViolations(input, onProgress, externalProvider) {
+async function generateViolations(input, onProgress, externalProvider, onCallStart, onCallDone) {
   const provider = externalProvider ?? createLLMProvider();
   const archRules = (input.llmRules || []).filter((r) => r.category === "service");
   const dbRules = (input.llmRules || []).filter((r) => r.category === "database");
@@ -146532,7 +146758,9 @@ async function generateViolations(input, onProgress, externalProvider) {
     service: serviceContext,
     database: dbContext,
     module: moduleContext,
-    onStepComplete: onProgress
+    onStepComplete: onProgress,
+    onCallStart,
+    onCallDone
   });
   const allViolations = [];
   let serviceDescriptions = [];
@@ -146569,7 +146797,7 @@ async function generateViolations(input, onProgress, externalProvider) {
   }
   return { violations: allViolations, serviceDescriptions };
 }
-async function generateViolationsWithLifecycle(input, onProgress, externalProvider) {
+async function generateViolationsWithLifecycle(input, onProgress, externalProvider, onCallStart, onCallDone) {
   const provider = externalProvider ?? createLLMProvider();
   const archRules = (input.llmRules || []).filter((r) => r.category === "service");
   const dbRules = (input.llmRules || []).filter((r) => r.category === "database");
@@ -146610,7 +146838,9 @@ async function generateViolationsWithLifecycle(input, onProgress, externalProvid
   const result = await provider.generateAllViolationsWithLifecycle({
     service: serviceContext,
     database: dbContext,
-    module: moduleContext
+    module: moduleContext,
+    onCallStart,
+    onCallDone
   }, (step) => {
     onProgress?.(step);
   });
@@ -146867,6 +147097,44 @@ init_logger();
 function throwIfAborted(signal) {
   if (signal?.aborted) throw new DOMException("Analysis cancelled", "AbortError");
 }
+function formatElapsed(ms) {
+  const totalSec = Math.floor(ms / 1e3);
+  const min = Math.floor(totalSec / 60);
+  const sec = totalSec % 60;
+  return min === 0 ? `${sec}s` : `${min}m ${sec}s`;
+}
+function renderLlmDetail(s) {
+  const parts = [];
+  if (s.detCount > 0) parts.push(`${s.detCount} det`);
+  parts.push(`LLM ${s.done}/${s.total}`);
+  if (s.running > 0) parts.push(`${s.running} running`);
+  if (s.elapsedMs >= 1e3) parts.push(formatElapsed(s.elapsedMs));
+  return parts.join(" \xB7 ");
+}
+function createLlmTracker(tracker, domain, detCount, total) {
+  let done = 0;
+  let running = 0;
+  const t0 = Date.now();
+  const render = () => tracker?.detail(domain, renderLlmDetail({
+    detCount,
+    total,
+    done,
+    running,
+    elapsedMs: Date.now() - t0
+  }));
+  return {
+    initialDetail: renderLlmDetail({ detCount, total, done: 0, running: 0, elapsedMs: 0 }),
+    onCallStart: () => {
+      running++;
+      render();
+    },
+    onCallDone: (started) => {
+      if (started) running--;
+      done++;
+      render();
+    }
+  };
+}
 function getDetComparisonKey(v) {
   return `${v.ruleKey}::${v.serviceName}::${v.moduleName || ""}::${v.methodName || ""}::${v.title}`;
 }
@@ -147210,11 +147478,6 @@ async function runViolationPipeline(input) {
   const allNewLlmItems = [];
   const allResolvedLlmIds = [];
   const hasArchLlm = enableLlmRules !== false && !llmSkipped;
-  if (hasArchLlm) tracker?.start("architecture", "Running LLM analysis...");
-  for (const [domain] of domainCodeBatches) {
-    const detCount = violationsByDomain.get(domain) ?? 0;
-    tracker?.start(domain, detCount > 0 ? `${detCount} det, running LLM...` : "Running LLM...");
-  }
   const previousDetForComparison = previousDetViolations.map((v) => ({
     ruleKey: v.ruleKey,
     serviceName: v.targetServiceName || "",
@@ -147439,14 +147702,43 @@ async function runViolationPipeline(input) {
     existingDatabaseViolations: void 0,
     existingModuleViolations: hasLlmOnlyExistingViolations ? existingModuleViolations : void 0
   };
+  const llmTrackers = /* @__PURE__ */ new Map();
+  for (const [domain, batches] of domainCodeBatches) {
+    const detCount = violationsByDomain.get(domain) ?? 0;
+    const ll = createLlmTracker(tracker, domain, detCount, batches.length);
+    llmTrackers.set(domain, ll);
+    tracker?.start(domain, ll.initialDetail);
+  }
+  if (dbSchemaContext && !llmSkipped && !domainCodeBatches.has("database")) {
+    const detCount = violationsByDomain.get("database") ?? 0;
+    const ll = createLlmTracker(tracker, "database", detCount, 1);
+    llmTrackers.set("database", ll);
+    tracker?.start("database", ll.initialDetail);
+  }
+  if (hasArchLlm) {
+    const detCount = violationsByDomain.get("architecture") ?? 0;
+    const archTotal2 = 1 + (violationModules && violationModules.length > 0 ? 1 : 0);
+    const ll = createLlmTracker(tracker, "architecture", detCount, archTotal2);
+    llmTrackers.set("architecture", ll);
+    tracker?.start("architecture", ll.initialDetail);
+  }
   const domainLlmPromises = [];
   for (const [domain, batches] of domainCodeBatches) {
     domainLlmPromises.push((async () => {
       const detCount = violationsByDomain.get(domain) ?? 0;
       log.info(`[LLM] ${domain}: starting (${batches.length} code batches)`);
       const t0 = Date.now();
+      const ll = llmTrackers.get(domain);
       const codeResults = await Promise.allSettled(
-        batches.map((b) => provider.generateCodeViolations(b))
+        batches.map((b) => {
+          let started = false;
+          return provider.generateCodeViolations(b, {
+            onStart: () => {
+              started = true;
+              ll.onCallStart();
+            }
+          }).finally(() => ll.onCallDone(started));
+        })
       );
       const rawViolations = [];
       const resolvedIds = [];
@@ -147471,15 +147763,19 @@ async function runViolationPipeline(input) {
   }
   let dbSchemaViolations = [];
   if (dbSchemaContext && !llmSkipped) {
-    if (!domainCodeBatches.has("database")) {
-      const detCount = violationsByDomain.get("database") ?? 0;
-      tracker?.start("database", detCount > 0 ? `${detCount} det, running LLM...` : "Running LLM...");
-    }
+    const schemaLl = domainCodeBatches.has("database") ? void 0 : llmTrackers.get("database");
     domainLlmPromises.push((async () => {
       log.info(`[LLM] database-schema: starting`);
       const t0 = Date.now();
+      let started = false;
       try {
-        const dbResult = await provider.generateDatabaseViolations(dbSchemaContext);
+        const dbResult = await provider.generateDatabaseViolations(dbSchemaContext, {
+          onStart: () => {
+            started = true;
+            schemaLl?.onCallStart();
+          }
+        });
+        schemaLl?.onCallDone(started);
         const dur = Date.now() - t0;
         log.info(`[LLM] database-schema: done in ${dur}ms \u2014 ${dbResult.violations.length} violations`);
         for (const v of dbResult.violations) {
@@ -147519,6 +147815,7 @@ async function runViolationPipeline(input) {
         }
         return { domain: "database-schema", violations: [], resolvedIds: [], unchangedIds: [] };
       } catch (err) {
+        schemaLl?.onCallDone(started);
         const dur = Date.now() - t0;
         log.warn(`[LLM] database-schema: failed in ${dur}ms \u2014 ${err instanceof Error ? err.message : String(err)}`);
         if (!domainCodeBatches.has("database")) tracker?.error("database", `Schema LLM failed`);
@@ -147530,11 +147827,22 @@ async function runViolationPipeline(input) {
   onProgress?.({ step: "analyzing", percent: 86, detail: "Analyzing architecture & modules..." });
   const llmRulePromise = (async () => {
     if (enableLlmRules === false || llmSkipped) return;
+    const archLl = llmTrackers.get("architecture");
+    const archStarted = /* @__PURE__ */ new Set();
+    const archOnCallStart = (key) => {
+      archStarted.add(key);
+      archLl?.onCallStart();
+    };
+    const archOnCallDone = (key) => {
+      archLl?.onCallDone(archStarted.has(key));
+    };
     if (hasLlmOnlyExistingViolations) {
       const archResult = await generateViolationsWithLifecycle(
         violationInput,
-        (step) => tracker?.detail("architecture", step),
-        provider
+        void 0,
+        provider,
+        archOnCallStart,
+        archOnCallDone
       );
       serviceDescriptions = archResult.serviceDescriptions;
       allResolvedLlmIds.push(...archResult.resolvedViolationIds);
@@ -147563,8 +147871,10 @@ async function runViolationPipeline(input) {
     } else {
       const archResult = await generateViolations(
         violationInput,
-        (step) => tracker?.detail("architecture", step),
-        provider
+        void 0,
+        provider,
+        archOnCallStart,
+        archOnCallDone
       );
       serviceDescriptions = archResult.serviceDescriptions;
       for (const v of archResult.violations) {
@@ -148282,8 +148592,13 @@ function makeDenormalizer(graph) {
 }
 
 // apps/server/src/commands/analyze-in-process.ts
+init_config();
+init_logger();
 async function analyzeInProcess(project, options = {}) {
   const startedAt = Date.now();
+  log.info(
+    `[LLM] Provider: claude-code, model: ${config.claudeCodeModel || "default"}, maxConcurrency: ${config.claudeCodeMaxConcurrency}`
+  );
   const core = await analyzeCore(project, { ...options, mode: "full" });
   return persistFullAnalysis(project, core, startedAt);
 }
@@ -154034,7 +154349,6 @@ async function main() {
   if (wipeLegacyPostgresData()) {
     log.info("[Storage] Legacy Postgres data wiped. Re-analyze to repopulate.");
   }
-  log.info(`[LLM] Provider: claude-code, model: ${config.claudeCodeModel || "default"}`);
   const app = (0, import_express10.default)();
   const httpServer = createServer(app);
   setupSocket(httpServer);