@codeyam/codeyam-cli 0.1.0-staging.b8a55ba → 0.1.0-staging.c90f8c9

package/analyzer-template/project/controller/startController.ts

@@ -13,8 +13,8 @@ export enum ControllerPhase {
   Startup = 'STARTUP',
   RepoCheckout = 'REPO_CHECKOUT',
   Analysis = 'ANALYSIS',
+  AnalysisProducing = 'ANALYSIS_PRODUCING',
   Serving = 'SERVING',
-  Orchestrating = 'ORCHESTRATING',
   Complete = 'COMPLETE',
 }
 
@@ -30,6 +30,7 @@ type ControllerContext =
   | { phase: ControllerPhase.Startup; info: null }
   | { phase: ControllerPhase.RepoCheckout; info: null }
   | { phase: ControllerPhase.Analysis; info: null }
+  | { phase: ControllerPhase.AnalysisProducing; info: null }
   | { phase: ControllerPhase.Serving; info: ServingCodeYamInfo }
   | { phase: ControllerPhase.Complete; info: null };
 
@@ -100,6 +101,11 @@ export class Controller extends EventEmitter {
     this.setPhase({ phase: ControllerPhase.Analysis, info: null });
   }
 
+  setAnalysisProducingPhase(): void {
+    this.setPhase({ phase: ControllerPhase.AnalysisProducing, info: null });
+    this.emit('analysisProducing');
+  }
+
   setServingPhase(info: ServingCodeYamInfo): void {
     this.setPhase({ phase: ControllerPhase.Serving, info });
   }
@@ -116,6 +122,15 @@ export class Controller extends EventEmitter {
     );
   }
 
+  hasStartedProducing(): boolean {
+    // Analysis is producing once we've moved past the Analysis phase
+    return (
+      this.context.phase === ControllerPhase.AnalysisProducing ||
+      this.context.phase === ControllerPhase.Serving ||
+      this.context.phase === ControllerPhase.Complete
+    );
+  }
+
   async close(): Promise<void> {
     if (!this.server) return;
 

package/analyzer-template/project/executeLibraryFunctionDirect.ts

@@ -33,11 +33,15 @@ export default async function executeLibraryFunctionDirect(
   // Generate the execution script
   const script = directExecutionScript(file, entity, analysis, scenario);
 
+  // Use .ts extension for TypeScript source files so tsx can resolve TS imports
+  const isTypeScript = file.path.endsWith('.ts') || file.path.endsWith('.tsx');
+  const scriptExtension = isTypeScript ? '.ts' : '.mjs';
+
   // Write the script to a temporary file
   const scriptPath = path.join(
     PROJECT_RELATIVE_PATH,
     '.codeyam-execution',
-    `${entity.sha}_${scenario.id}.mjs`,
+    `${entity.sha}_${scenario.id}${scriptExtension}`,
   );
 
   await writeFile(scriptPath, script);
@@ -54,10 +58,10 @@ export default async function executeLibraryFunctionDirect(
       command: 'npx',
       args: ['tsx', scriptPath],
       workingDir: PROJECT_RELATIVE_PATH,
-      onData: async (data) => {
+      onData: (data) => {
         stdout += data;
       },
-      onError: async (data) => {
+      onError: (data) => {
         stderr += data;
       },
       processName: 'library-function-execution',

package/analyzer-template/project/mocks/analyzeFileMock.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/require-await */
 import {
   Analysis,
   AnalysisMap,
@@ -47,7 +48,7 @@ const standaloneComponentAnalysis = {
         'The counter is initialized at 0, with the ability to increment and decrement the count.',
       metadata: {
         dataMapping: {},
-        keyAttributeInstructions: {},
+        coveredFlows: [],
         data: {
           argumentsData: [],
           mockData: {},
@@ -221,7 +222,7 @@ async function analyzeReturnsSimplePropsFile(): Promise<{
                 'A user who is under 18 years old and is currently active.',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [
                     {
@@ -242,7 +243,7 @@ async function analyzeReturnsSimplePropsFile(): Promise<{
                 'A user who is between 18 and 39 years old and is currently active.',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [
                     {
@@ -263,7 +264,7 @@ async function analyzeReturnsSimplePropsFile(): Promise<{
                 'A user who is 40 years or older and is currently active.',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [
                     {
@@ -284,7 +285,7 @@ async function analyzeReturnsSimplePropsFile(): Promise<{
                 'A user who is under 18 years old and is currently inactive.',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [
                     {
@@ -305,7 +306,7 @@ async function analyzeReturnsSimplePropsFile(): Promise<{
                 'A user who is between 18 and 39 years old and is currently inactive.',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [
                     {
@@ -378,7 +379,7 @@ async function analyzeReturnsImportedComponentsFile(): Promise<{
               description: 'Default scenario description',
               metadata: {
                 dataMapping: {},
-                keyAttributeInstructions: {},
+                coveredFlows: [],
                 data: {
                   argumentsData: [],
                   mockData: {},

package/analyzer-template/project/orchestrateCapture/KyselyAnalysisLoader.ts

@@ -46,13 +46,10 @@ export default class KyselyAnalysisLoader implements AnalysisLoader {
             'status',
           ])
           // Base condition: readyToBeCaptured = true
-          // Use json_extract for SQLite (returns 1 for boolean true)
+          // Use -> operator which works in both PostgreSQL and SQLite
+          // Both return a value that compares equal to string 'true'
           .where((eb) =>
-            eb(
-              sql`json_extract(${sql.ref('status')}, '$.readyToBeCaptured')`,
-              '=',
-              sql`1`,
-            ),
+            eb(sql`${sql.ref('status')} -> 'readyToBeCaptured'`, '=', 'true'),
           )
           // Project filter (always required)
           .where('project_id', '=', this.config.project.id);

package/analyzer-template/project/orchestrateCapture/SequentialCaptureTaskRunner.ts

@@ -94,7 +94,13 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
 
     // In CAPTURE_ONLY mode, run directly from the main project folder (skip rsync)
     // This preserves any manual edits made to generated files
-    const captureOnly = process.env.CAPTURE_ONLY === 'true';
+    const captureOnlyEnvValue = process.env.CAPTURE_ONLY;
+    const captureOnly = captureOnlyEnvValue === 'true';
+
+    console.log(
+      `CodeYam: CAPTURE_ONLY env = ${captureOnlyEnvValue === undefined ? 'undefined' : `"${captureOnlyEnvValue}"`}`,
+    );
+
     const capturerPath = captureOnly
       ? parentDir
       : path.normalize(path.join(parentDir, 'capturer-1'));

package/analyzer-template/project/orchestrateCapture.ts

@@ -50,6 +50,9 @@ interface OrchestrateCaptureArgs {
   taskRunner: CaptureTaskRunner;
   analysisLoader?: AnalysisLoader;
   pollingInterval?: number;
+  // Optional commit for metadata/progress tracking only (not filtering).
+  // Use when full=true but you still want capture progress updates on a commit.
+  metadataCommit?: Commit | null;
 }
 
 export default async function orchestrateCapture({
@@ -62,6 +65,7 @@ export default async function orchestrateCapture({
   taskRunner,
   analysisLoader,
   pollingInterval = POLLING_INTERVAL,
+  metadataCommit,
 }: OrchestrateCaptureArgs) {
   if (!full && !analysisIds && !commit && !entityShas) {
     throw new Error(
@@ -318,9 +322,12 @@ export default async function orchestrateCapture({
         // console.log(
         //   `Codeyam Debug: All known analyses: ${Array.from(knownAnalyses).join(', ')}`,
         // );
-        if (commit) {
-          commit.metadata = await updateCommitMetadata({
-            commitId: commit.id,
+        // Use metadataCommit if provided, otherwise fall back to commit.
+        // This allows progress tracking even when commit is null (e.g., full=true mode).
+        const trackingCommit = metadataCommit ?? commit;
+        if (trackingCommit) {
+          trackingCommit.metadata = await updateCommitMetadata({
+            commitId: trackingCommit.id,
             runStatusUpdate: {
               readyToBeCaptured: knownAnalyses.size,
               capturesAttempted: capturedAnalysisIds.length + abandoned.length,
@@ -348,6 +355,32 @@ export default async function orchestrateCapture({
         }
       }
 
+      // Early exit when all enqueued work is settled (captured or abandoned)
+      // This avoids waiting for the 20-minute ANALYSIS_TIMEOUT when capture is complete
+      // IMPORTANT: Only check this when isDraining (analysis phase complete) to avoid
+      // exiting while slow-running analyses are still in progress
+      if (
+        isDraining &&
+        !firstLoop &&
+        enqueuedAnalyses.size > 0 &&
+        inFlight.size === 0 &&
+        remaining.length === 0 &&
+        toRetry.length === 0
+      ) {
+        const allAnalysesSettled = Array.from(enqueuedAnalyses).every((id) => {
+          const captured = !allReadyAnalysisIds.includes(id);
+          const abandoned = (attemptCount.get(id) || 0) >= maxAttempts;
+          return captured || abandoned;
+        });
+
+        if (allAnalysesSettled) {
+          console.log(
+            'CodeYam Capture: All enqueued analyses settled (captured or abandoned), exiting early',
+          );
+          break;
+        }
+      }
+
       if (isDraining) {
         // Exit if analysis complete but no entities ready for capture
         // Only check this after at least one poll (not firstLoop) to ensure we've

package/analyzer-template/project/reconcileMockDataKeys.ts

@@ -5,51 +5,49 @@
  * (e.g., "eq('user_id', 'user-12345')") when the mock code expects variable
  * references (e.g., "eq('user_id', user.id)").
  *
- * This function also handles canonical key format (EntityName::hookName::index)
- * and remaps old variable-based keys (variableName <- functionName) to canonical keys.
+ * Keys are now original call signatures (e.g., "useFetcher<User>()", "db.select(query)").
+ *
+ * Also handles flat dotted keys (e.g., "trpc.fastener.getAttributeValues.useQuery(...)")
+ * by converting them to nested structure.
  *
  * @param mockData The mock data object to reconcile
  * @param expectedKeys The expected keys from the structure
- * @param entityName Optional entity name for canonical key remapping
  */
 export function reconcileMockDataKeys(
   mockData: Record<string, unknown>,
   expectedKeys: string[],
-  entityName?: string,
 ): Record<string, unknown> {
   const result: Record<string, unknown> = {};
-  // Track which canonical keys have been used for multiple calls to same hook
-  const usedCanonicalKeys = new Set<string>();
 
   for (const [key, value] of Object.entries(mockData)) {
     // Recursively reconcile nested objects
     const reconciledValue =
       value && typeof value === 'object' && !Array.isArray(value)
-        ? reconcileMockDataKeys(
-            value as Record<string, unknown>,
-            expectedKeys,
-            entityName,
-          )
+        ? reconcileMockDataKeys(value as Record<string, unknown>, expectedKeys)
         : value;
 
     // Check if key matches an expected key exactly
     if (expectedKeys.includes(key)) {
       result[key] = reconciledValue;
-      usedCanonicalKeys.add(key);
       continue;
     }
 
-    // Try to remap variable-based key to canonical key
-    if (entityName) {
-      const canonicalKey = remapToCanonicalKey(
-        key,
-        expectedKeys,
-        entityName,
-        usedCanonicalKeys,
+    // Check if this is a flat dotted key that should be converted to nested structure
+    // e.g., "trpc.fastener.getAttributeValues.useQuery({ ... })"
+    const flatKeyParts = parseFlatDottedKey(key);
+    if (flatKeyParts && flatKeyParts.length > 1) {
+      // Check if the parts match expected keys (indicating this should be nested)
+      const partsMatchExpected = flatKeyParts.some((part) =>
+        expectedKeys.includes(part),
       );
-      if (canonicalKey) {
-        result[canonicalKey] = reconciledValue;
-        usedCanonicalKeys.add(canonicalKey);
+      if (partsMatchExpected) {
+        // Convert flat key to nested structure and merge
+        deepMergeIntoResult(
+          result,
+          flatKeyParts,
+          reconciledValue,
+          expectedKeys,
+        );
         continue;
       }
     }
@@ -68,76 +66,91 @@ export function reconcileMockDataKeys(
 }
 
 /**
- * Attempt to remap a variable-based key to a canonical key.
- *
- * Variable-based format: "variableName <- functionName"
- * Canonical format: "EntityName::hookName::index"
+ * Parse a flat dotted key into path segments.
+ * Handles keys like "trpc.fastener.getAttributeValues.useQuery({ ... })"
+ * where the last part might contain parentheses with function arguments.
  *
- * @example
- * remapToCanonicalKey("currentCommit <- useLoaderData", ["DashboardPage::useLoaderData::0"], "DashboardPage", new Set())
- * // returns "DashboardPage::useLoaderData::0"
+ * Returns null if the key doesn't look like a dotted path.
  */
-function remapToCanonicalKey(
-  key: string,
-  expectedCanonicalKeys: string[],
-  entityName: string,
-  usedKeys: Set<string>,
-): string | null {
-  // Check if key is in variable-based format: "varName <- functionName"
-  const arrowMatch = key.match(/<-\s*(\w+)/);
-  if (!arrowMatch) {
-    // Not a variable-based key, try other patterns
-    // Check if it's a simple function call like "useLoaderData()"
-    const funcCallMatch = key.match(/^(\w+)\(\)/);
-    if (funcCallMatch) {
-      const hookName = funcCallMatch[1];
-      return findMatchingCanonicalKey(
-        hookName,
-        entityName,
-        expectedCanonicalKeys,
-        usedKeys,
-      );
+function parseFlatDottedKey(key: string): string[] | null {
+  // Don't treat keys that start with a function call as dotted paths
+  // e.g., "useQuery({ id: 123 })" should not be parsed
+  if (key.match(/^[a-zA-Z_][a-zA-Z0-9_]*\s*\(/)) {
+    // Check if there's a dot BEFORE the first parenthesis
+    const parenIndex = key.indexOf('(');
+    const dotBeforeParen = key.slice(0, parenIndex).includes('.');
+    if (!dotBeforeParen) {
+      return null;
     }
+  }
+
+  // Must contain a dot to be a dotted path
+  if (!key.includes('.')) {
     return null;
   }
 
-  const hookName = arrowMatch[1];
+  const parts: string[] = [];
+  let current = '';
+  let depth = 0;
+
+  for (let i = 0; i < key.length; i++) {
+    const char = key[i];
 
-  return findMatchingCanonicalKey(
-    hookName,
-    entityName,
-    expectedCanonicalKeys,
-    usedKeys,
-  );
+    if (char === '(' || char === '{' || char === '[') {
+      depth++;
+      current += char;
+    } else if (char === ')' || char === '}' || char === ']') {
+      depth--;
+      current += char;
+    } else if (char === '.' && depth === 0) {
+      if (current) {
+        parts.push(current);
+      }
+      current = '';
+    } else {
+      current += char;
+    }
+  }
+
+  if (current) {
+    parts.push(current);
+  }
+
+  // Need at least 2 parts for it to be a meaningful dotted path
+  return parts.length >= 2 ? parts : null;
 }
 
 /**
- * Find a matching canonical key for a hook name within an entity.
+ * Deep merge a value into the result object following the path segments.
+ * Reconciles the leaf key against expected keys.
  */
-function findMatchingCanonicalKey(
-  hookName: string,
-  entityName: string,
-  expectedCanonicalKeys: string[],
-  usedKeys: Set<string>,
-): string | null {
-  // Find all canonical keys for this entity and hook
-  const candidatePrefix = `${entityName}::${hookName}::`;
-  const candidates = expectedCanonicalKeys.filter(
-    (k) => k.startsWith(candidatePrefix) && !usedKeys.has(k),
-  );
+function deepMergeIntoResult(
+  result: Record<string, unknown>,
+  parts: string[],
+  value: unknown,
+  expectedKeys: string[],
+): void {
+  let current = result;
 
-  if (candidates.length === 0) {
-    return null;
+  // Navigate/create path for all but the last part
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in current)) {
+      current[part] = {};
+    }
+    const next = current[part];
+    if (next && typeof next === 'object' && !Array.isArray(next)) {
+      current = next as Record<string, unknown>;
+    } else {
+      // Can't traverse further, structure mismatch
+      return;
+    }
   }
 
-  // Sort by index to prefer lower indices
-  candidates.sort((a, b) => {
-    const aIndex = parseInt(a.split('::')[2], 10);
-    const bIndex = parseInt(b.split('::')[2], 10);
-    return aIndex - bIndex;
-  });
-
-  return candidates[0];
+  // Handle the leaf key
+  const leafKey = parts[parts.length - 1];
+  const closestLeafKey = findClosestKey(leafKey, expectedKeys) || leafKey;
+  current[closestLeafKey] = value;
 }
 
 /**
@@ -148,9 +161,15 @@ function findMatchingCanonicalKey(
  * - Ignore the last argument value (could be literal or variable)
  * - Match based on the common prefix
  * - If key has no parentheses, try matching with "()" appended
+ * - If key is "funcName()" (empty args), match expected key "funcName({...})" by function name
+ * - If key has object arguments (like useQuery({...})), match by function name
+ * - If key has single argument with literal value, match by function name
  *
  * e.g., "eq('user_id', 'user-12345')" matches "eq('user_id', user.id)"
  * e.g., "getAll" matches "getAll()"
+ * e.g., "getSurveysAction()" matches "getSurveysAction({ environmentId, ... })"
+ * e.g., "useQuery({ id: 123 })" matches "useQuery({ id: Number(id) })"
+ * e.g., "useCustomSizes('example-slug')" matches "useCustomSizes(projectSlug)"
  */
 function findClosestKey(key: string, expectedKeys: string[]): string | null {
   const keyBase = extractKeyBase(key);
@@ -174,9 +193,132 @@ function findClosestKey(key: string, expectedKeys: string[]): string | null {
     }
   }
 
+  // If key is "funcName()" (empty args), try matching expected key "funcName({...})"
+  // This handles the case where LLM generates "getSurveysAction()" but expected key
+  // is "getSurveysAction({ environmentId, limit, ... })" with an object argument
+  const emptyArgsMatch = key.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\(\)$/);
+  if (emptyArgsMatch) {
+    const funcName = emptyArgsMatch[1];
+    for (const expected of expectedKeys) {
+      // Match if expected key starts with the same function name and has args
+      const expectedMatch = expected.match(
+        new RegExp(`^${escapeRegExp(funcName)}\\([^)]+\\)$`),
+      );
+      if (expectedMatch) {
+        return expected;
+      }
+    }
+  }
+
+  // If key has object literal arguments (like "useQuery({ id: 123, ... })"),
+  // try matching expected keys with the same function path AND first object property.
+  // This handles cases where LLM generates literal values but expected keys have variable references.
+  // e.g., "useQuery({ attributes: ['a', 'b'] })" matches "useQuery({ attributes: items || [] })"
+  // e.g., "trpc.users.getById.useQuery({ userId: 'user-123' })" matches "trpc.users.getById.useQuery({ userId })"
+  // Uses first property matching when multiple candidates exist for disambiguation.
+  const objectArgMatch = key.match(/^([a-zA-Z_][a-zA-Z0-9_.]*)\s*\(\s*\{/);
+  if (objectArgMatch) {
+    const funcPath = objectArgMatch[1]; // Can be "funcName" or "path.to.funcName"
+    // Extract the first property name from the object argument
+    const firstPropMatch = key.match(
+      /\(\s*\{\s*\n?\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*:/,
+    );
+    const firstProp = firstPropMatch ? firstPropMatch[1] : null;
+
+    // Collect all matching candidates
+    const candidates: string[] = [];
+    for (const expected of expectedKeys) {
+      // Match if expected key has the same function path and starts with object argument
+      const expectedObjArgMatch = expected.match(
+        new RegExp(`^${escapeRegExp(funcPath)}\\s*\\(\\s*\\{`),
+      );
+      if (expectedObjArgMatch) {
+        candidates.push(expected);
+      }
+    }
+
+    // If we have a first property, prefer matching by property name
+    if (firstProp && candidates.length > 1) {
+      // Look for a candidate with the same first property
+      const propRegex = new RegExp(
+        `\\(\\s*\\{[\\s\\n]*${escapeRegExp(firstProp)}\\s*:`,
+      );
+      const propMatch = candidates.find((c) => propRegex.test(c));
+      if (propMatch) {
+        return propMatch;
+      }
+    }
+
+    // Fall back to first candidate if no property match found
+    if (candidates.length > 0) {
+      return candidates[0];
+    }
+  }
+
+  // If key has a single argument (literal value OR variable reference),
+  // try matching expected keys with the same function name but different argument.
+  // This handles cases where:
+  // - LLM generates "useCustomSizes('example-slug')" but expected key is "useCustomSizes(projectSlug)"
+  // - LLM generates "useCustomSizes(someProjectSlug)" but expected key is "useCustomSizes(projectSlug)"
+  //
+  // The second case is important because when LLM generates multiple keys with different
+  // variable names (e.g., "useCustomSizes(someProjectSlug)" and "useCustomSizes(projectSlug)"),
+  // without reconciliation, normalizeMockData merges them into "useCustomSizes()" which
+  // doesn't match the expected key "useCustomSizes(projectSlug)", causing undefined data access.
+  const singleArgMatch = key.match(
+    /^([a-zA-Z_][a-zA-Z0-9_.]*)\s*\(([^,)]+)\)$/,
+  );
+  if (singleArgMatch) {
+    const funcPath = singleArgMatch[1];
+    const arg = singleArgMatch[2].trim();
+    // Apply this matching if the argument is a literal OR a simple variable reference
+    const isLiteralArg = /^['"`].*['"`]$/.test(arg) || /^\d+$/.test(arg);
+    const isVariableRef = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(arg);
+    if (isLiteralArg || isVariableRef) {
+      for (const expected of expectedKeys) {
+        // Match if expected key has the same function path with a single argument
+        const expectedSingleArgMatch = expected.match(
+          new RegExp(`^${escapeRegExp(funcPath)}\\s*\\([^,)]+\\)$`),
+        );
+        if (expectedSingleArgMatch) {
+          return expected;
+        }
+      }
+    }
+  }
+
+  // If key has multiple arguments where one contains a literal value,
+  // try matching expected keys with the same function name and argument count.
+  // This handles cases like "getScenarioDisplayState(scenario, undefined, undefined, 'entitysha123', undefined)"
+  // matching "getScenarioDisplayState(scenario, undefined, undefined, entitySha, undefined)"
+  const multiArgWithLiteralMatch = key.match(
+    /^([a-zA-Z_][a-zA-Z0-9_.]*)\s*\((.+)\)$/,
+  );
+  if (multiArgWithLiteralMatch) {
+    const funcPath = multiArgWithLiteralMatch[1];
+    const argsStr = multiArgWithLiteralMatch[2];
+    // Check if any argument is a string literal
+    const hasLiteralArg = /'[^']*'|"[^"]*"/.test(argsStr);
+    if (hasLiteralArg) {
+      for (const expected of expectedKeys) {
+        // Match if expected key starts with the same function path
+        if (expected.startsWith(funcPath + '(')) {
+          return expected;
+        }
+      }
+    }
+  }
+
   return null;
 }
 
+/**
+ * Escape special regex characters in a string.
+ */
+function escapeRegExp(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 /**
  * Normalize quotes in a string: convert double quotes to single quotes.
  * This handles cases where the LLM generates keys with double quotes

package/analyzer-template/project/runAnalysis.ts

@@ -215,6 +215,11 @@ export default async function runAnalysis({
       entityShas,
       branchName: branch?.name,
     });
+
+    // Propagate the fallback branch to branchCommit so downstream code can use it
+    if (branchCommit && branch) {
+      branchCommit.branch = branch;
+    }
   }
 
   // After this block, 'commit' is the union of a regular or baseline commit
@@ -308,6 +313,10 @@ export default async function runAnalysis({
   // Route to appropriate analyzer
   try {
     if (runReadyToBeCapturedPath) {
+      // Signal that analysis can produce captures immediately since analyses are already ready.
+      // This is needed for recapture to work - orchestration waits for the 'analysisProducing' event.
+      controller?.setAnalysisProducingPhase();
+
       return await analyzeReadyToBeCaptured({
         project,
         projectAnalyzer,
@@ -330,6 +339,7 @@ export default async function runAnalysis({
         desiredAnalyses,
         force,
         fileStore,
+        onAnalysisProducing: () => controller?.setAnalysisProducingPhase(),
       });
     }
 
@@ -350,6 +360,7 @@ export default async function runAnalysis({
       backgroundJob,
       desiredAnalyses,
       fileStore,
+      onAnalysisProducing: () => controller?.setAnalysisProducingPhase(),
     });
   } catch (e) {
     awsLog('CodeYam Error: Analysis failed', {