truecourse 0.5.4 → 0.5.5

package/cli.mjs

@@ -121036,6 +121036,172 @@ var init_rules_service = __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 node = new Node(value);
+        if (this.#head) {
+          this.#tail.next = node;
+          this.#tail = node;
+        } else {
+          this.#head = node;
+          this.#tail = node;
+        }
+        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_, resolve8, arguments_) => {
+    const result = (async () => function_(...arguments_))();
+    resolve8(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (function_, resolve8, reject, arguments_) => {
+    const queueItem = { reject };
+    new Promise((internalResolve) => {
+      queueItem.run = internalResolve;
+      queue.enqueue(queueItem);
+    }).then(run.bind(void 0, function_, resolve8, arguments_));
+    if (activeCount < concurrency) {
+      resumeNext();
+    }
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve8, reject) => {
+    enqueue(function_, resolve8, 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/dist/services/analysis-registry.js
 function registerChildProcess(repoId, child) {
   const entry = activeAnalyses.get(repoId);
@@ -123007,6 +123173,15 @@ var init_env = __esm({
 });
 
 // apps/server/dist/config/index.js
+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_config2 = __esm({
   "apps/server/dist/config/index.js"() {
@@ -123019,7 +123194,8 @@ var init_config2 = __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)
     };
   }
 });
@@ -123690,6 +123866,7 @@ var init_cli_provider = __esm({
   "apps/server/dist/services/llm/cli-provider.js"() {
     "use strict";
     init_logger();
+    init_p_limit();
     init_analysis_registry();
     init_esm5();
     init_config2();
@@ -123697,6 +123874,7 @@ var init_cli_provider = __esm({
     init_schemas2();
     BaseCLIProvider = class {
       maxRetries = config.claudeCodeMaxRetries ?? 2;
+      limit = pLimit(config.claudeCodeMaxConcurrency);
       debugDir = null;
       callCounter = 0;
       _analysisId = null;
@@ -123889,36 +124067,43 @@ var init_cli_provider = __esm({
       }
       /** Spawn CLI with retry on parse/validation failure. */
       async spawnAndParse(prompt, schema2, opts) {
-        const jsonSchemaStr = this.toJsonSchema(schema2);
-        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, schema2);
-          } 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(schema2);
+          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, schema2);
+            } 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`);
@@ -123941,14 +124126,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`);
@@ -123968,7 +124154,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(context.modules.filter((m) => m.serviceId).map((m) => [m.id, m.serviceId]));
@@ -123978,7 +124164,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`);
@@ -124005,15 +124192,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",
@@ -124022,7 +124217,11 @@ var init_cli_provider = __esm({
         };
         const settled = await Promise.allSettled(promises.map(([key, p2]) => p2.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++) {
@@ -124037,6 +124236,7 @@ var init_cli_provider = __esm({
         return result;
       }
       async generateAllViolationsWithLifecycle(contexts, onStepComplete) {
+        const onCallStart = contexts.onCallStart;
         const allResolved = [];
         const allNew = [];
         let serviceDescriptions = [];
@@ -124053,7 +124253,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}`);
@@ -124061,7 +124262,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) {
@@ -124075,7 +124278,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}`);
@@ -124083,7 +124287,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) {
@@ -124098,7 +124304,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}`);
@@ -124119,7 +124326,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 = {
@@ -124130,9 +124339,15 @@ 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, p2]) => p2.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];
@@ -124224,7 +124439,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") {
@@ -124245,7 +124460,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}`);
@@ -124268,7 +124484,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`);
@@ -124758,7 +124975,7 @@ var init_context_router = __esm({
 });
 
 // apps/server/dist/services/violation.service.js
-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");
@@ -124802,7 +125019,9 @@ async function generateViolations(input, onProgress, externalProvider) {
     service: serviceContext,
     database: dbContext,
     module: moduleContext,
-    onStepComplete: onProgress
+    onStepComplete: onProgress,
+    onCallStart,
+    onCallDone
   });
   const allViolations = [];
   let serviceDescriptions = [];
@@ -124839,7 +125058,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");
@@ -124880,7 +125099,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);
   });
@@ -125145,6 +125366,48 @@ 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}`;
 }
@@ -125483,12 +125746,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 || "",
@@ -125715,13 +125972,42 @@ 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 codeResults = await Promise.allSettled(batches.map((b) => provider.generateCodeViolations(b)));
+      const ll = llmTrackers.get(domain);
+      const codeResults = await Promise.allSettled(batches.map((b) => {
+        let started = false;
+        return provider.generateCodeViolations(b, {
+          onStart: () => {
+            started = true;
+            ll.onCallStart();
+          }
+        }).finally(() => ll.onCallDone(started));
+      }));
       const rawViolations = [];
       const resolvedIds = [];
       const unchangedIds = [];
@@ -125747,15 +126033,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) {
@@ -125795,6 +126085,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"))
@@ -125808,8 +126099,17 @@ async function runViolationPipeline(input) {
   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);
+      const archResult = await generateViolationsWithLifecycle(violationInput, void 0, provider, archOnCallStart, archOnCallDone);
       serviceDescriptions = archResult.serviceDescriptions;
       allResolvedLlmIds.push(...archResult.resolvedViolationIds);
       allNewLlmItems.push(...archResult.newViolations);
@@ -125831,7 +126131,7 @@ async function runViolationPipeline(input) {
       resolved.push(...lifecycle.resolved);
       resolvedRefs.push(...lifecycle.resolvedRefs);
     } else {
-      const archResult = await generateViolations(violationInput, (step) => tracker?.detail("architecture", step), provider);
+      const archResult = await generateViolations(violationInput, void 0, provider, archOnCallStart, archOnCallDone);
       serviceDescriptions = archResult.serviceDescriptions;
       for (const v of archResult.violations) {
         added.push({
@@ -126635,8 +126935,11 @@ import path16 from "node:path";
 init_analysis_store();
 init_analyze_core();
 init_analyze_persist();
+init_config2();
+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 core2 = await analyzeCore(project, { ...options, mode: "full" });
   return persistFullAnalysis(project, core2, startedAt);
 }
@@ -130733,7 +131036,7 @@ async function runHooksRun() {
 
 // tools/cli/src/index.ts
 var program2 = new Command();
-program2.name("truecourse").version("0.5.4").description("TrueCourse CLI \u2014 analyze your repository and open the dashboard");
+program2.name("truecourse").version("0.5.5").description("TrueCourse CLI \u2014 analyze your repository and open the dashboard");
 var dashboardCmd = program2.command("dashboard").description("Start the TrueCourse dashboard and open it in your browser").option("--reconfigure", "Re-prompt for console vs background service mode").option("--service", "Run as a background service (skips mode prompt)").option("--console", "Run in this terminal (skips mode prompt)").action(async (options) => {
   if (options.service && options.console) {
     console.error("error: --service and --console are mutually exclusive");