@@ -0,0 +1,52 @@
+import { db } from '@db/server';
+
+/**
+ * Resolves framework IDs for an organization by:
+ * 1. Checking for a raw frameworkIds context entry (JSON array, saved by newer code)
+ * 2. Falling back to reverse-looking framework names from the onboarding context
+ */
+export async function resolveFrameworkIds(organizationId: string): Promise<string[]> {
+  // Try the raw IDs context entry first (saved by newer createOrganizationMinimal)
+  const rawIdsContext = await db.context.findFirst({
+    where: {
+      organizationId,
+      question: 'frameworkIds',
+      tags: { has: 'onboarding' },
+    },
+  });
+
+  if (rawIdsContext?.answer) {
+    try {
+      const ids = JSON.parse(rawIdsContext.answer);
+      if (Array.isArray(ids) && ids.length > 0) {
+        return ids;
+      }
+    } catch {
+      // Fall through to name-based lookup
+    }
+  }
+
+  // Fall back to reverse-looking from framework names
+  const frameworkContext = await db.context.findFirst({
+    where: {
+      organizationId,
+      question: 'Which compliance frameworks do you need?',
+      tags: { has: 'onboarding' },
+    },
+  });
+
+  if (!frameworkContext?.answer) {
+    return [];
+  }
+
+  const frameworkNames = frameworkContext.answer.split(',').map((name) => name.trim());
+
+  const frameworks = await db.frameworkEditorFramework.findMany({
+    where: {
+      name: { in: frameworkNames, mode: 'insensitive' },
+    },
+    select: { id: true },
+  });
+
+  return frameworks.map((f) => f.id);
+}
@@ -1,5 +1,7 @@
 'use server';
 
+import { initializeOrganization } from '@/actions/organization/lib/initialize-organization';
+import { resolveFrameworkIds } from '@/actions/organization/lib/resolve-framework-ids';
 import { authActionClientWithoutOrg } from '@/actions/safe-action';
 import { steps } from '@/app/(app)/setup/lib/constants';
 import { createFleetLabelForOrg } from '@/trigger/tasks/device/create-fleet-label-for-org';
@@ -155,6 +157,43 @@ export const completeOnboarding = authActionClientWithoutOrg
         data: { onboardingCompleted: true },
       });
 
+      // Ensure framework structure exists before triggering the onboard job.
+      // If createOrganizationMinimal partially failed (org created but
+      // initializeOrganization didn't run), recover by initializing now.
+      const existingFrameworks = await db.frameworkInstance.findFirst({
+        where: { organizationId: parsedInput.organizationId },
+      });
+
+      if (!existingFrameworks) {
+        console.warn(
+          `[complete-onboarding] No framework instances found for org ${parsedInput.organizationId}, running initializeOrganization as recovery`,
+        );
+
+        const frameworkIds = await resolveFrameworkIds(parsedInput.organizationId);
+
+        if (frameworkIds.length > 0) {
+          await initializeOrganization({
+            frameworkIds,
+            organizationId: parsedInput.organizationId,
+          });
+        } else {
+          console.error(
+            `[complete-onboarding] Could not resolve framework IDs for org ${parsedInput.organizationId}`,
+          );
+        }
+      }
+
+      // Ensure onboarding record exists (may be missing if createOrganizationMinimal
+      // failed before creating it).
+      await db.onboarding.upsert({
+        where: { organizationId: parsedInput.organizationId },
+        create: {
+          organizationId: parsedInput.organizationId,
+          triggerJobCompleted: false,
+        },
+        update: {},
+      });
+
       // Now trigger the jobs that were skipped during minimal creation
       const handle = await tasks.trigger<typeof onboardOrganizationTask>('onboard-organization', {
         organizationId: parsedInput.organizationId,
@@ -208,3 +247,4 @@ export const completeOnboarding = authActionClientWithoutOrg
       };
     }
   });
+
@@ -134,12 +134,21 @@ export const createOrganizationMinimal = authActionClientWithoutOrg
               role: 'owner',
             },
           },
-          // Only save the context for frameworkIds (we need this for later)
+          // Save framework context: display names for AI prompts + raw IDs for recovery
           context: {
-            create: {
-              question: 'Which compliance frameworks do you need?',
-              answer: frameworkNames || parsedInput.frameworkIds.join(', '),
-              tags: ['onboarding'],
+            createMany: {
+              data: [
+                {
+                  question: 'Which compliance frameworks do you need?',
+                  answer: frameworkNames || parsedInput.frameworkIds.join(', '),
+                  tags: ['onboarding'],
+                },
+                {
+                  question: 'frameworkIds',
+                  answer: JSON.stringify(parsedInput.frameworkIds),
+                  tags: ['onboarding'],
+                },
+              ],
             },
           },
         },
 
@@ -0,0 +1,66 @@
+import { initializeOrganization } from '@/actions/organization/lib/initialize-organization';
+import { resolveFrameworkIds } from '@/actions/organization/lib/resolve-framework-ids';
+import { db } from '@db/server';
+import { logger, queue, tags, task } from '@trigger.dev/sdk';
+
+const initOrgQueue = queue({
+  name: 'initialize-organization',
+  concurrencyLimit: 10,
+});
+
+/**
+ * Standalone Trigger.dev task for initializing an organization's framework
+ * structure (framework instances, controls, policies, tasks, requirement maps).
+ *
+ * Use cases:
+ * - Manual re-run from the Trigger.dev dashboard for orgs stuck in a partial state
+ * - Automatic recovery when `completeOnboarding` detects missing framework instances
+ *
+ * Accepts optional `frameworkIds`. When omitted, resolves them by reverse-looking
+ * framework names stored in the organization's onboarding context.
+ */
+export const initializeOrganizationTask = task({
+  id: 'initialize-organization',
+  queue: initOrgQueue,
+  retry: {
+    maxAttempts: 3,
+  },
+  run: async (payload: { organizationId: string; frameworkIds?: string[] }) => {
+    const { organizationId } = payload;
+    await tags.add([`org:${organizationId}`]);
+
+    logger.info(`Initializing organization ${organizationId}`);
+
+    // Check if already initialized
+    const existingFrameworks = await db.frameworkInstance.findFirst({
+      where: { organizationId },
+    });
+
+    if (existingFrameworks) {
+      logger.info(
+        `Organization ${organizationId} already has framework instances, skipping initialization`,
+      );
+      return { skipped: true, reason: 'already_initialized' };
+    }
+
+    // Resolve framework IDs
+    const frameworkIds = payload.frameworkIds ?? (await resolveFrameworkIds(organizationId));
+
+    if (frameworkIds.length === 0) {
+      logger.error(`No framework IDs found for organization ${organizationId}`);
+      throw new Error(
+        `Cannot initialize organization ${organizationId}: no framework IDs found in context`,
+      );
+    }
+
+    logger.info(
+      `Initializing organization ${organizationId} with frameworks: ${frameworkIds.join(', ')}`,
+    );
+
+    await initializeOrganization({ frameworkIds, organizationId });
+
+    logger.info(`Successfully initialized organization ${organizationId}`);
+    return { skipped: false, frameworkIds };
+  },
+});
+